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.

6 files changed, 45 insertions, 45 deletions

diff --git a/extmod/modmachine.c b/extmod/modmachine.c
index 5e54b2272..675a32086 100644
--- a/extmod/modmachine.c
+++ b/extmod/modmachine.c
@@ -77,13 +77,13 @@ typedef struct _machine_mem_obj_t {
 
 STATIC void machine_mem_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
-    machine_mem_obj_t *self = self_in;
+    machine_mem_obj_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "<%u-bit memory>", 8 * self->elem_size);
 }
 
 STATIC mp_obj_t machine_mem_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     // TODO support slice index to read/write multiple values at once
-    machine_mem_obj_t *self = self_in;
+    machine_mem_obj_t *self = MP_OBJ_TO_PTR(self_in);
     if (value == MP_OBJ_NULL) {
         // delete
         return MP_OBJ_NULL; // op not supported
diff --git a/extmod/moductypes.c b/extmod/moductypes.c
index 9dcaf4469..559339a7a 100644
--- a/extmod/moductypes.c
+++ b/extmod/moductypes.c
@@ -124,24 +124,24 @@ STATIC NORETURN void syntax_error(void) {
 STATIC mp_obj_t uctypes_struct_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 2, 3, false);
     mp_obj_uctypes_struct_t *o = m_new_obj(mp_obj_uctypes_struct_t);
-    o->base.type = type_in;
-    o->addr = (void*)mp_obj_get_int(args[0]);
+    o->base.type = MP_OBJ_TO_PTR(type_in);
+    o->addr = (void*)(uintptr_t)mp_obj_get_int(args[0]);
     o->desc = args[1];
     o->flags = LAYOUT_NATIVE;
     if (n_args == 3) {
         o->flags = mp_obj_get_int(args[2]);
     }
-    return o;
+    return MP_OBJ_FROM_PTR(o);
 }
 
 STATIC void uctypes_struct_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
-    mp_obj_uctypes_struct_t *self = self_in;
+    mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
     const char *typen = "unk";
     if (MP_OBJ_IS_TYPE(self->desc, &mp_type_dict)) {
         typen = "STRUCT";
     } else if (MP_OBJ_IS_TYPE(self->desc, &mp_type_tuple)) {
-        mp_obj_tuple_t *t = (mp_obj_tuple_t*)self->desc;
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc);
         mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(t->items[0]);
         uint agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
         switch (agg_type) {
@@ -207,12 +207,9 @@ STATIC mp_uint_t uctypes_struct_agg_size(mp_obj_tuple_t *t, mp_uint_t *max_field
 }
 
 STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, mp_uint_t *max_field_size) {
-    mp_obj_dict_t *d = desc_in;
-    mp_uint_t total_size = 0;
-
     if (!MP_OBJ_IS_TYPE(desc_in, &mp_type_dict)) {
         if (MP_OBJ_IS_TYPE(desc_in, &mp_type_tuple)) {
-            return uctypes_struct_agg_size((mp_obj_tuple_t*)desc_in, max_field_size);
+            return uctypes_struct_agg_size((mp_obj_tuple_t*)MP_OBJ_TO_PTR(desc_in), max_field_size);
         } else if (MP_OBJ_IS_SMALL_INT(desc_in)) {
             // We allow sizeof on both type definitions and structures/structure fields,
             // but scalar structure field is lowered into native Python int, so all
@@ -223,6 +220,9 @@ STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, mp_uint_t *max_field_size
         syntax_error();
     }
 
+    mp_obj_dict_t *d = MP_OBJ_TO_PTR(desc_in);
+    mp_uint_t total_size = 0;
+
     for (mp_uint_t i = 0; i < d->map.alloc; i++) {
         if (MP_MAP_SLOT_IS_FILLED(&d->map, i)) {
             mp_obj_t v = d->map.table[i].value;
@@ -241,7 +241,7 @@ STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, mp_uint_t *max_field_size
                 if (!MP_OBJ_IS_TYPE(v, &mp_type_tuple)) {
                     syntax_error();
                 }
-                mp_obj_tuple_t *t = (mp_obj_tuple_t*)v;
+                mp_obj_tuple_t *t = MP_OBJ_TO_PTR(v);
                 mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(t->items[0]);
                 offset &= VALUE_MASK(AGG_TYPE_BITS);
                 mp_uint_t s = uctypes_struct_agg_size(t, max_field_size);
@@ -266,7 +266,7 @@ STATIC mp_obj_t uctypes_struct_sizeof(mp_obj_t obj_in) {
     // or to instantiated structure
     if (MP_OBJ_IS_TYPE(obj_in, &uctypes_struct_type)) {
         // Extract structure definition
-        mp_obj_uctypes_struct_t *obj = obj_in;
+        mp_obj_uctypes_struct_t *obj = MP_OBJ_TO_PTR(obj_in);
         obj_in = obj->desc;
     }
     mp_uint_t size = uctypes_struct_size(obj_in, &max_field_size);
@@ -365,7 +365,7 @@ STATIC void set_aligned(uint val_type, void *p, mp_int_t index, mp_obj_t val) {
 }
 
 STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set_val) {
-    mp_obj_uctypes_struct_t *self = self_in;
+    mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
 
     // TODO: Support at least OrderedDict in addition
     if (!MP_OBJ_IS_TYPE(self->desc, &mp_type_dict)) {
@@ -443,7 +443,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
         syntax_error();
     }
 
-    mp_obj_tuple_t *sub = (mp_obj_tuple_t*)deref;
+    mp_obj_tuple_t *sub = MP_OBJ_TO_PTR(deref);
     mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(sub->items[0]);
     mp_uint_t agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
     offset &= VALUE_MASK(AGG_TYPE_BITS);
@@ -456,7 +456,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
             o->desc = sub->items[1];
             o->addr = self->addr + offset;
             o->flags = self->flags;
-            return o;
+            return MP_OBJ_FROM_PTR(o);
         }
         case ARRAY: {
             mp_uint_t dummy;
@@ -468,11 +468,11 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
         case PTR: {
             mp_obj_uctypes_struct_t *o = m_new_obj(mp_obj_uctypes_struct_t);
             o->base.type = &uctypes_struct_type;
-            o->desc = sub;
+            o->desc = MP_OBJ_FROM_PTR(sub);
             o->addr = self->addr + offset;
             o->flags = self->flags;
 //printf("PTR/ARR base addr=%p\n", o->addr);
-            return o;
+            return MP_OBJ_FROM_PTR(o);
         }
     }
 
@@ -494,7 +494,7 @@ STATIC void uctypes_struct_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 }
 
 STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value) {
-    mp_obj_uctypes_struct_t *self = self_in;
+    mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
 
     if (value == MP_OBJ_NULL) {
         // delete
@@ -505,7 +505,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
             nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "struct: cannot index"));
         }
 
-        mp_obj_tuple_t *t = (mp_obj_tuple_t*)self->desc;
+        mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc);
         mp_int_t offset = MP_OBJ_SMALL_INT_VALUE(t->items[0]);
         uint agg_type = GET_TYPE(offset, AGG_TYPE_BITS);
 
@@ -530,7 +530,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
                 o->desc = t->items[2];
                 o->addr = self->addr + size * index;
                 o->flags = self->flags;
-                return o;
+                return MP_OBJ_FROM_PTR(o);
             }
         } else if (agg_type == PTR) {
             byte *p = *(void**)self->addr;
@@ -545,7 +545,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
                 o->desc = t->items[1];
                 o->addr = p + size * index;
                 o->flags = self->flags;
-                return o;
+                return MP_OBJ_FROM_PTR(o);
             }
         }
 
@@ -559,7 +559,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
 
 STATIC mp_int_t uctypes_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
     (void)flags;
-    mp_obj_uctypes_struct_t *self = self_in;
+    mp_obj_uctypes_struct_t *self = MP_OBJ_TO_PTR(self_in);
     mp_uint_t max_field_size = 0;
     mp_uint_t size = uctypes_struct_size(self->desc, &max_field_size);
 
@@ -575,7 +575,7 @@ STATIC mp_int_t uctypes_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo,
 STATIC mp_obj_t uctypes_struct_addressof(mp_obj_t buf) {
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(buf, &bufinfo, MP_BUFFER_READ);
-    return mp_obj_new_int((mp_int_t)bufinfo.buf);
+    return mp_obj_new_int((mp_int_t)(uintptr_t)bufinfo.buf);
 }
 MP_DEFINE_CONST_FUN_OBJ_1(uctypes_struct_addressof_obj, uctypes_struct_addressof);
 
@@ -584,7 +584,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(uctypes_struct_addressof_obj, uctypes_struct_addressof
 /// captured by reference (and thus memory pointed by bytearray may change
 /// or become invalid at later time). Use bytes_at() to capture by value.
 STATIC mp_obj_t uctypes_struct_bytearray_at(mp_obj_t ptr, mp_obj_t size) {
-    return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void*)mp_obj_int_get_truncated(ptr));
+    return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void*)(uintptr_t)mp_obj_int_get_truncated(ptr));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytearray_at_obj, uctypes_struct_bytearray_at);
 
@@ -593,7 +593,7 @@ MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytearray_at_obj, uctypes_struct_bytear
 /// captured by value, i.e. copied. Use bytearray_at() to capture by reference
 /// ("zero copy").
 STATIC mp_obj_t uctypes_struct_bytes_at(mp_obj_t ptr, mp_obj_t size) {
-    return mp_obj_new_bytes((void*)mp_obj_int_get_truncated(ptr), mp_obj_int_get_truncated(size));
+    return mp_obj_new_bytes((void*)(uintptr_t)mp_obj_int_get_truncated(ptr), mp_obj_int_get_truncated(size));
 }
 MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytes_at_obj, uctypes_struct_bytes_at);
 
diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index 8df96be3c..7b0d25e80 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -44,16 +44,16 @@ STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg);
 STATIC mp_obj_t hash_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
     mp_arg_check_num(n_args, n_kw, 0, 1, false);
     mp_obj_hash_t *o = m_new_obj_var(mp_obj_hash_t, char, sizeof(SHA256_CTX));
-    o->base.type = type_in;
+    o->base.type = MP_OBJ_TO_PTR(type_in);
     sha256_init((SHA256_CTX*)o->state);
     if (n_args == 1) {
-        hash_update(o, args[0]);
+        hash_update(MP_OBJ_FROM_PTR(o), args[0]);
     }
-    return o;
+    return MP_OBJ_FROM_PTR(o);
 }
 
 STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg) {
-    mp_obj_hash_t *self = self_in;
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(arg, &bufinfo, MP_BUFFER_READ);
     sha256_update((SHA256_CTX*)self->state, bufinfo.buf, bufinfo.len);
@@ -62,7 +62,7 @@ STATIC mp_obj_t hash_update(mp_obj_t self_in, mp_obj_t arg) {
 MP_DEFINE_CONST_FUN_OBJ_2(hash_update_obj, hash_update);
 
 STATIC mp_obj_t hash_digest(mp_obj_t self_in) {
-    mp_obj_hash_t *self = self_in;
+    mp_obj_hash_t *self = MP_OBJ_TO_PTR(self_in);
     vstr_t vstr;
     vstr_init_len(&vstr, SHA256_BLOCK_SIZE);
     sha256_final((SHA256_CTX*)self->state, (byte*)vstr.buf);
diff --git a/extmod/moduheapq.c b/extmod/moduheapq.c
index c0d3c6376..84ffe54f9 100644
--- a/extmod/moduheapq.c
+++ b/extmod/moduheapq.c
@@ -37,7 +37,7 @@ STATIC mp_obj_list_t *get_heap(mp_obj_t heap_in) {
     if (!MP_OBJ_IS_TYPE(heap_in, &mp_type_list)) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "heap must be a list"));
     }
-    return heap_in;
+    return MP_OBJ_TO_PTR(heap_in);
 }
 
 STATIC void heap_siftdown(mp_obj_list_t *heap, mp_uint_t start_pos, mp_uint_t pos) {
@@ -74,7 +74,7 @@ STATIC void heap_siftup(mp_obj_list_t *heap, mp_uint_t pos) {
 
 STATIC mp_obj_t mod_uheapq_heappush(mp_obj_t heap_in, mp_obj_t item) {
     mp_obj_list_t *heap = get_heap(heap_in);
-    mp_obj_list_append(heap, item);
+    mp_obj_list_append(heap_in, item);
     heap_siftdown(heap, 0, heap->len - 1);
     return mp_const_none;
 }
diff --git a/extmod/modujson.c b/extmod/modujson.c
index 68ed26471..4e080c975 100644
--- a/extmod/modujson.c
+++ b/extmod/modujson.c
@@ -222,7 +222,7 @@ STATIC mp_obj_t mod_ujson_loads(mp_obj_t obj) {
                     mp_obj_list_init(&stack, 1);
                     stack.items[0] = stack_top;
                 } else {
-                    mp_obj_list_append(&stack, stack_top);
+                    mp_obj_list_append(MP_OBJ_FROM_PTR(&stack), stack_top);
                 }
                 stack_top = next;
                 stack_top_type = mp_obj_get_type(stack_top);
diff --git a/extmod/modure.c b/extmod/modure.c
index ef946ea98..5843569a5 100644
--- a/extmod/modure.c
+++ b/extmod/modure.c
@@ -53,12 +53,12 @@ typedef struct _mp_obj_match_t {
 
 STATIC void match_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
-    mp_obj_match_t *self = self_in;
+    mp_obj_match_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "<match num=%d>", self->num_matches);
 }
 
 STATIC mp_obj_t match_group(mp_obj_t self_in, mp_obj_t no_in) {
-    mp_obj_match_t *self = self_in;
+    mp_obj_match_t *self = MP_OBJ_TO_PTR(self_in);
     mp_int_t no = mp_obj_get_int(no_in);
     if (no < 0 || no >= self->num_matches) {
         nlr_raise(mp_obj_new_exception_arg1(&mp_type_IndexError, no_in));
@@ -83,18 +83,18 @@ STATIC const mp_obj_type_t match_type = {
     { &mp_type_type },
     .name = MP_QSTR_match,
     .print = match_print,
-    .locals_dict = (mp_obj_t)&match_locals_dict,
+    .locals_dict = (void*)&match_locals_dict,
 };
 
 STATIC void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
-    mp_obj_re_t *self = self_in;
+    mp_obj_re_t *self = MP_OBJ_TO_PTR(self_in);
     mp_printf(print, "<re %p>", self);
 }
 
 STATIC mp_obj_t re_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
     (void)n_args;
-    mp_obj_re_t *self = args[0];
+    mp_obj_re_t *self = MP_OBJ_TO_PTR(args[0]);
     Subject subj;
     mp_uint_t len;
     subj.begin = mp_obj_str_get_data(args[1], &len);
@@ -112,7 +112,7 @@ STATIC mp_obj_t re_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
     match->base.type = &match_type;
     match->num_matches = caps_num / 2; // caps_num counts start and end pointers
     match->str = args[1];
-    return match;
+    return MP_OBJ_FROM_PTR(match);
 }
 
 STATIC mp_obj_t re_match(mp_uint_t n_args, const mp_obj_t *args) {
@@ -126,7 +126,7 @@ STATIC mp_obj_t re_search(mp_uint_t n_args, const mp_obj_t *args) {
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(re_search_obj, 2, 4, re_search);
 
 STATIC mp_obj_t re_split(mp_uint_t n_args, const mp_obj_t *args) {
-    mp_obj_re_t *self = args[0];
+    mp_obj_re_t *self = MP_OBJ_TO_PTR(args[0]);
     Subject subj;
     mp_uint_t len;
     subj.begin = mp_obj_str_get_data(args[1], &len);
@@ -179,7 +179,7 @@ STATIC const mp_obj_type_t re_type = {
     { &mp_type_type },
     .name = MP_QSTR_ure,
     .print = re_print,
-    .locals_dict = (mp_obj_t)&re_locals_dict,
+    .locals_dict = (void*)&re_locals_dict,
 };
 
 STATIC mp_obj_t mod_re_compile(mp_uint_t n_args, const mp_obj_t *args) {
@@ -202,16 +202,16 @@ error:
     if (flags & FLAG_DEBUG) {
         re1_5_dumpcode(&o->re);
     }
-    return o;
+    return MP_OBJ_FROM_PTR(o);
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_re_compile_obj, 1, 2, mod_re_compile);
 
 STATIC mp_obj_t mod_re_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
     (void)n_args;
-    mp_obj_re_t *self = mod_re_compile(1, args);
+    mp_obj_t self = mod_re_compile(1, args);
 
     const mp_obj_t args2[] = {self, args[1]};
-    mp_obj_match_t *match = re_exec(is_anchored, 2, args2);
+    mp_obj_t match = re_exec(is_anchored, 2, args2);
     return match;
 }