TonBERRY/micropython
3
0
Fork 0
Code Pull Requests Activity

all: Make all mp_obj_type_t defs use MP_DEFINE_CONST_OBJ_TYPE.

Browse Source 
In preparation for upcoming rework of mp_obj_type_t layout.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
This commit is contained in:
Jim Mussared
2021-07-14 14:38:38 +10:00
committed by Damien George
parent cdb880789f
commit 662b9761b3
227 changed files with 2543 additions and 2184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
py/builtinevex.c
View File

@@ -38,10 +38,12 @@ typedef struct _mp_obj_code_t {
mp_obj_t module_fun;
} mp_obj_code_t;
STATIC const mp_obj_type_t mp_type_code = {
{ &mp_type_type },
.name = MP_QSTR_code,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_code,
MP_QSTR_code,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW
);
STATIC mp_obj_t code_execute(mp_obj_code_t *self, mp_obj_dict_t *globals, mp_obj_dict_t *locals) {
// save context and set new context

28
py/modio.c
View File

@@ -97,12 +97,13 @@ STATIC const mp_stream_p_t iobase_p = {
.ioctl = iobase_ioctl,
};
STATIC const mp_obj_type_t mp_type_iobase = {
{ &mp_type_type },
.name = MP_QSTR_IOBase,
.make_new = iobase_make_new,
.protocol = &iobase_p,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_iobase,
MP_QSTR_IOBase,
MP_TYPE_FLAG_NONE,
iobase_make_new,
protocol, &iobase_p
);
#endif // MICROPY_PY_IO_IOBASE
@@ -191,13 +192,14 @@ STATIC const mp_stream_p_t bufwriter_stream_p = {
.write = bufwriter_write,
};
STATIC const mp_obj_type_t mp_type_bufwriter = {
{ &mp_type_type },
.name = MP_QSTR_BufferedWriter,
.make_new = bufwriter_make_new,
.protocol = &bufwriter_stream_p,
.locals_dict = (mp_obj_dict_t *)&bufwriter_locals_dict,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_bufwriter,
MP_QSTR_BufferedWriter,
MP_TYPE_FLAG_NONE,
bufwriter_make_new,
protocol, &bufwriter_stream_p,
locals_dict, (mp_obj_dict_t *)&bufwriter_locals_dict
);
#endif // MICROPY_PY_IO_BUFFEREDWRITER
STATIC const mp_rom_map_elem_t mp_module_io_globals_table[] = {

12
py/modthread.c
View File

@@ -116,11 +116,13 @@ STATIC const mp_rom_map_elem_t thread_lock_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(thread_lock_locals_dict, thread_lock_locals_dict_table);
STATIC const mp_obj_type_t mp_type_thread_lock = {
{ &mp_type_type },
.name = MP_QSTR_lock,
.locals_dict = (mp_obj_dict_t *)&thread_lock_locals_dict,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_thread_lock,
MP_QSTR_lock,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
locals_dict, (mp_obj_dict_t *)&thread_lock_locals_dict
);
/****************************************************************/
// _thread module

87
py/objarray.c
View File

@@ -571,54 +571,55 @@ STATIC mp_int_t array_get_buffer(mp_obj_t o_in, mp_buffer_info_t *bufinfo, mp_ui
}
#if MICROPY_PY_ARRAY
const mp_obj_type_t mp_type_array = {
{ &mp_type_type },
.name = MP_QSTR_array,
.print = array_print,
.make_new = array_make_new,
.getiter = array_iterator_new,
.unary_op = array_unary_op,
.binary_op = array_binary_op,
.subscr = array_subscr,
.buffer_p = array_get_buffer,
.locals_dict = (mp_obj_dict_t *)&mp_obj_array_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_array,
MP_QSTR_array,
MP_TYPE_FLAG_NONE,
array_make_new,
print, array_print,
getiter, array_iterator_new,
unary_op, array_unary_op,
binary_op, array_binary_op,
subscr, array_subscr,
buffer, array_get_buffer,
locals_dict, (mp_obj_dict_t *)&mp_obj_array_locals_dict
);
#endif
#if MICROPY_PY_BUILTINS_BYTEARRAY
const mp_obj_type_t mp_type_bytearray = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
.name = MP_QSTR_bytearray,
.print = array_print,
.make_new = bytearray_make_new,
.getiter = array_iterator_new,
.unary_op = array_unary_op,
.binary_op = array_binary_op,
.subscr = array_subscr,
.buffer = array_get_buffer,
.locals_dict = (mp_obj_dict_t *)&mp_obj_bytearray_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_bytearray,
MP_QSTR_bytearray,
MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
bytearray_make_new,
print, array_print,
getiter, array_iterator_new,
unary_op, array_unary_op,
binary_op, array_binary_op,
subscr, array_subscr,
buffer, array_get_buffer,
locals_dict, (mp_obj_dict_t *)&mp_obj_bytearray_locals_dict
);
#endif
#if MICROPY_PY_BUILTINS_MEMORYVIEW
const mp_obj_type_t mp_type_memoryview = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
.name = MP_QSTR_memoryview,
.make_new = memoryview_make_new,
.getiter = array_iterator_new,
.unary_op = array_unary_op,
.binary_op = array_binary_op,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_memoryview,
MP_QSTR_memoryview,
MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
memoryview_make_new,
getiter, array_iterator_new,
unary_op, array_unary_op,
binary_op, array_binary_op,
#if MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE
.attr = memoryview_attr,
attr, memoryview_attr,
#endif
#if MICROPY_PY_BUILTINS_BYTES_HEX
.locals_dict = (mp_obj_dict_t *)&mp_obj_memoryview_locals_dict,
locals_dict, (mp_obj_dict_t *)&mp_obj_memoryview_locals_dict,
#endif
.subscr = array_subscr,
.buffer = array_get_buffer,
};
);
#endif
/* unused
@@ -664,12 +665,14 @@ STATIC mp_obj_t array_it_iternext(mp_obj_t self_in) {
}
}
STATIC const mp_obj_type_t mp_type_array_it = {
{ &mp_type_type },
.name = MP_QSTR_iterator,
.getiter = mp_identity_getiter,
.iternext = array_it_iternext,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_array_it,
MP_QSTR_iterator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
getiter, mp_identity_getiter,
iternext, array_it_iternext
);
STATIC mp_obj_t array_iterator_new(mp_obj_t array_in, mp_obj_iter_buf_t *iter_buf) {
assert(sizeof(mp_obj_array_t) <= sizeof(mp_obj_iter_buf_t));

23
py/objattrtuple.c
View File

@@ -80,15 +80,18 @@ mp_obj_t mp_obj_new_attrtuple(const qstr *fields, size_t n, const mp_obj_t *item
return MP_OBJ_FROM_PTR(o);
}
const mp_obj_type_t mp_type_attrtuple = {
{ &mp_type_type },
.name = MP_QSTR_tuple, // reuse tuple to save on a qstr
.print = mp_obj_attrtuple_print,
.unary_op = mp_obj_tuple_unary_op,
.binary_op = mp_obj_tuple_binary_op,
.attr = mp_obj_attrtuple_attr,
.subscr = mp_obj_tuple_subscr,
.getiter = mp_obj_tuple_getiter,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_attrtuple,
MP_QSTR_tuple,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
// reuse tuple to save on a qstr
print, mp_obj_attrtuple_print,
unary_op, mp_obj_tuple_unary_op,
binary_op, mp_obj_tuple_binary_op,
attr, mp_obj_attrtuple_attr,
subscr, mp_obj_tuple_subscr,
getiter, mp_obj_tuple_getiter
);
#endif // MICROPY_PY_ATTRTUPLE

19
py/objbool.c
View File

@@ -84,15 +84,16 @@ STATIC mp_obj_t bool_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_
return mp_binary_op(op, MP_OBJ_NEW_SMALL_INT(value), rhs_in);
}
const mp_obj_type_t mp_type_bool = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, // can match all numeric types
.name = MP_QSTR_bool,
.print = bool_print,
.make_new = bool_make_new,
.unary_op = bool_unary_op,
.binary_op = bool_binary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
// can match all numeric types
mp_type_bool,
MP_QSTR_bool,
MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
bool_make_new,
print, bool_print,
unary_op, bool_unary_op,
binary_op, bool_binary_op
);
#if !MICROPY_OBJ_IMMEDIATE_OBJS
const mp_obj_bool_t mp_const_false_obj = {{&mp_type_bool}, false};

16
py/objboundmeth.c
View File

@@ -95,17 +95,19 @@ STATIC void bound_meth_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
#endif
STATIC const mp_obj_type_t mp_type_bound_meth = {
{ &mp_type_type },
.name = MP_QSTR_bound_method,
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_bound_meth,
MP_QSTR_bound_method,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
.print = bound_meth_print,
print, bound_meth_print,
#endif
.call = bound_meth_call,
call, bound_meth_call
#if MICROPY_PY_FUNCTION_ATTRS
.attr = bound_meth_attr,
, attr, bound_meth_attr
#endif
};
);
mp_obj_t mp_obj_new_bound_meth(mp_obj_t meth, mp_obj_t self) {
mp_obj_bound_meth_t *o = mp_obj_malloc(mp_obj_bound_meth_t, &mp_type_bound_meth);

10
py/objcell.c
View File

@@ -40,13 +40,13 @@ STATIC void cell_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t k
}
#endif
STATIC const mp_obj_type_t mp_type_cell = {
{ &mp_type_type },
.name = MP_QSTR_, // cell representation is just value in < >
STATIC MP_DEFINE_CONST_OBJ_TYPE(
// cell representation is just value in < >
mp_type_cell, MP_QSTR_, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW
#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
.print = cell_print,
, print, cell_print
#endif
};
);
mp_obj_t mp_obj_new_cell(mp_obj_t obj) {
mp_obj_cell_t *o = mp_obj_malloc(mp_obj_cell_t, &mp_type_cell);

17
py/objclosure.c
View File

@@ -86,18 +86,19 @@ STATIC void mp_obj_closure_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
#endif
const mp_obj_type_t mp_type_closure = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_closure,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_closure,
MP_QSTR_closure,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
.print = closure_print,
print, closure_print,
#endif
.call = closure_call,
#if MICROPY_PY_FUNCTION_ATTRS
.attr = mp_obj_closure_attr,
attr, mp_obj_closure_attr,
#endif
};
call, closure_call
);
mp_obj_t mp_obj_new_closure(mp_obj_t fun, size_t n_closed_over, const mp_obj_t *closed) {
mp_obj_closure_t *o = mp_obj_malloc_var(mp_obj_closure_t, mp_obj_t, n_closed_over, &mp_type_closure);

17
py/objcomplex.c
View File

@@ -151,16 +151,13 @@ STATIC void complex_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
}
const mp_obj_type_t mp_type_complex = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
.name = MP_QSTR_complex,
.print = complex_print,
.make_new = complex_make_new,
.unary_op = complex_unary_op,
.binary_op = complex_binary_op,
.attr = complex_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_complex, MP_QSTR_complex, MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, complex_make_new,
print, complex_print,
unary_op, complex_unary_op,
binary_op, complex_binary_op,
attr, complex_attr
);
mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag) {
mp_obj_complex_t *o = mp_obj_malloc(mp_obj_complex_t, &mp_type_complex);

15
py/objdeque.c
View File

@@ -155,12 +155,13 @@ STATIC const mp_rom_map_elem_t deque_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(deque_locals_dict, deque_locals_dict_table);
const mp_obj_type_t mp_type_deque = {
{ &mp_type_type },
.name = MP_QSTR_deque,
.make_new = deque_make_new,
.unary_op = deque_unary_op,
.locals_dict = (mp_obj_dict_t *)&deque_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_deque,
MP_QSTR_deque,
MP_TYPE_FLAG_NONE,
deque_make_new,
unary_op, deque_unary_op,
locals_dict, (mp_obj_dict_t *)&deque_locals_dict
);
#endif // MICROPY_PY_COLLECTIONS_DEQUE

78
py/objdict.c
View File

@@ -461,12 +461,14 @@ STATIC mp_obj_t dict_view_it_iternext(mp_obj_t self_in) {
}
}
STATIC const mp_obj_type_t mp_type_dict_view_it = {
{ &mp_type_type },
.name = MP_QSTR_iterator,
.getiter = mp_identity_getiter,
.iternext = dict_view_it_iternext,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_dict_view_it,
MP_QSTR_iterator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
getiter, mp_identity_getiter,
iternext, dict_view_it_iternext
);
STATIC mp_obj_t dict_view_getiter(mp_obj_t view_in, mp_obj_iter_buf_t *iter_buf) {
assert(sizeof(mp_obj_dict_view_it_t) <= sizeof(mp_obj_iter_buf_t));
@@ -512,13 +514,15 @@ STATIC mp_obj_t dict_view_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t
return dict_binary_op(op, o->dict, rhs_in);
}
STATIC const mp_obj_type_t mp_type_dict_view = {
{ &mp_type_type },
.name = MP_QSTR_dict_view,
.print = dict_view_print,
.binary_op = dict_view_binary_op,
.getiter = dict_view_getiter,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_dict_view,
MP_QSTR_dict_view,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, dict_view_print,
binary_op, dict_view_binary_op,
getiter, dict_view_getiter
);
STATIC mp_obj_t mp_obj_new_dict_view(mp_obj_t dict, mp_dict_view_kind_t kind) {
mp_obj_dict_view_t *o = mp_obj_malloc(mp_obj_dict_view_t, &mp_type_dict_view);
@@ -585,31 +589,33 @@ STATIC const mp_rom_map_elem_t dict_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(dict_locals_dict, dict_locals_dict_table);
const mp_obj_type_t mp_type_dict = {
{ &mp_type_type },
.name = MP_QSTR_dict,
.print = dict_print,
.make_new = mp_obj_dict_make_new,
.unary_op = dict_unary_op,
.binary_op = dict_binary_op,
.subscr = dict_subscr,
.getiter = dict_getiter,
.locals_dict = (mp_obj_dict_t *)&dict_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_dict,
MP_QSTR_dict,
MP_TYPE_FLAG_NONE,
mp_obj_dict_make_new,
print, dict_print,
unary_op, dict_unary_op,
binary_op, dict_binary_op,
subscr, dict_subscr,
getiter, dict_getiter,
locals_dict, (mp_obj_dict_t *)&dict_locals_dict
);
#if MICROPY_PY_COLLECTIONS_ORDEREDDICT
const mp_obj_type_t mp_type_ordereddict = {
{ &mp_type_type },
.name = MP_QSTR_OrderedDict,
.print = dict_print,
.make_new = mp_obj_dict_make_new,
.unary_op = dict_unary_op,
.binary_op = dict_binary_op,
.subscr = dict_subscr,
.getiter = dict_getiter,
.parent = &mp_type_dict,
.locals_dict = (mp_obj_dict_t *)&dict_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_ordereddict,
MP_QSTR_OrderedDict,
MP_TYPE_FLAG_NONE,
mp_obj_dict_make_new,
print, dict_print,
unary_op, dict_unary_op,
binary_op, dict_binary_op,
subscr, dict_subscr,
getiter, dict_getiter,
parent, &mp_type_dict,
locals_dict, (mp_obj_dict_t *)&dict_locals_dict
);
#endif
void mp_obj_dict_init(mp_obj_dict_t *dict, size_t n_args) {

15
py/objenumerate.c
View File

@@ -67,13 +67,14 @@ STATIC mp_obj_t enumerate_make_new(const mp_obj_type_t *type, size_t n_args, siz
return MP_OBJ_FROM_PTR(o);
}
const mp_obj_type_t mp_type_enumerate = {
{ &mp_type_type },
.name = MP_QSTR_enumerate,
.make_new = enumerate_make_new,
.iternext = enumerate_iternext,
.getiter = mp_identity_getiter,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_enumerate,
MP_QSTR_enumerate,
MP_TYPE_FLAG_NONE,
enumerate_make_new,
iternext, enumerate_iternext,
getiter, mp_identity_getiter
);
STATIC mp_obj_t enumerate_iternext(mp_obj_t self_in) {
assert(mp_obj_is_type(self_in, &mp_type_enumerate));

15
py/objexcept.c
View File

@@ -284,13 +284,14 @@ void mp_obj_exception_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
}
const mp_obj_type_t mp_type_BaseException = {
{ &mp_type_type },
.name = MP_QSTR_BaseException,
.print = mp_obj_exception_print,
.make_new = mp_obj_exception_make_new,
.attr = mp_obj_exception_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_BaseException,
MP_QSTR_BaseException,
MP_TYPE_FLAG_NONE,
mp_obj_exception_make_new,
print, mp_obj_exception_print,
attr, mp_obj_exception_attr
);
// *FORMAT-OFF*

15
py/objfilter.c
View File

@@ -60,12 +60,13 @@ STATIC mp_obj_t filter_iternext(mp_obj_t self_in) {
return MP_OBJ_STOP_ITERATION;
}
const mp_obj_type_t mp_type_filter = {
{ &mp_type_type },
.name = MP_QSTR_filter,
.make_new = filter_make_new,
.getiter = mp_identity_getiter,
.iternext = filter_iternext,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_filter,
MP_QSTR_filter,
MP_TYPE_FLAG_NONE,
filter_make_new,
getiter, mp_identity_getiter,
iternext, filter_iternext
);
#endif // MICROPY_PY_BUILTINS_FILTER

15
py/objfloat.c
View File

@@ -182,15 +182,12 @@ STATIC mp_obj_t float_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
return mp_obj_float_binary_op(op, lhs_val, rhs_in);
}
const mp_obj_type_t mp_type_float = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
.name = MP_QSTR_float,
.print = float_print,
.make_new = float_make_new,
.unary_op = float_unary_op,
.binary_op = float_binary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_float, MP_QSTR_float, MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, float_make_new,
print, float_print,
unary_op, float_unary_op,
binary_op, float_binary_op
);
#if MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_C && MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_D

113
py/objfun.c
View File

@@ -56,13 +56,11 @@ STATIC mp_obj_t fun_builtin_0_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
return self->fun._0();
}
const mp_obj_type_t mp_type_fun_builtin_0 = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
.name = MP_QSTR_function,
.call = fun_builtin_0_call,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_builtin_0, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
call, fun_builtin_0_call,
unary_op, mp_generic_unary_op
);
STATIC mp_obj_t fun_builtin_1_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_1));
@@ -71,13 +69,11 @@ STATIC mp_obj_t fun_builtin_1_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
return self->fun._1(args[0]);
}
const mp_obj_type_t mp_type_fun_builtin_1 = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
.name = MP_QSTR_function,
.call = fun_builtin_1_call,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_builtin_1, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
call, fun_builtin_1_call,
unary_op, mp_generic_unary_op
);
STATIC mp_obj_t fun_builtin_2_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_2));
@@ -86,13 +82,11 @@ STATIC mp_obj_t fun_builtin_2_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
return self->fun._2(args[0], args[1]);
}
const mp_obj_type_t mp_type_fun_builtin_2 = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
.name = MP_QSTR_function,
.call = fun_builtin_2_call,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_builtin_2, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
call, fun_builtin_2_call,
unary_op, mp_generic_unary_op
);
STATIC mp_obj_t fun_builtin_3_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_3));
@@ -101,13 +95,11 @@ STATIC mp_obj_t fun_builtin_3_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
return self->fun._3(args[0], args[1], args[2]);
}
const mp_obj_type_t mp_type_fun_builtin_3 = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
.name = MP_QSTR_function,
.call = fun_builtin_3_call,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_builtin_3, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
call, fun_builtin_3_call,
unary_op, mp_generic_unary_op
);
STATIC mp_obj_t fun_builtin_var_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_var));
@@ -132,13 +124,11 @@ STATIC mp_obj_t fun_builtin_var_call(mp_obj_t self_in, size_t n_args, size_t n_k
}
}
const mp_obj_type_t mp_type_fun_builtin_var = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
.name = MP_QSTR_function,
.call = fun_builtin_var_call,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_builtin_var, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
call, fun_builtin_var_call,
unary_op, mp_generic_unary_op
);
/******************************************************************************/
/* byte code functions */
@@ -362,19 +352,20 @@ void mp_obj_fun_bc_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
#endif
const mp_obj_type_t mp_type_fun_bc = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_function,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_bc,
MP_QSTR_function,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
#if MICROPY_CPYTHON_COMPAT
.print = fun_bc_print,
print, fun_bc_print,
#endif
.call = fun_bc_call,
.unary_op = mp_generic_unary_op,
call, fun_bc_call,
unary_op, mp_generic_unary_op
#if MICROPY_PY_FUNCTION_ATTRS
.attr = mp_obj_fun_bc_attr,
, attr, mp_obj_fun_bc_attr
#endif
};
);
mp_obj_t mp_obj_new_fun_bc(const mp_obj_t *def_args, const byte *code, const mp_module_context_t *context, struct _mp_raw_code_t *const *child_table) {
size_t n_def_args = 0;
@@ -417,19 +408,20 @@ STATIC mp_obj_t fun_native_call(mp_obj_t self_in, size_t n_args, size_t n_kw, co
return fun(self_in, n_args, n_kw, args);
}
STATIC const mp_obj_type_t mp_type_fun_native = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_function,
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_native,
MP_QSTR_function,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
#if MICROPY_CPYTHON_COMPAT
.print = fun_bc_print,
print, fun_bc_print,
#endif
.call = fun_native_call,
.unary_op = mp_generic_unary_op,
#if MICROPY_PY_FUNCTION_ATTRS
.attr = mp_obj_fun_bc_attr,
attr, mp_obj_fun_bc_attr,
#endif
};
call, fun_native_call,
unary_op, mp_generic_unary_op
);
mp_obj_t mp_obj_new_fun_native(const mp_obj_t *def_args, const void *fun_data, const mp_module_context_t *mc, struct _mp_raw_code_t *const *child_table) {
mp_obj_fun_bc_t *o = MP_OBJ_TO_PTR(mp_obj_new_fun_bc(def_args, (const byte *)fun_data, mc, child_table));
@@ -531,13 +523,14 @@ STATIC mp_obj_t fun_asm_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
return mp_native_to_obj(ret, self->type_sig);
}
STATIC const mp_obj_type_t mp_type_fun_asm = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_function,
.call = fun_asm_call,
.unary_op = mp_generic_unary_op,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_fun_asm,
MP_QSTR_function,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
call, fun_asm_call,
unary_op, mp_generic_unary_op
);
mp_obj_t mp_obj_new_fun_asm(size_t n_args, const void *fun_data, mp_uint_t type_sig) {
mp_obj_fun_asm_t *o = mp_obj_malloc(mp_obj_fun_asm_t, &mp_type_fun_asm);

54
py/objgenerator.c
View File

@@ -70,16 +70,17 @@ STATIC mp_obj_t gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
return MP_OBJ_FROM_PTR(o);
}
const mp_obj_type_t mp_type_gen_wrap = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_generator,
.call = gen_wrap_call,
.unary_op = mp_generic_unary_op,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_gen_wrap,
MP_QSTR_generator,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
call, gen_wrap_call,
unary_op, mp_generic_unary_op
#if MICROPY_PY_FUNCTION_ATTRS
.attr = mp_obj_fun_bc_attr,
, attr, mp_obj_fun_bc_attr
#endif
};
);
/******************************************************************************/
// native generator wrapper
@@ -131,16 +132,17 @@ STATIC mp_obj_t native_gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_k
return MP_OBJ_FROM_PTR(o);
}
const mp_obj_type_t mp_type_native_gen_wrap = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_generator,
.call = native_gen_wrap_call,
.unary_op = mp_generic_unary_op,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_native_gen_wrap,
MP_QSTR_generator,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
call, native_gen_wrap_call,
unary_op, mp_generic_unary_op
#if MICROPY_PY_FUNCTION_ATTRS
.attr = mp_obj_fun_bc_attr,
, attr, mp_obj_fun_bc_attr
#endif
};
);
#endif // MICROPY_EMIT_NATIVE
@@ -357,12 +359,14 @@ STATIC const mp_rom_map_elem_t gen_instance_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(gen_instance_locals_dict, gen_instance_locals_dict_table);
const mp_obj_type_t mp_type_gen_instance = {
{ &mp_type_type },
.name = MP_QSTR_generator,
.print = gen_instance_print,
.unary_op = mp_generic_unary_op,
.getiter = mp_identity_getiter,
.iternext = gen_instance_iternext,
.locals_dict = (mp_obj_dict_t *)&gen_instance_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_gen_instance,
MP_QSTR_generator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, gen_instance_print,
unary_op, mp_generic_unary_op,
getiter, mp_identity_getiter,
iternext, gen_instance_iternext,
locals_dict, (mp_obj_dict_t *)&gen_instance_locals_dict
);

14
py/objgetitemiter.c
View File

@@ -56,12 +56,14 @@ STATIC mp_obj_t it_iternext(mp_obj_t self_in) {
}
}
STATIC const mp_obj_type_t mp_type_it = {
{ &mp_type_type },
.name = MP_QSTR_iterator,
.getiter = mp_identity_getiter,
.iternext = it_iternext,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_it,
MP_QSTR_iterator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
getiter, mp_identity_getiter,
iternext, it_iternext
);
// args are those returned from mp_load_method_maybe (ie either an attribute or a method)
mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args, mp_obj_iter_buf_t *iter_buf) {

19
py/objint.c
View File

@@ -457,12 +457,13 @@ STATIC const mp_rom_map_elem_t int_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(int_locals_dict, int_locals_dict_table);
const mp_obj_type_t mp_type_int = {
{ &mp_type_type },
.name = MP_QSTR_int,
.print = mp_obj_int_print,
.make_new = mp_obj_int_make_new,
.unary_op = mp_obj_int_unary_op,
.binary_op = mp_obj_int_binary_op,
.locals_dict = (mp_obj_dict_t *)&int_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_int,
MP_QSTR_int,
MP_TYPE_FLAG_NONE,
mp_obj_int_make_new,
print, mp_obj_int_print,
unary_op, mp_obj_int_unary_op,
binary_op, mp_obj_int_binary_op,
locals_dict, (mp_obj_dict_t *)&int_locals_dict
);

24
py/objlist.c
View File

@@ -452,17 +452,19 @@ STATIC const mp_rom_map_elem_t list_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(list_locals_dict, list_locals_dict_table);
const mp_obj_type_t mp_type_list = {
{ &mp_type_type },
.name = MP_QSTR_list,
.print = list_print,
.make_new = list_make_new,
.unary_op = list_unary_op,
.binary_op = list_binary_op,
.subscr = list_subscr,
.getiter = list_getiter,
.locals_dict = (mp_obj_dict_t *)&list_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_list,
MP_QSTR_list,
MP_TYPE_FLAG_NONE,
list_make_new,
print, list_print,
unary_op, list_unary_op,
binary_op, list_binary_op,
subscr, list_subscr,
getiter, list_getiter,
locals_dict, (mp_obj_dict_t *)&list_locals_dict
);
void mp_obj_list_init(mp_obj_list_t *o, size_t n) {
o->base.type = &mp_type_list;

15
py/objmap.c
View File

@@ -63,10 +63,11 @@ STATIC mp_obj_t map_iternext(mp_obj_t self_in) {
return mp_call_function_n_kw(self->fun, self->n_iters, 0, nextses);
}
const mp_obj_type_t mp_type_map = {
{ &mp_type_type },
.name = MP_QSTR_map,
.make_new = map_make_new,
.getiter = mp_identity_getiter,
.iternext = map_iternext,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_map,
MP_QSTR_map,
MP_TYPE_FLAG_NONE,
map_make_new,
getiter, mp_identity_getiter,
iternext, map_iternext
);

14
py/objmodule.c
View File

@@ -130,12 +130,14 @@ STATIC void module_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
}
const mp_obj_type_t mp_type_module = {
{ &mp_type_type },
.name = MP_QSTR_module,
.print = module_print,
.attr = module_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_module,
MP_QSTR_module,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, module_print,
attr, module_attr
);
mp_obj_t mp_obj_new_module(qstr module_name) {
mp_map_t *mp_loaded_modules_map = &MP_STATE_VM(mp_loaded_modules_dict).map;

14
py/objnone.c
View File

@@ -43,12 +43,14 @@ STATIC void none_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_
}
}
const mp_obj_type_t mp_type_NoneType = {
{ &mp_type_type },
.name = MP_QSTR_NoneType,
.print = none_print,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_NoneType,
MP_QSTR_NoneType,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, none_print,
unary_op, mp_generic_unary_op
);
#if !MICROPY_OBJ_IMMEDIATE_OBJS
const mp_obj_none_t mp_const_none_obj = {{&mp_type_NoneType}};

13
py/objobject.c
View File

@@ -111,11 +111,12 @@ STATIC const mp_rom_map_elem_t object_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(object_locals_dict, object_locals_dict_table);
#endif
const mp_obj_type_t mp_type_object = {
{ &mp_type_type },
.name = MP_QSTR_object,
.make_new = object_make_new,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_object,
MP_QSTR_object,
MP_TYPE_FLAG_NONE,
object_make_new
#if MICROPY_CPYTHON_COMPAT
.locals_dict = (mp_obj_dict_t *)&object_locals_dict,
, locals_dict, (mp_obj_dict_t *)&object_locals_dict
#endif
};
);

31
py/objpolyiter.c
View File

@@ -45,12 +45,14 @@ STATIC mp_obj_t polymorph_it_iternext(mp_obj_t self_in) {
return self->iternext(self_in);
}
const mp_obj_type_t mp_type_polymorph_iter = {
{ &mp_type_type },
.name = MP_QSTR_iterator,
.getiter = mp_identity_getiter,
.iternext = polymorph_it_iternext,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_polymorph_iter,
MP_QSTR_iterator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
getiter, mp_identity_getiter,
iternext, polymorph_it_iternext
);
#if MICROPY_ENABLE_FINALISER
// mp_type_polymorph_iter_with_finaliser is a variant of the universal iterator
@@ -76,12 +78,13 @@ STATIC const mp_rom_map_elem_t mp_obj_polymorph_iter_locals_dict_table[] = {
};
STATIC MP_DEFINE_CONST_DICT(mp_obj_polymorph_iter_locals_dict, mp_obj_polymorph_iter_locals_dict_table);
const mp_obj_type_t mp_type_polymorph_iter_with_finaliser = {
{ &mp_type_type },
.name = MP_QSTR_iterator,
.getiter = mp_identity_getiter,
.iternext = polymorph_it_iternext,
.locals_dict = (mp_obj_dict_t *)&mp_obj_polymorph_iter_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_polymorph_iter_with_finaliser,
MP_QSTR_iterator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
getiter, mp_identity_getiter,
iternext, polymorph_it_iternext,
locals_dict, (mp_obj_dict_t *)&mp_obj_polymorph_iter_locals_dict
);
#endif

13
py/objproperty.c
View File

@@ -90,12 +90,13 @@ STATIC const mp_rom_map_elem_t property_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(property_locals_dict, property_locals_dict_table);
const mp_obj_type_t mp_type_property = {
{ &mp_type_type },
.name = MP_QSTR_property,
.make_new = property_make_new,
.locals_dict = (mp_obj_dict_t *)&property_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_property,
MP_QSTR_property,
MP_TYPE_FLAG_NONE,
property_make_new,
locals_dict, (mp_obj_dict_t *)&property_locals_dict
);
const mp_obj_t *mp_obj_property_get(mp_obj_t self_in) {
mp_check_self(mp_obj_is_type(self_in, &mp_type_property));

37
py/objrange.c
View File

@@ -50,12 +50,14 @@ STATIC mp_obj_t range_it_iternext(mp_obj_t o_in) {
}
}
STATIC const mp_obj_type_t mp_type_range_it = {
{ &mp_type_type },
.name = MP_QSTR_iterator,
.getiter = mp_identity_getiter,
.iternext = range_it_iternext,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_range_it,
MP_QSTR_iterator,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
getiter, mp_identity_getiter,
iternext, range_it_iternext
);
STATIC mp_obj_t mp_obj_new_range_iterator(mp_int_t cur, mp_int_t stop, mp_int_t step, mp_obj_iter_buf_t *iter_buf) {
assert(sizeof(mp_obj_range_it_t) <= sizeof(mp_obj_iter_buf_t));
@@ -208,18 +210,19 @@ STATIC void range_attr(mp_obj_t o_in, qstr attr, mp_obj_t *dest) {
}
#endif
const mp_obj_type_t mp_type_range = {
{ &mp_type_type },
.name = MP_QSTR_range,
.print = range_print,
.make_new = range_make_new,
.unary_op = range_unary_op,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_range,
MP_QSTR_range,
MP_TYPE_FLAG_NONE,
range_make_new,
print, range_print,
unary_op, range_unary_op,
#if MICROPY_PY_BUILTINS_RANGE_BINOP
.binary_op = range_binary_op,
binary_op, range_binary_op,
#endif
.subscr = range_subscr,
.getiter = range_getiter,
subscr, range_subscr,
getiter, range_getiter
#if MICROPY_PY_BUILTINS_RANGE_ATTRS
.attr = range_attr,
, attr, range_attr
#endif
};
);

15
py/objreversed.c
View File

@@ -68,12 +68,13 @@ STATIC mp_obj_t reversed_iternext(mp_obj_t self_in) {
return mp_obj_subscr(self->seq, MP_OBJ_NEW_SMALL_INT(self->cur_index), MP_OBJ_SENTINEL);
}
const mp_obj_type_t mp_type_reversed = {
{ &mp_type_type },
.name = MP_QSTR_reversed,
.make_new = reversed_make_new,
.getiter = mp_identity_getiter,
.iternext = reversed_iternext,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_reversed,
MP_QSTR_reversed,
MP_TYPE_FLAG_NONE,
reversed_make_new,
getiter, mp_identity_getiter,
iternext, reversed_iternext
);
#endif // MICROPY_PY_BUILTINS_REVERSED

43
py/objset.c
View File

@@ -539,16 +539,17 @@ STATIC const mp_rom_map_elem_t set_locals_dict_table[] = {
};
STATIC MP_DEFINE_CONST_DICT(set_locals_dict, set_locals_dict_table);
const mp_obj_type_t mp_type_set = {
{ &mp_type_type },
.name = MP_QSTR_set,
.print = set_print,
.make_new = set_make_new,
.unary_op = set_unary_op,
.binary_op = set_binary_op,
.getiter = set_getiter,
.locals_dict = (mp_obj_dict_t *)&set_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_set,
MP_QSTR_set,
MP_TYPE_FLAG_NONE,
set_make_new,
print, set_print,
unary_op, set_unary_op,
binary_op, set_binary_op,
getiter, set_getiter,
locals_dict, (mp_obj_dict_t *)&set_locals_dict
);
#if MICROPY_PY_BUILTINS_FROZENSET
STATIC const mp_rom_map_elem_t frozenset_locals_dict_table[] = {
@@ -564,17 +565,17 @@ STATIC const mp_rom_map_elem_t frozenset_locals_dict_table[] = {
};
STATIC MP_DEFINE_CONST_DICT(frozenset_locals_dict, frozenset_locals_dict_table);
const mp_obj_type_t mp_type_frozenset = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
.name = MP_QSTR_frozenset,
.print = set_print,
.make_new = set_make_new,
.unary_op = set_unary_op,
.binary_op = set_binary_op,
.getiter = set_getiter,
.locals_dict = (mp_obj_dict_t *)&frozenset_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_frozenset,
MP_QSTR_frozenset,
MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
set_make_new,
print, set_print,
unary_op, set_unary_op,
binary_op, set_binary_op,
getiter, set_getiter,
locals_dict, (mp_obj_dict_t *)&frozenset_locals_dict
);
#endif
mp_obj_t mp_obj_new_set(size_t n_args, mp_obj_t *items) {

11
py/objsingleton.c
View File

@@ -43,12 +43,11 @@ STATIC void singleton_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
mp_printf(print, "%q", self->name);
}
const mp_obj_type_t mp_type_singleton = {
{ &mp_type_type },
.name = MP_QSTR_,
.print = singleton_print,
.unary_op = mp_generic_unary_op,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_singleton, MP_QSTR_, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
print, singleton_print,
unary_op, mp_generic_unary_op
);
const mp_obj_singleton_t mp_const_ellipsis_obj = {{&mp_type_singleton}, MP_QSTR_Ellipsis};
#if MICROPY_PY_BUILTINS_NOTIMPLEMENTED

16
py/objslice.c
View File

@@ -92,16 +92,18 @@ STATIC const mp_rom_map_elem_t slice_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(slice_locals_dict, slice_locals_dict_table);
#endif
const mp_obj_type_t mp_type_slice = {
{ &mp_type_type },
.name = MP_QSTR_slice,
.print = slice_print,
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_slice,
MP_QSTR_slice,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, slice_print
#if MICROPY_PY_BUILTINS_SLICE_ATTRS
.attr = slice_attr,
, attr, slice_attr
#elif MICROPY_PY_BUILTINS_SLICE_INDICES
.locals_dict = (mp_obj_dict_t *)&slice_locals_dict,
, locals_dict, (mp_obj_dict_t *)&slice_locals_dict
#endif
};
);
mp_obj_t mp_obj_new_slice(mp_obj_t ostart, mp_obj_t ostop, mp_obj_t ostep) {
mp_obj_slice_t *o = mp_obj_malloc(mp_obj_slice_t, &mp_type_slice);

48
py/objstr.c
View File

@@ -2143,31 +2143,33 @@ MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_memoryview_locals_dict,
#if !MICROPY_PY_BUILTINS_STR_UNICODE
STATIC mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf);
const mp_obj_type_t mp_type_str = {
{ &mp_type_type },
.name = MP_QSTR_str,
.print = str_print,
.make_new = mp_obj_str_make_new,
.binary_op = mp_obj_str_binary_op,
.subscr = bytes_subscr,
.getiter = mp_obj_new_str_iterator,
.buffer = mp_obj_str_get_buffer,
.locals_dict = (mp_obj_dict_t *)&mp_obj_str_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_str,
MP_QSTR_str,
MP_TYPE_FLAG_NONE,
mp_obj_str_make_new,
print, str_print,
binary_op, mp_obj_str_binary_op,
subscr, bytes_subscr,
getiter, mp_obj_new_str_iterator,
buffer, mp_obj_str_get_buffer,
locals_dict, (mp_obj_dict_t *)&mp_obj_str_locals_dict
);
#endif // !MICROPY_PY_BUILTINS_STR_UNICODE
// Reuses most of methods from str
const mp_obj_type_t mp_type_bytes = {
{ &mp_type_type },
.name = MP_QSTR_bytes,
.print = str_print,
.make_new = bytes_make_new,
.binary_op = mp_obj_str_binary_op,
.subscr = bytes_subscr,
.getiter = mp_obj_new_bytes_iterator,
.buffer = mp_obj_str_get_buffer,
.locals_dict = (mp_obj_dict_t *)&mp_obj_bytes_locals_dict,
};
// Reuses most methods from str
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_bytes,
MP_QSTR_bytes,
MP_TYPE_FLAG_NONE,
bytes_make_new,
print, str_print,
binary_op, mp_obj_str_binary_op,
subscr, bytes_subscr,
getiter, mp_obj_new_bytes_iterator,
buffer, mp_obj_str_get_buffer,
locals_dict, (mp_obj_dict_t *)&mp_obj_bytes_locals_dict
);
// The zero-length bytes object, with data that includes a null-terminating byte
const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, (const byte *)""};

42
py/objstringio.c
View File

@@ -244,16 +244,17 @@ STATIC const mp_stream_p_t stringio_stream_p = {
.is_text = true,
};
const mp_obj_type_t mp_type_stringio = {
{ &mp_type_type },
.name = MP_QSTR_StringIO,
.print = stringio_print,
.make_new = stringio_make_new,
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &stringio_stream_p,
.locals_dict = (mp_obj_dict_t *)&stringio_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_stringio,
MP_QSTR_StringIO,
MP_TYPE_FLAG_NONE,
stringio_make_new,
print, stringio_print,
getiter, mp_identity_getiter,
iternext, mp_stream_unbuffered_iter,
protocol, &stringio_stream_p,
locals_dict, (mp_obj_dict_t *)&stringio_locals_dict
);
#if MICROPY_PY_IO_BYTESIO
STATIC const mp_stream_p_t bytesio_stream_p = {
@@ -262,16 +263,17 @@ STATIC const mp_stream_p_t bytesio_stream_p = {
.ioctl = stringio_ioctl,
};
const mp_obj_type_t mp_type_bytesio = {
{ &mp_type_type },
.name = MP_QSTR_BytesIO,
.print = stringio_print,
.make_new = stringio_make_new,
.getiter = mp_identity_getiter,
.iternext = mp_stream_unbuffered_iter,
.protocol = &bytesio_stream_p,
.locals_dict = (mp_obj_dict_t *)&stringio_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_bytesio,
MP_QSTR_BytesIO,
MP_TYPE_FLAG_NONE,
stringio_make_new,
print, stringio_print,
getiter, mp_identity_getiter,
iternext, mp_stream_unbuffered_iter,
protocol, &bytesio_stream_p,
locals_dict, (mp_obj_dict_t *)&stringio_locals_dict
);
#endif
#endif

25
py/objstrunicode.c
View File

@@ -229,18 +229,19 @@ STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
}
}
const mp_obj_type_t mp_type_str = {
{ &mp_type_type },
.name = MP_QSTR_str,
.print = uni_print,
.make_new = mp_obj_str_make_new,
.unary_op = uni_unary_op,
.binary_op = mp_obj_str_binary_op,
.subscr = str_subscr,
.getiter = mp_obj_new_str_iterator,
.buffer = mp_obj_str_get_buffer,
.locals_dict = (mp_obj_dict_t *)&mp_obj_str_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_str,
MP_QSTR_str,
MP_TYPE_FLAG_NONE,
mp_obj_str_make_new,
print, uni_print,
unary_op, uni_unary_op,
binary_op, mp_obj_str_binary_op,
subscr, str_subscr,
getiter, mp_obj_new_str_iterator,
buffer, mp_obj_str_get_buffer,
locals_dict, (mp_obj_dict_t *)&mp_obj_str_locals_dict
);
/******************************************************************************/
/* str iterator */

23
py/objtuple.c
View File

@@ -224,17 +224,18 @@ STATIC const mp_rom_map_elem_t tuple_locals_dict_table[] = {
STATIC MP_DEFINE_CONST_DICT(tuple_locals_dict, tuple_locals_dict_table);
const mp_obj_type_t mp_type_tuple = {
{ &mp_type_type },
.name = MP_QSTR_tuple,
.print = mp_obj_tuple_print,
.make_new = mp_obj_tuple_make_new,
.unary_op = mp_obj_tuple_unary_op,
.binary_op = mp_obj_tuple_binary_op,
.subscr = mp_obj_tuple_subscr,
.getiter = mp_obj_tuple_getiter,
.locals_dict = (mp_obj_dict_t *)&tuple_locals_dict,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_tuple,
MP_QSTR_tuple,
MP_TYPE_FLAG_NONE,
mp_obj_tuple_make_new,
print, mp_obj_tuple_print,
unary_op, mp_obj_tuple_unary_op,
binary_op, mp_obj_tuple_binary_op,
subscr, mp_obj_tuple_subscr,
getiter, mp_obj_tuple_getiter,
locals_dict, (mp_obj_dict_t *)&tuple_locals_dict
);
// the zero-length tuple
const mp_obj_tuple_t mp_const_empty_tuple_obj = {{&mp_type_tuple}, 0};

56
py/objtype.c
View File

@@ -1098,15 +1098,16 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
}
const mp_obj_type_t mp_type_type = {
{ &mp_type_type },
.name = MP_QSTR_type,
.print = type_print,
.make_new = type_make_new,
.call = type_call,
.unary_op = mp_generic_unary_op,
.attr = type_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_type,
MP_QSTR_type,
MP_TYPE_FLAG_NONE,
type_make_new,
print, type_print,
call, type_call,
unary_op, mp_generic_unary_op,
attr, type_attr
);
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
// Verify input objects have expected type
@@ -1314,13 +1315,14 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
mp_obj_class_lookup(&lookup, &mp_type_object);
}
const mp_obj_type_t mp_type_super = {
{ &mp_type_type },
.name = MP_QSTR_super,
.print = super_print,
.make_new = super_make_new,
.attr = super_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_super,
MP_QSTR_super,
MP_TYPE_FLAG_NONE,
super_make_new,
print, super_print,
attr, super_attr
);
void mp_load_super_method(qstr attr, mp_obj_t *dest) {
mp_obj_super_t super = {{&mp_type_super}, dest[1], dest[2]};
@@ -1436,14 +1438,16 @@ STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self, size_t n
return MP_OBJ_FROM_PTR(o);
}
const mp_obj_type_t mp_type_staticmethod = {
{ &mp_type_type },
.name = MP_QSTR_staticmethod,
.make_new = static_class_method_make_new,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_staticmethod,
MP_QSTR_staticmethod,
MP_TYPE_FLAG_NONE,
static_class_method_make_new
);
const mp_obj_type_t mp_type_classmethod = {
{ &mp_type_type },
.name = MP_QSTR_classmethod,
.make_new = static_class_method_make_new,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_classmethod,
MP_QSTR_classmethod,
MP_TYPE_FLAG_NONE,
static_class_method_make_new
);

15
py/objzip.c
View File

@@ -66,10 +66,11 @@ STATIC mp_obj_t zip_iternext(mp_obj_t self_in) {
return MP_OBJ_FROM_PTR(tuple);
}
const mp_obj_type_t mp_type_zip = {
{ &mp_type_type },
.name = MP_QSTR_zip,
.make_new = zip_make_new,
.getiter = mp_identity_getiter,
.iternext = zip_iternext,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_zip,
MP_QSTR_zip,
MP_TYPE_FLAG_NONE,
zip_make_new,
getiter, mp_identity_getiter,
iternext, zip_iternext
);

32
py/profile.c
View File

@@ -172,13 +172,15 @@ STATIC void code_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
}
const mp_obj_type_t mp_type_settrace_codeobj = {
{ &mp_type_type },
.name = MP_QSTR_code,
.print = code_print,
.unary_op = mp_generic_unary_op,
.attr = code_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_settrace_codeobj,
MP_QSTR_code,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, code_print,
unary_op, mp_generic_unary_op,
attr, code_attr
);
mp_obj_t mp_obj_new_code(const mp_module_context_t *context, const mp_raw_code_t *rc) {
mp_obj_code_t *o = m_new_obj_maybe(mp_obj_code_t);
@@ -241,13 +243,15 @@ STATIC void frame_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
}
}
const mp_obj_type_t mp_type_frame = {
{ &mp_type_type },
.name = MP_QSTR_frame,
.print = frame_print,
.unary_op = mp_generic_unary_op,
.attr = frame_attr,
};
MP_DEFINE_CONST_OBJ_TYPE(
mp_type_frame,
MP_QSTR_frame,
MP_TYPE_FLAG_NONE,
MP_TYPE_NULL_MAKE_NEW,
print, frame_print,
unary_op, mp_generic_unary_op,
attr, frame_attr
);
mp_obj_t mp_obj_new_frame(const mp_code_state_t *code_state) {
if (gc_is_locked()) {

13
py/runtime.c
View File

@@ -1070,12 +1070,13 @@ STATIC mp_obj_t checked_fun_call(mp_obj_t self_in, size_t n_args, size_t n_kw, c
return mp_call_function_n_kw(self->fun, n_args, n_kw, args);
}
STATIC const mp_obj_type_t mp_type_checked_fun = {
{ &mp_type_type },
.flags = MP_TYPE_FLAG_BINDS_SELF,
.name = MP_QSTR_function,
.call = checked_fun_call,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
mp_type_checked_fun,
MP_QSTR_function,
MP_TYPE_FLAG_BINDS_SELF,
MP_TYPE_NULL_MAKE_NEW,
call, checked_fun_call
);
STATIC mp_obj_t mp_obj_new_checked_fun(const mp_obj_type_t *type, mp_obj_t fun) {
mp_obj_checked_fun_t *o = mp_obj_malloc(mp_obj_checked_fun_t, &mp_type_checked_fun);