micropython
diff --git a/‎py/mpconfig.h‎
Lines changed: 0 additions & 7 deletions b/‎py/mpconfig.h‎
Lines changed: 0 additions & 7 deletions
diff --git a/‎py/obj.h‎
Lines changed: 19 additions & 81 deletions b/‎py/obj.h‎
Lines changed: 19 additions & 81 deletions
@@ -145,13 +145,6 @@
 #define MICROPY_OBJ_IMMEDIATE_OBJS (MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_D)
 #endif
 
-#define MICROPY_OBJ_TYPE_REPR_FULL (0)
-#define MICROPY_OBJ_TYPE_REPR_SLOT_INDEX (1)
-
-#ifndef MICROPY_OBJ_TYPE_REPR
-#define MICROPY_OBJ_TYPE_REPR (MICROPY_OBJ_TYPE_REPR_FULL)
-#endif
-
 /*****************************************************************************/
 /* Memory allocation policy                                                  */
 
 
@@ -569,17 +569,22 @@ struct _mp_obj_type_t {
     // Corresponds to __new__ and __init__ special methods, to make an instance of the type.
     mp_make_new_fun_t make_new;
 
-    #if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_FULL
+    // Slots: For the rest of the fields, the slot index points to the
+    // relevant function in the variable-length "slots" field. Ideally these
+    // would be only 4 bits, but the extra overhead of accessing them adds
+    // more code, and we also need to be able to take the address of them for
+    // mp_obj_class_lookup.
+
     // Corresponds to __repr__ and __str__ special methods.
-    mp_print_fun_t print;
+    uint8_t slot_index_print;
 
     // Corresponds to __call__ special method, ie T(...).
-    mp_call_fun_t call;
+    uint8_t slot_index_call;
 
     // Implements unary and binary operations.
     // Can return MP_OBJ_NULL if the operation is not supported.
-    mp_unary_op_fun_t unary_op;
-    mp_binary_op_fun_t binary_op;
+    uint8_t slot_index_unary_op;
+    uint8_t slot_index_binary_op;
 
     // Implements load, store and delete attribute.
     //
@@ -593,60 +598,40 @@ struct _mp_obj_type_t {
     // dest[0,1] = {MP_OBJ_SENTINEL, object} means store
     //  return: for fail, do nothing
     //          for success set dest[0] = MP_OBJ_NULL
-    mp_attr_fun_t attr;
+    uint8_t slot_index_attr;
 
     // Implements load, store and delete subscripting:
     //  - value = MP_OBJ_SENTINEL means load
     //  - value = MP_OBJ_NULL means delete
     //  - all other values mean store the value
     // Can return MP_OBJ_NULL if operation not supported.
-    mp_subscr_fun_t subscr;
+    uint8_t slot_index_subscr;
 
     // Corresponds to __iter__ special method.
     // Can use the given mp_obj_iter_buf_t to store iterator object,
     // otherwise can return a pointer to an object on the heap.
-    mp_getiter_fun_t getiter;
+    uint8_t slot_index_getiter;
 
     // Corresponds to __next__ special method.  May return MP_OBJ_STOP_ITERATION
     // as an optimisation instead of raising StopIteration() with no args.
-    mp_fun_1_t iternext;
+    uint8_t slot_index_iternext;
 
     // Implements the buffer protocol if supported by this type.
-    mp_buffer_fun_t buffer;
+    uint8_t slot_index_buffer;
 
     // One of disjoint protocols (interfaces), like mp_stream_p_t, etc.
-    const void *protocol;
+    uint8_t slot_index_protocol;
 
     // A pointer to the parents of this type:
     //  - 0 parents: pointer is NULL (object is implicitly the single parent)
     //  - 1 parent: a pointer to the type of that parent
     //  - 2 or more parents: pointer to a tuple object containing the parent types
-    const void *parent;
+    uint8_t slot_index_parent;
 
     // A dict mapping qstrs to objects local methods/constants/etc.
-    struct _mp_obj_dict_t *locals_dict;
-
-    #elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SLOT_INDEX
-
-    // Ideally these would be only 4 bits, but the extra overhead of
-    // accessing them adds more code, and we also need to be able to
-    // take the address of them for mp_obj_class_lookup.
-    uint8_t slot_index_print;
-    uint8_t slot_index_call;
-    uint8_t slot_index_unary_op;
-    uint8_t slot_index_binary_op;
-    uint8_t slot_index_attr;
-    uint8_t slot_index_subscr;
-    uint8_t slot_index_getiter;
-    uint8_t slot_index_iternext;
-    uint8_t slot_index_buffer;
-    uint8_t slot_index_protocol;
-    uint8_t slot_index_parent;
     uint8_t slot_index_locals_dict;
 
     const void *slots[];
-
-    #endif
 };
 
 // Non-variable sized version of mp_obj_type_t to be used as a member
@@ -659,23 +644,6 @@ typedef struct _mp_obj_full_type_t {
     uint16_t name;
     mp_make_new_fun_t make_new;
 
-    #if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_FULL
-
-    mp_print_fun_t print;
-    mp_call_fun_t call;
-    mp_unary_op_fun_t unary_op;
-    mp_binary_op_fun_t binary_op;
-    mp_attr_fun_t attr;
-    mp_subscr_fun_t subscr;
-    mp_getiter_fun_t getiter;
-    mp_fun_1_t iternext;
-    mp_buffer_fun_t buffer;
-    const void *protocol;
-    const void *parent;
-    struct _mp_obj_dict_t *locals_dict;
-
-    #elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SLOT_INDEX
-
     uint8_t slot_index_print;
     uint8_t slot_index_call;
     uint8_t slot_index_unary_op;
@@ -688,41 +656,13 @@ typedef struct _mp_obj_full_type_t {
     uint8_t slot_index_protocol;
     uint8_t slot_index_parent;
     uint8_t slot_index_locals_dict;
-    const void *slots[12];
 
-    #endif
+    // This is the only change from _mp_obj_type_t.
+    const void *slots[12];
 } mp_obj_full_type_t;
 
 #define MP_TYPE_NULL_MAKE_NEW (NULL)
 
-#if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_FULL
-
-#define _MP_DEFINE_CONST_OBJ_TYPE_0(_typename, _name, _flags, _make_new) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new }
-#define _MP_DEFINE_CONST_OBJ_TYPE_1(_typename, _name, _flags, _make_new, f1, v1) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_2(_typename, _name, _flags, _make_new, f1, v1, f2, v2) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_3(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_4(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_5(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_6(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_7(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_8(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_9(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_10(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9, .f10 = v10 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_11(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9, .f10 = v10, .f11 = v11 }
-#define _MP_DEFINE_CONST_OBJ_TYPE_12(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11, f12, v12) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9, .f10 = v10, .f11 = v11, .f12 = v12 }
-
-// Always safe, checks if the type can and does have this slot.
-#define MP_OBJ_TYPE_HAS_SLOT(t, f) ((t)->f)
-// Requires you know that this type can have this slot.
-#define MP_OBJ_TYPE_GET_SLOT(t, f) ((t)->f)
-// Always safe, returns NULL if the type cannot have this slot.
-#define MP_OBJ_TYPE_GET_SLOT_OR_NULL(t, f) ((t)->f)
-#define MP_OBJ_TYPE_SET_SLOT(t, f, v, n) ((t)->f = v)
-#define MP_OBJ_TYPE_OFFSETOF_SLOT(f) (offsetof(mp_obj_type_t, f))
-#define MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(t, offset) (*(void **)((char *)(t) + (offset)) != NULL)
-
-#elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SLOT_INDEX
-
 #define _MP_OBJ_TYPE_SLOT_TYPE_print (mp_print_fun_t)
 #define _MP_OBJ_TYPE_SLOT_TYPE_call (mp_call_fun_t)
 #define _MP_OBJ_TYPE_SLOT_TYPE_unary_op (mp_unary_op_fun_t)
@@ -758,8 +698,6 @@ typedef struct _mp_obj_full_type_t {
 // For everything except make_new, the offset is to the uint8_t index. For make_new, we need to check the pointer.
 #define MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(t, offset) (*(uint8_t *)((char *)(t) + (offset)) != 0 || (offset == offsetof(mp_obj_type_t, make_new) && t->make_new))
 
-#endif
-
 // Workaround for https://docs.microsoft.com/en-us/cpp/preprocessor/preprocessor-experimental-overview?view=msvc-160#macro-arguments-are-unpacked
 #define _MP_DEFINE_CONST_OBJ_TYPE_EXPAND(x) x