Update mp_obj_type_t definitions for latest MicroPython. (#549)

* build.sh: Fix unix executable path.

This was updated recently to no longer copy to the ports/unix directory.

Use the version in the build directory instead if available.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

* Update to new style mp_obj_type_t definitions.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

build.sh

@@ -51,8 +51,13 @@ make -C micropython/mpy-cross -j${NPROC}
 make -C micropython/ports/unix submodules
 make -C micropython/ports/unix -j${NPROC} USER_C_MODULES="${HERE}" DEBUG=1 STRIP=: MICROPY_PY_FFI=0 MICROPY_PY_BTREE=0 CFLAGS_EXTRA=-DULAB_MAX_DIMS=$dims CFLAGS_EXTRA+=-DULAB_HASH=$GIT_HASH BUILD=build-$dims PROG=micropython-$dims
 
+PROG="micropython/ports/unix/build-$dims/micropython-$dims"
+if [ ! -e "$PROG" ]; then
+  # Older MicroPython revision, executable is still in ports/unix.
+  PROG="micropython/ports/unix/micropython-$dims"
+fi
 
-bash test-common.sh "${dims}" "micropython/ports/unix/micropython-$dims"
+bash test-common.sh "${dims}" "$PROG"
 
 # Build with single-precision float.
 make -C micropython/ports/unix -j${NPROC} USER_C_MODULES="${HERE}" DEBUG=1 STRIP=: MICROPY_PY_FFI=0 MICROPY_PY_BTREE=0 CFLAGS_EXTRA=-DMICROPY_FLOAT_IMPL=MICROPY_FLOAT_IMPL_FLOAT CFLAGS_EXTRA+=-DULAB_MAX_DIMS=$dims CFLAGS_EXTRA+=-DULAB_HASH=$GIT_HASH BUILD=build-nanbox-$dims PROG=micropython-nanbox-$dims

code/ndarray.h

@@ -93,12 +93,21 @@ typedef struct _mp_obj_slice_t {
 #define MP_ERROR_TEXT(x) x
 #endif
 
-#if !defined(MP_TYPE_FLAG_EXTENDED)
-#define MP_TYPE_CALL call
-#define mp_type_get_call_slot(t) t->call
+#if !defined(MP_OBJ_TYPE_GET_SLOT)
+#if defined(MP_TYPE_FLAG_EXTENDED)
+// Provide MP_OBJ_TYPE_{HAS,GET}_SLOT for CircuitPython.
+#define MP_OBJ_TYPE_HAS_SLOT(t, f) (mp_type_get_##f##_slot(t) != NULL)
+#define MP_OBJ_TYPE_GET_SLOT(t, f) mp_type_get_##f##_slot(t)
+#else
+// Provide MP_OBJ_TYPE_{HAS,GET}_SLOT for older revisions of MicroPython.
+#define MP_OBJ_TYPE_HAS_SLOT(t, f) ((t)->f != NULL)
+#define MP_OBJ_TYPE_GET_SLOT(t, f) (t)->f
+
+// Also allow CiruitPython-style mp_obj_type_t definitions.
 #define MP_TYPE_FLAG_EXTENDED (0)
 #define MP_TYPE_EXTENDED_FIELDS(...) __VA_ARGS__
 #endif
+#endif
 
 #if !CIRCUITPY
 #define translate(x) MP_ERROR_TEXT(x)

code/ndarray_properties.c

@@ -31,18 +31,18 @@
 
 STATIC void call_local_method(mp_obj_t obj, qstr attr, mp_obj_t *dest) {
     const mp_obj_type_t *type = mp_obj_get_type(obj);
-    while (type->locals_dict != NULL) {
-        assert(type->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
-        mp_map_t *locals_map = &type->locals_dict->map;
+    while (MP_OBJ_TYPE_HAS_SLOT(type, locals_dict)) {
+        assert(MP_OBJ_TYPE_GET_SLOT(type, locals_dict)->base.type == &mp_type_dict); // MicroPython restriction, for now
+        mp_map_t *locals_map = &MP_OBJ_TYPE_GET_SLOT(type, locals_dict)->map;
         mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
         if (elem != NULL) {
             mp_convert_member_lookup(obj, type, elem->value, dest);
             break;
         }
-        if (type->parent == NULL) {
+        if (!MP_OBJ_TYPE_HAS_SLOT(type, parent)) {
             break;
         }
-        type = type->parent;
+        type = MP_OBJ_TYPE_GET_SLOT(type, parent);
     }
 }
 
@@ -120,4 +120,4 @@ void ndarray_properties_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-#endif /* CIRCUITPY */
+#endif /* CIRCUITPY */

code/numpy/vector.c

@@ -762,7 +762,7 @@ static mp_obj_t vector_vectorized_function_call(mp_obj_t self_in, size_t n_args,
         ndarray_obj_t *ndarray = ndarray_new_dense_ndarray(source->ndim, source->shape, self->otypes);
         for(size_t i=0; i < source->len; i++) {
             avalue[0] = mp_binary_get_val_array(source->dtype, source->array, i);
-            fvalue = self->type->MP_TYPE_CALL(self->fun, 1, 0, avalue);
+            fvalue = MP_OBJ_TYPE_GET_SLOT(self->type, call)(self->fun, 1, 0, avalue);
             ndarray_set_value(self->otypes, ndarray->array, i, fvalue);
         }
         return MP_OBJ_FROM_PTR(ndarray);
@@ -774,14 +774,14 @@ static mp_obj_t vector_vectorized_function_call(mp_obj_t self_in, size_t n_args,
         mp_obj_t iterable = mp_getiter(args[0], &iter_buf);
         size_t i=0;
         while ((avalue[0] = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
-            fvalue = self->type->MP_TYPE_CALL(self->fun, 1, 0, avalue);
+            fvalue = MP_OBJ_TYPE_GET_SLOT(self->type, call)(self->fun, 1, 0, avalue);
             ndarray_set_value(self->otypes, ndarray->array, i, fvalue);
             i++;
         }
         return MP_OBJ_FROM_PTR(ndarray);
     } else if(mp_obj_is_int(args[0]) || mp_obj_is_float(args[0])) {
         ndarray_obj_t *ndarray = ndarray_new_linear_array(1, self->otypes);
-        fvalue = self->type->MP_TYPE_CALL(self->fun, 1, 0, args);
+        fvalue = MP_OBJ_TYPE_GET_SLOT(self->type, call)(self->fun, 1, 0, args);
         ndarray_set_value(self->otypes, ndarray->array, 0, fvalue);
         return MP_OBJ_FROM_PTR(ndarray);
     } else {
@@ -790,6 +790,14 @@ static mp_obj_t vector_vectorized_function_call(mp_obj_t self_in, size_t n_args,
     return mp_const_none;
 }
 
+#if defined(MP_DEFINE_CONST_OBJ_TYPE)
+MP_DEFINE_CONST_OBJ_TYPE(
+    vector_function_type,
+    MP_QSTR_,
+    MP_TYPE_FLAG_NONE,
+    call, vector_vectorized_function_call
+);
+#else
 const mp_obj_type_t vector_function_type = {
     { &mp_type_type },
     .flags = MP_TYPE_FLAG_EXTENDED,
@@ -798,6 +806,7 @@ const mp_obj_type_t vector_function_type = {
     .call = vector_vectorized_function_call,
     )
 };
+#endif
 
 //| def vectorize(
 //|     f: Union[Callable[[int], _float], Callable[[_float], _float]],
@@ -821,7 +830,7 @@ static mp_obj_t vector_vectorize(size_t n_args, const mp_obj_t *pos_args, mp_map
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
     const mp_obj_type_t *type = mp_obj_get_type(args[0].u_obj);
-    if(mp_type_get_call_slot(type) == NULL) {
+    if(!MP_OBJ_TYPE_HAS_SLOT(type, call)) {
         mp_raise_TypeError(translate("first argument must be a callable"));
     }
     mp_obj_t _otypes = args[1].u_obj;

code/scipy/optimize/optimize.c

@@ -30,7 +30,7 @@ static mp_float_t optimize_python_call(const mp_obj_type_t *type, mp_obj_t fun,
     // where f is defined in python. Takes a float, returns a float.
     // The array of mp_obj_t type must be supplied, as must the number of parameters (a, b, c...) in nparams
     fargs[0] = mp_obj_new_float(x);
-    return mp_obj_get_float(type->MP_TYPE_CALL(fun, nparams+1, 0, fargs));
+    return mp_obj_get_float(MP_OBJ_TYPE_GET_SLOT(type, call)(fun, nparams+1, 0, fargs));
 }
 
 #if ULAB_SCIPY_OPTIMIZE_HAS_BISECT
@@ -70,7 +70,7 @@ STATIC mp_obj_t optimize_bisect(size_t n_args, const mp_obj_t *pos_args, mp_map_
 
     mp_obj_t fun = args[0].u_obj;
     const mp_obj_type_t *type = mp_obj_get_type(fun);
-    if(mp_type_get_call_slot(type) == NULL) {
+    if(!MP_OBJ_TYPE_HAS_SLOT(type, call)) {
         mp_raise_TypeError(translate("first argument must be a function"));
     }
     mp_float_t xtol = mp_obj_get_float(args[3].u_obj);
@@ -140,7 +140,7 @@ STATIC mp_obj_t optimize_fmin(size_t n_args, const mp_obj_t *pos_args, mp_map_t
 
     mp_obj_t fun = args[0].u_obj;
     const mp_obj_type_t *type = mp_obj_get_type(fun);
-    if(mp_type_get_call_slot(type) == NULL) {
+    if(!MP_OBJ_TYPE_HAS_SLOT(type, call)) {
         mp_raise_TypeError(translate("first argument must be a function"));
     }
 
@@ -276,7 +276,7 @@ mp_obj_t optimize_curve_fit(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
 
     mp_obj_t fun = args[0].u_obj;
     const mp_obj_type_t *type = mp_obj_get_type(fun);
-    if(mp_type_get_call_slot(type) == NULL) {
+    if(!MP_OBJ_TYPE_HAS_SLOT(type, call)) {
         mp_raise_TypeError(translate("first argument must be a function"));
     }
 
@@ -365,7 +365,7 @@ static mp_obj_t optimize_newton(size_t n_args, const mp_obj_t *pos_args, mp_map_
 
     mp_obj_t fun = args[0].u_obj;
     const mp_obj_type_t *type = mp_obj_get_type(fun);
-    if(mp_type_get_call_slot(type) == NULL) {
+    if(!MP_OBJ_TYPE_HAS_SLOT(type, call)) {
         mp_raise_TypeError(translate("first argument must be a function"));
     }
     mp_float_t x = mp_obj_get_float(args[1].u_obj);

code/ulab.c

@@ -100,6 +100,49 @@ STATIC const mp_rom_map_elem_t ulab_ndarray_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ulab_ndarray_locals_dict, ulab_ndarray_locals_dict_table);
 
+#if defined(MP_DEFINE_CONST_OBJ_TYPE)
+// MicroPython after-b41aaaa (Sept 19 2022).
+
+#if NDARRAY_IS_SLICEABLE
+#define NDARRAY_TYPE_SUBSCR subscr, ndarray_subscr,
+#else
+#define NDARRAY_TYPE_SUBSCR
+#endif
+#if NDARRAY_IS_ITERABLE
+#define NDARRAY_TYPE_ITER iter, ndarray_getiter,
+#define NDARRAY_TYPE_ITER_FLAGS MP_TYPE_FLAG_ITER_IS_GETITER
+#else
+#define NDARRAY_TYPE_ITER
+#define NDARRAY_TYPE_ITER_FLAGS 0
+#endif
+#if NDARRAY_HAS_UNARY_OPS
+#define NDARRAY_TYPE_UNARY_OP unary_op, ndarray_unary_op,
+#else
+#define NDARRAY_TYPE_UNARY_OP
+#endif
+#if NDARRAY_HAS_BINARY_OPS
+#define NDARRAY_TYPE_BINARY_OP binary_op, ndarray_binary_op,
+#else
+#define NDARRAY_TYPE_BINARY_OP
+#endif
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    ulab_ndarray_type,
+    MP_QSTR_ndarray,
+    MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE | MP_TYPE_FLAG_EQ_HAS_NEQ_TEST | NDARRAY_TYPE_ITER_FLAGS,
+    print, ndarray_print,
+    make_new, ndarray_make_new,
+    locals_dict, &ulab_ndarray_locals_dict,
+    NDARRAY_TYPE_SUBSCR
+    NDARRAY_TYPE_ITER
+    NDARRAY_TYPE_UNARY_OP
+    NDARRAY_TYPE_BINARY_OP
+    attr, ndarray_properties_attr,
+    buffer, ndarray_get_buffer
+);
+
+#else
+// CircuitPython and earlier MicroPython revisions.
 const mp_obj_type_t ulab_ndarray_type = {
     { &mp_type_type },
     .flags = MP_TYPE_FLAG_EXTENDED
@@ -129,17 +172,37 @@ const mp_obj_type_t ulab_ndarray_type = {
     .buffer_p = { .get_buffer = ndarray_get_buffer, },
     )
 };
+#endif
 
 #if ULAB_HAS_DTYPE_OBJECT
+
+#if defined(MP_DEFINE_CONST_OBJ_TYPE)
+MP_DEFINE_CONST_OBJ_TYPE(
+    ulab_dtype_type,
+    MP_QSTR_dtype,
+    MP_TYPE_FLAG_NONE,
+    print, ndarray_dtype_print
+    make_new, ndarray_dtype_make_new
+);
+#else
 const mp_obj_type_t ulab_dtype_type = {
     { &mp_type_type },
     .name = MP_QSTR_dtype,
     .print = ndarray_dtype_print,
     .make_new = ndarray_dtype_make_new,
 };
 #endif
+#endif
 
 #if NDARRAY_HAS_FLATITER
+#if defined(MP_DEFINE_CONST_OBJ_TYPE)
+MP_DEFINE_CONST_OBJ_TYPE(
+    ndarray_flatiter_type,
+    MP_QSTR_flatiter,
+    MP_TYPE_FLAG_ITER_IS_GETITER,
+    iter, ndarray_get_flatiterator
+);
+#else
 const mp_obj_type_t ndarray_flatiter_type = {
     { &mp_type_type },
     .name = MP_QSTR_flatiter,
@@ -148,6 +211,7 @@ const mp_obj_type_t ndarray_flatiter_type = {
     )
 };
 #endif
+#endif
 
 STATIC const mp_rom_map_elem_t ulab_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ulab) },