From 6ead0d2fbc21795b0a8f0f69a80f3752c9b0d1de Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 29 Apr 2014 02:42:28 +0300 Subject: [PATCH 1/6] objtype: Implement basic framework for subclassing native types. This implements checking of base types, allocation and basic initialization, and optimized support for special method lookups. Other features are not yet supported. --- py/objtype.c | 155 ++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 130 insertions(+), 25 deletions(-) diff --git a/py/objtype.c b/py/objtype.c index 75d53b8279..4491eb0d5b 100644 --- a/py/objtype.c +++ b/py/objtype.c @@ -1,3 +1,5 @@ +#include +#include #include #include @@ -9,6 +11,13 @@ #include "runtime0.h" #include "runtime.h" +#if 0 // print debugging info +#define DEBUG_PRINT (1) +#define DEBUG_printf DEBUG_printf +#else // don't print debugging info +#define DEBUG_printf(...) (void)0 +#endif + /******************************************************************************/ // class object // creating an instance of a class makes one of these objects @@ -16,19 +25,65 @@ typedef struct _mp_obj_class_t { mp_obj_base_t base; mp_map_t members; + mp_obj_t subobj[]; // TODO maybe cache __getattr__ and __setattr__ for efficient lookup of them } mp_obj_class_t; -STATIC mp_obj_t mp_obj_new_class(mp_obj_t class) { - mp_obj_class_t *o = m_new_obj(mp_obj_class_t); +#define is_native_type(type) ((type)->make_new != class_make_new) +STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args); + +STATIC mp_obj_t mp_obj_new_class(mp_obj_t class, uint subobjs) { + mp_obj_class_t *o = m_new_obj_var(mp_obj_class_t, mp_obj_t, subobjs); o->base.type = class; mp_map_init(&o->members, 0); + mp_seq_clear(o->subobj, 0, subobjs, sizeof(*o->subobj)); return o; } +STATIC int class_count_native_bases(const mp_obj_type_t *type, const mp_obj_type_t **last_native_base) { + uint len; + mp_obj_t *items; + mp_obj_tuple_get(type->bases_tuple, &len, &items); + + int count = 0; + for (uint i = 0; i < len; i++) { + assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); + if (is_native_type((const mp_obj_type_t *)items[i])) { + *last_native_base = items[i]; + count++; + } else { + count += class_count_native_bases(items[i], last_native_base); + } + } + + return count; +} + +// TODO +// This implements depth-first left-to-right MRO, which is not compliant with Python3 MRO +// http://python-history.blogspot.com/2010/06/method-resolution-order.html +// https://www.python.org/download/releases/2.3/mro/ +// // will return MP_OBJ_NULL if not found -STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) { +// will return MP_OBJ_SENTINEL if special method was found in a native type base +// via slot id (meth_offset). As there can be only one native base, it's known that it +// applies to instance->subobj[0]. In most cases, we also don't need to know which type +// it was - because instance->subobj[0] is of that type. The only exception is when +// object is not yet constructed, then we need to know base native type to construct +// instance->subobj[0]. This case is handled via class_count_native_bases() though. +STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset) { for (;;) { + // Optimize special method lookup for native types + // This avoids extra method_name => slot lookup. On the other hand, + // this should not be applied to class types, as will result in extra + // lookup either. + if (meth_offset != 0 && is_native_type(type)) { + if (*(void**)((char*)type + meth_offset) != NULL) { + DEBUG_printf("mp_obj_class_lookup: matched special meth slot for %s\n", qstr_str(attr)); + return MP_OBJ_SENTINEL; + } + } + if (type->locals_dict != NULL) { // search locals_dict (the set of methods/attributes) assert(MP_OBJ_IS_TYPE(type->locals_dict, &mp_type_dict)); // Micro Python restriction, for now @@ -54,7 +109,7 @@ STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) { } for (uint i = 0; i < len - 1; i++) { assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); - mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr); + mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, meth_offset); if (obj != MP_OBJ_NULL) { return obj; } @@ -69,10 +124,15 @@ STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) { STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { mp_obj_class_t *self = self_in; qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__; - mp_obj_t member = mp_obj_class_lookup(self->base.type, meth); + mp_obj_t member = mp_obj_class_lookup(self->base.type, meth, offsetof(mp_obj_type_t, print)); if (member == MP_OBJ_NULL && kind == PRINT_STR) { // If there's no __str__, fall back to __repr__ - member = mp_obj_class_lookup(self->base.type, MP_QSTR___repr__); + member = mp_obj_class_lookup(self->base.type, MP_QSTR___repr__, 0); + } + + if (member == MP_OBJ_SENTINEL) { + mp_obj_print_helper(print, env, self->subobj[0], kind); + return; } if (member != MP_OBJ_NULL) { @@ -89,13 +149,25 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type)); mp_obj_type_t *self = self_in; - mp_obj_t o = mp_obj_new_class(self_in); + const mp_obj_type_t *native_base; + uint num_native_bases = class_count_native_bases(self, &native_base); + assert(num_native_bases < 2); + + mp_obj_class_t *o = mp_obj_new_class(self_in, num_native_bases); // look for __init__ function - mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__); + mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new)); - if (init_fn != MP_OBJ_NULL) { - // call __init__ function + if (init_fn == MP_OBJ_SENTINEL) { + // Native type's constructor is what wins - it gets all our arguments, + // and none Python classes are initialized at all. + o->subobj[0] = native_base->make_new((mp_obj_type_t*)native_base, n_args, n_kw, args); + } else if (init_fn != MP_OBJ_NULL) { + // We need to default-initialize any native subobjs first + if (num_native_bases > 0) { + o->subobj[0] = native_base->make_new((mp_obj_type_t*)native_base, 0, 0, NULL); + } + // now call Python class __init__ function with all args mp_obj_t init_ret; if (n_args == 0 && n_kw == 0) { init_ret = mp_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o); @@ -111,9 +183,8 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m } } else { - // TODO if (n_args != 0) { - nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 0 positional arguments but %d were given", n_args)); + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "object() takes no parameters")); } } @@ -132,11 +203,15 @@ STATIC const qstr unary_op_method_name[] = { STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) { mp_obj_class_t *self = self_in; qstr op_name = unary_op_method_name[op]; + /* Still try to lookup native slot if (op_name == 0) { return MP_OBJ_NOT_SUPPORTED; } - mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name); - if (member != MP_OBJ_NULL) { + */ + mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name, offsetof(mp_obj_type_t, unary_op)); + if (member == MP_OBJ_SENTINEL) { + return mp_unary_op(op, self->subobj[0]); + } else if (member != MP_OBJ_NULL) { return mp_call_function_1(member, self_in); } else { return MP_OBJ_NOT_SUPPORTED; @@ -210,11 +285,15 @@ STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) { // __getattr__ or __getattribute__. It only looks in the class dictionary. mp_obj_class_t *lhs = lhs_in; qstr op_name = binary_op_method_name[op]; + /* Still try to lookup native slot if (op_name == 0) { return MP_OBJ_NOT_SUPPORTED; } - mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name); - if (member != MP_OBJ_NULL) { + */ + mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op)); + if (member == MP_OBJ_SENTINEL) { + return mp_binary_op(op, lhs->subobj[0], rhs_in); + } else if (member != MP_OBJ_NULL) { mp_obj_t dest[3]; dest[1] = MP_OBJ_NULL; class_convert_return_attr(lhs_in, member, dest); @@ -237,7 +316,7 @@ STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { return; } - mp_obj_t member = mp_obj_class_lookup(self->base.type, attr); + mp_obj_t member = mp_obj_class_lookup(self->base.type, attr, 0); if (member != MP_OBJ_NULL) { if (0) { #if MICROPY_ENABLE_PROPERTY @@ -280,7 +359,7 @@ STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) { #if MICROPY_ENABLE_PROPERTY // for property, we need to do a lookup first in the class dict // this makes all stores slow... how to fix? - mp_obj_t member = mp_obj_class_lookup(self->base.type, attr); + mp_obj_t member = mp_obj_class_lookup(self->base.type, attr, 0); if (member != MP_OBJ_NULL && MP_OBJ_IS_TYPE(member, &mp_type_property)) { // attribute already exists and is a property // delegate the store to the property @@ -313,18 +392,20 @@ STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { uint meth_args; if (value == MP_OBJ_NULL) { // delete item - member = mp_obj_class_lookup(self->base.type, MP_QSTR___delitem__); + member = mp_obj_class_lookup(self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr)); meth_args = 2; } else if (value == MP_OBJ_SENTINEL) { // load item - member = mp_obj_class_lookup(self->base.type, MP_QSTR___getitem__); + member = mp_obj_class_lookup(self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr)); meth_args = 2; } else { // store item - member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__); + member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr)); meth_args = 3; } - if (member != MP_OBJ_NULL) { + if (member == MP_OBJ_SENTINEL) { + return mp_obj_subscr(self->subobj[0], index, value); + } else if (member != MP_OBJ_NULL) { mp_obj_t args[3] = {self_in, index, value}; // TODO probably need to call class_convert_return_attr, and use mp_call_method_n_kw mp_obj_t ret = mp_call_function_n_kw(member, meth_args, 0, args); @@ -340,10 +421,13 @@ STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { STATIC mp_obj_t class_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) { mp_obj_class_t *self = self_in; - mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___call__); + mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call)); if (member == MP_OBJ_NULL) { return member; } + if (member == MP_OBJ_SENTINEL) { + return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args); + } mp_obj_t meth = mp_obj_new_bound_meth(member, self); return mp_call_function_n_kw(meth, n_args, n_kw, args); } @@ -403,7 +487,7 @@ STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { return; } #endif - mp_obj_t member = mp_obj_class_lookup(self, attr); + mp_obj_t member = mp_obj_class_lookup(self, attr, 0); if (member != MP_OBJ_NULL) { // check if the methods are functions, static or class methods // see http://docs.python.org/3.3/howto/descriptor.html @@ -474,6 +558,20 @@ const mp_obj_type_t mp_type_type = { mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) { assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now + + // Basic validation of base classes + uint len; + mp_obj_t *items; + mp_obj_tuple_get(bases_tuple, &len, &items); + for (uint i = 0; i < len; i++) { + assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); + mp_obj_type_t *t = items[i]; + // TODO: Verify with CPy, tested on function type + if (t->make_new == NULL) { + nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "type '%s' is not an acceptable base type", qstr_str(t->name))); + } + } + mp_obj_type_t *o = m_new0(mp_obj_type_t, 1); o->base.type = &mp_type_type; o->name = name; @@ -487,6 +585,13 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) o->call = class_call; o->bases_tuple = bases_tuple; o->locals_dict = locals_dict; + + const mp_obj_type_t *native_base; + uint num_native_bases = class_count_native_bases(o, &native_base); + if (num_native_bases > 1) { + nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "multiple bases have instance lay-out conflict")); + } + return o; } @@ -536,7 +641,7 @@ STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { mp_obj_tuple_get(type->bases_tuple, &len, &items); for (uint i = 0; i < len; i++) { assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); - mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr); + mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, 0); if (member != MP_OBJ_NULL) { class_convert_return_attr(self->obj, member, dest); return; From 4f46c441efef3a88498c186fdace5614bbe26cd7 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 29 Apr 2014 02:44:13 +0300 Subject: [PATCH 2/6] tests: Add basic tests for subclassing native types and using special methods. Even of these, some features do not yet work as expected. --- tests/basics/subclass-native1.py | 31 ++++++++++++++++++++++++++ tests/basics/subclass-native2.py | 37 ++++++++++++++++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 tests/basics/subclass-native1.py create mode 100644 tests/basics/subclass-native2.py diff --git a/tests/basics/subclass-native1.py b/tests/basics/subclass-native1.py new file mode 100644 index 0000000000..a176893425 --- /dev/null +++ b/tests/basics/subclass-native1.py @@ -0,0 +1,31 @@ +class mylist(list): + pass + +a = mylist([1, 2, 5]) +# Test setting instance attr +a.attr = "something" +# Test base type __str__ +print(a) +# Test getting instance attr +print(a.attr) +# Test base type ->subscr +print(a[-1]) +a[0] = -1 +print(a) +# Test another base type unary op +print(len(a)) + +# Test binary op of base type, with 2nd arg being raw base type +print(a + [20, 30, 40]) +# Test binary op of base type, with 2nd arg being same class as 1st arg +# TODO: Faults +#print(a + a) + +def foo(): + print("hello from foo") + +try: + class myfunc(type(foo)): + pass +except TypeError: + print("TypeError") diff --git a/tests/basics/subclass-native2.py b/tests/basics/subclass-native2.py new file mode 100644 index 0000000000..749bf969cf --- /dev/null +++ b/tests/basics/subclass-native2.py @@ -0,0 +1,37 @@ +class Base1: + def __init__(self, *args): + print("Base1.__init__",args) + +class Clist1(Base1, list): + pass + +class Ctuple1(Base1, tuple): + pass + +a = Clist1() +print(len(a)) +a = Clist1([1, 2, 3]) +print(len(a)) + +a = Ctuple1() +print(len(a)) +a = Ctuple1([1, 2, 3]) +# TODO: Faults +#print(len(a)) + +print("---") + +class Clist2(list, Base1): + pass + +class Ctuple2(tuple, Base1): + pass +a = Clist2() +print(len(a)) +a = Clist2([1, 2, 3]) +print(len(a)) + +#a = Ctuple2() +#print(len(a)) +#a = Ctuple2([1, 2, 3]) +#print(len(a)) From 443857de98025d022070a73d5ca79ed4841e90c0 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 29 Apr 2014 03:16:38 +0300 Subject: [PATCH 3/6] objtype: Add support for looking up non-method attrs in native base class. --- py/objtype.c | 41 ++++++++++++++++++++++++++--------------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/py/objtype.c b/py/objtype.c index 4491eb0d5b..fc08ce0637 100644 --- a/py/objtype.c +++ b/py/objtype.c @@ -71,7 +71,7 @@ STATIC int class_count_native_bases(const mp_obj_type_t *type, const mp_obj_type // it was - because instance->subobj[0] is of that type. The only exception is when // object is not yet constructed, then we need to know base native type to construct // instance->subobj[0]. This case is handled via class_count_native_bases() though. -STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset) { +STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset) { for (;;) { // Optimize special method lookup for native types // This avoids extra method_name => slot lookup. On the other hand, @@ -94,6 +94,17 @@ STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, machin } } + if (o != MP_OBJ_NULL && is_native_type(type)) { + mp_obj_t dest[2]; + mp_load_method_maybe(o->subobj[0], attr, dest); + if (dest[0] != MP_OBJ_NULL) { + if (dest[1] == MP_OBJ_NULL) { + return dest[0]; + } + assert(0); + } + } + // attribute not found, keep searching base classes // for a const struct, this entry might be NULL @@ -109,7 +120,7 @@ STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, machin } for (uint i = 0; i < len - 1; i++) { assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); - mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, meth_offset); + mp_obj_t obj = mp_obj_class_lookup(o, (mp_obj_type_t*)items[i], attr, meth_offset); if (obj != MP_OBJ_NULL) { return obj; } @@ -124,10 +135,10 @@ STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, machin STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { mp_obj_class_t *self = self_in; qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__; - mp_obj_t member = mp_obj_class_lookup(self->base.type, meth, offsetof(mp_obj_type_t, print)); + mp_obj_t member = mp_obj_class_lookup(self, self->base.type, meth, offsetof(mp_obj_type_t, print)); if (member == MP_OBJ_NULL && kind == PRINT_STR) { // If there's no __str__, fall back to __repr__ - member = mp_obj_class_lookup(self->base.type, MP_QSTR___repr__, 0); + member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___repr__, 0); } if (member == MP_OBJ_SENTINEL) { @@ -156,7 +167,7 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m mp_obj_class_t *o = mp_obj_new_class(self_in, num_native_bases); // look for __init__ function - mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new)); + mp_obj_t init_fn = mp_obj_class_lookup(NULL, self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new)); if (init_fn == MP_OBJ_SENTINEL) { // Native type's constructor is what wins - it gets all our arguments, @@ -208,7 +219,7 @@ STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) { return MP_OBJ_NOT_SUPPORTED; } */ - mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name, offsetof(mp_obj_type_t, unary_op)); + mp_obj_t member = mp_obj_class_lookup(self, self->base.type, op_name, offsetof(mp_obj_type_t, unary_op)); if (member == MP_OBJ_SENTINEL) { return mp_unary_op(op, self->subobj[0]); } else if (member != MP_OBJ_NULL) { @@ -290,7 +301,7 @@ STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) { return MP_OBJ_NOT_SUPPORTED; } */ - mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op)); + mp_obj_t member = mp_obj_class_lookup(lhs, lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op)); if (member == MP_OBJ_SENTINEL) { return mp_binary_op(op, lhs->subobj[0], rhs_in); } else if (member != MP_OBJ_NULL) { @@ -316,7 +327,7 @@ STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { return; } - mp_obj_t member = mp_obj_class_lookup(self->base.type, attr, 0); + mp_obj_t member = mp_obj_class_lookup(self, self->base.type, attr, 0); if (member != MP_OBJ_NULL) { if (0) { #if MICROPY_ENABLE_PROPERTY @@ -359,7 +370,7 @@ STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) { #if MICROPY_ENABLE_PROPERTY // for property, we need to do a lookup first in the class dict // this makes all stores slow... how to fix? - mp_obj_t member = mp_obj_class_lookup(self->base.type, attr, 0); + mp_obj_t member = mp_obj_class_lookup(self, self->base.type, attr, 0); if (member != MP_OBJ_NULL && MP_OBJ_IS_TYPE(member, &mp_type_property)) { // attribute already exists and is a property // delegate the store to the property @@ -392,15 +403,15 @@ STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { uint meth_args; if (value == MP_OBJ_NULL) { // delete item - member = mp_obj_class_lookup(self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr)); + member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr)); meth_args = 2; } else if (value == MP_OBJ_SENTINEL) { // load item - member = mp_obj_class_lookup(self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr)); + member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr)); meth_args = 2; } else { // store item - member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr)); + member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr)); meth_args = 3; } if (member == MP_OBJ_SENTINEL) { @@ -421,7 +432,7 @@ STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { STATIC mp_obj_t class_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) { mp_obj_class_t *self = self_in; - mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call)); + mp_obj_t member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call)); if (member == MP_OBJ_NULL) { return member; } @@ -487,7 +498,7 @@ STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { return; } #endif - mp_obj_t member = mp_obj_class_lookup(self, attr, 0); + mp_obj_t member = mp_obj_class_lookup(NULL, self, attr, 0); if (member != MP_OBJ_NULL) { // check if the methods are functions, static or class methods // see http://docs.python.org/3.3/howto/descriptor.html @@ -641,7 +652,7 @@ STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { mp_obj_tuple_get(type->bases_tuple, &len, &items); for (uint i = 0; i < len; i++) { assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); - mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, 0); + mp_obj_t member = mp_obj_class_lookup(self->obj, (mp_obj_type_t*)items[i], attr, 0); if (member != MP_OBJ_NULL) { class_convert_return_attr(self->obj, member, dest); return; From 5a12137c3e766451d83e6598ba93d16e0a8cbde8 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Tue, 29 Apr 2014 03:28:31 +0300 Subject: [PATCH 4/6] tests: Add test for accessing attribute of inherited native type. --- tests/basics/subclass-native3.py | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 tests/basics/subclass-native3.py diff --git a/tests/basics/subclass-native3.py b/tests/basics/subclass-native3.py new file mode 100644 index 0000000000..5d443cf5cd --- /dev/null +++ b/tests/basics/subclass-native3.py @@ -0,0 +1,8 @@ +class MyExc(Exception): + pass + +e = MyExc(100, "Some error") +print(e) +# TODO: Prints native base class name +#print(repr(e)) +print(e.args) From 7f0419c0e528faf444c60dea461f172143dbc88d Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Wed, 30 Apr 2014 02:14:30 +0300 Subject: [PATCH 5/6] objtype: Support calling normal methods inherited from native base class. Biggest part of this support is refactoring mp_obj_class_lookup() to return standard "bound member" pair (mp_obj_t[2]). Actual support of inherited native methods is 3 lines then. Some inherited features may be not supported yet (e.g. native class methods, native properties, etc., etc.). There may be opportunities for further optimization too. --- py/objtype.c | 137 +++++++++++++++++++++++++++++---------------------- 1 file changed, 78 insertions(+), 59 deletions(-) diff --git a/py/objtype.c b/py/objtype.c index fc08ce0637..56a5dd937d 100644 --- a/py/objtype.c +++ b/py/objtype.c @@ -71,7 +71,9 @@ STATIC int class_count_native_bases(const mp_obj_type_t *type, const mp_obj_type // it was - because instance->subobj[0] is of that type. The only exception is when // object is not yet constructed, then we need to know base native type to construct // instance->subobj[0]. This case is handled via class_count_native_bases() though. -STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset) { +STATIC void mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset, mp_obj_t *dest) { + assert(dest[0] == NULL); + assert(dest[1] == NULL); for (;;) { // Optimize special method lookup for native types // This avoids extra method_name => slot lookup. On the other hand, @@ -80,7 +82,8 @@ STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type if (meth_offset != 0 && is_native_type(type)) { if (*(void**)((char*)type + meth_offset) != NULL) { DEBUG_printf("mp_obj_class_lookup: matched special meth slot for %s\n", qstr_str(attr)); - return MP_OBJ_SENTINEL; + dest[0] = MP_OBJ_SENTINEL; + return; } } @@ -90,18 +93,20 @@ STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict); mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP); if (elem != NULL) { - return elem->value; + dest[0] = elem->value; + if (o != MP_OBJ_NULL && is_native_type(type)) { + dest[1] = o->subobj[0]; + } + return; } } + // Try this for completeness, by all native methods should be statically defined + // in locals_dict, and would be handled by above. if (o != MP_OBJ_NULL && is_native_type(type)) { - mp_obj_t dest[2]; mp_load_method_maybe(o->subobj[0], attr, dest); if (dest[0] != MP_OBJ_NULL) { - if (dest[1] == MP_OBJ_NULL) { - return dest[0]; - } - assert(0); + return; } } @@ -109,20 +114,20 @@ STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type // for a const struct, this entry might be NULL if (type->bases_tuple == MP_OBJ_NULL) { - return MP_OBJ_NULL; + return; } uint len; mp_obj_t *items; mp_obj_tuple_get(type->bases_tuple, &len, &items); if (len == 0) { - return MP_OBJ_NULL; + return; } for (uint i = 0; i < len - 1; i++) { assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); - mp_obj_t obj = mp_obj_class_lookup(o, (mp_obj_type_t*)items[i], attr, meth_offset); - if (obj != MP_OBJ_NULL) { - return obj; + mp_obj_class_lookup(o, (mp_obj_type_t*)items[i], attr, meth_offset, dest); + if (dest[0] != MP_OBJ_NULL) { + return; } } @@ -135,19 +140,20 @@ STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) { mp_obj_class_t *self = self_in; qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__; - mp_obj_t member = mp_obj_class_lookup(self, self->base.type, meth, offsetof(mp_obj_type_t, print)); - if (member == MP_OBJ_NULL && kind == PRINT_STR) { + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(self, self->base.type, meth, offsetof(mp_obj_type_t, print), member); + if (member[0] == MP_OBJ_NULL && kind == PRINT_STR) { // If there's no __str__, fall back to __repr__ - member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___repr__, 0); + mp_obj_class_lookup(self, self->base.type, MP_QSTR___repr__, 0, member); } - if (member == MP_OBJ_SENTINEL) { + if (member[0] == MP_OBJ_SENTINEL) { mp_obj_print_helper(print, env, self->subobj[0], kind); return; } - if (member != MP_OBJ_NULL) { - mp_obj_t r = mp_call_function_1(member, self_in); + if (member[0] != MP_OBJ_NULL) { + mp_obj_t r = mp_call_function_1(member[0], self_in); mp_obj_print_helper(print, env, r, PRINT_STR); return; } @@ -167,13 +173,14 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m mp_obj_class_t *o = mp_obj_new_class(self_in, num_native_bases); // look for __init__ function - mp_obj_t init_fn = mp_obj_class_lookup(NULL, self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new)); + mp_obj_t init_fn[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(NULL, self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new), init_fn); - if (init_fn == MP_OBJ_SENTINEL) { + if (init_fn[0] == MP_OBJ_SENTINEL) { // Native type's constructor is what wins - it gets all our arguments, // and none Python classes are initialized at all. o->subobj[0] = native_base->make_new((mp_obj_type_t*)native_base, n_args, n_kw, args); - } else if (init_fn != MP_OBJ_NULL) { + } else if (init_fn[0] != MP_OBJ_NULL) { // We need to default-initialize any native subobjs first if (num_native_bases > 0) { o->subobj[0] = native_base->make_new((mp_obj_type_t*)native_base, 0, 0, NULL); @@ -181,12 +188,12 @@ STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const m // now call Python class __init__ function with all args mp_obj_t init_ret; if (n_args == 0 && n_kw == 0) { - init_ret = mp_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o); + init_ret = mp_call_function_n_kw(init_fn[0], 1, 0, (mp_obj_t*)&o); } else { mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw); args2[0] = o; memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t)); - init_ret = mp_call_function_n_kw(init_fn, n_args + 1, n_kw, args2); + init_ret = mp_call_function_n_kw(init_fn[0], n_args + 1, n_kw, args2); m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw); } if (init_ret != mp_const_none) { @@ -219,11 +226,12 @@ STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) { return MP_OBJ_NOT_SUPPORTED; } */ - mp_obj_t member = mp_obj_class_lookup(self, self->base.type, op_name, offsetof(mp_obj_type_t, unary_op)); - if (member == MP_OBJ_SENTINEL) { + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(self, self->base.type, op_name, offsetof(mp_obj_type_t, unary_op), member); + if (member[0] == MP_OBJ_SENTINEL) { return mp_unary_op(op, self->subobj[0]); - } else if (member != MP_OBJ_NULL) { - return mp_call_function_1(member, self_in); + } else if (member[0] != MP_OBJ_NULL) { + return mp_call_function_1(member[0], self_in); } else { return MP_OBJ_NOT_SUPPORTED; } @@ -274,6 +282,7 @@ STATIC const qstr binary_op_method_name[] = { // Conversion means dealing with static/class methods, callables, and values. // see http://docs.python.org/3.3/howto/descriptor.html STATIC void class_convert_return_attr(mp_obj_t self, mp_obj_t member, mp_obj_t *dest) { + assert(dest[1] == NULL); if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) { // return just the function dest[0] = ((mp_obj_static_class_method_t*)member)->fun; @@ -301,13 +310,14 @@ STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) { return MP_OBJ_NOT_SUPPORTED; } */ - mp_obj_t member = mp_obj_class_lookup(lhs, lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op)); - if (member == MP_OBJ_SENTINEL) { + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(lhs, lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op), member); + if (member[0] == MP_OBJ_SENTINEL) { return mp_binary_op(op, lhs->subobj[0], rhs_in); - } else if (member != MP_OBJ_NULL) { + } else if (member[0] != MP_OBJ_NULL) { mp_obj_t dest[3]; dest[1] = MP_OBJ_NULL; - class_convert_return_attr(lhs_in, member, dest); + class_convert_return_attr(lhs_in, member[0], dest); dest[2] = rhs_in; return mp_call_method_n_kw(1, 0, dest); } else { @@ -327,7 +337,8 @@ STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { return; } - mp_obj_t member = mp_obj_class_lookup(self, self->base.type, attr, 0); + mp_obj_class_lookup(self, self->base.type, attr, 0, dest); + mp_obj_t member = dest[0]; if (member != MP_OBJ_NULL) { if (0) { #if MICROPY_ENABLE_PROPERTY @@ -345,7 +356,11 @@ STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { #endif } else { // not a property - class_convert_return_attr(self_in, member, dest); + // if we don't yet have bound method (supposedly from native base), go + // try to convert own attrs. + if (dest[1] == MP_OBJ_NULL) { + class_convert_return_attr(self_in, member, dest); + } } return; } @@ -370,11 +385,12 @@ STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) { #if MICROPY_ENABLE_PROPERTY // for property, we need to do a lookup first in the class dict // this makes all stores slow... how to fix? - mp_obj_t member = mp_obj_class_lookup(self, self->base.type, attr, 0); - if (member != MP_OBJ_NULL && MP_OBJ_IS_TYPE(member, &mp_type_property)) { + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(self, self->base.type, attr, 0, member); + if (member[0] != MP_OBJ_NULL && MP_OBJ_IS_TYPE(member[0], &mp_type_property)) { // attribute already exists and is a property // delegate the store to the property - const mp_obj_t *proxy = mp_obj_property_get(member); + const mp_obj_t *proxy = mp_obj_property_get(member[0]); if (proxy[1] == mp_const_none) { // TODO better error message return false; @@ -399,27 +415,27 @@ STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) { STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { mp_obj_class_t *self = self_in; - mp_obj_t member; + mp_obj_t member[2] = {MP_OBJ_NULL}; uint meth_args; if (value == MP_OBJ_NULL) { // delete item - member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr)); + mp_obj_class_lookup(self, self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr), member); meth_args = 2; } else if (value == MP_OBJ_SENTINEL) { // load item - member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr)); + mp_obj_class_lookup(self, self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr), member); meth_args = 2; } else { // store item - member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr)); + mp_obj_class_lookup(self, self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr), member); meth_args = 3; } - if (member == MP_OBJ_SENTINEL) { + if (member[0] == MP_OBJ_SENTINEL) { return mp_obj_subscr(self->subobj[0], index, value); - } else if (member != MP_OBJ_NULL) { + } else if (member[0] != MP_OBJ_NULL) { mp_obj_t args[3] = {self_in, index, value}; // TODO probably need to call class_convert_return_attr, and use mp_call_method_n_kw - mp_obj_t ret = mp_call_function_n_kw(member, meth_args, 0, args); + mp_obj_t ret = mp_call_function_n_kw(member[0], meth_args, 0, args); if (value == MP_OBJ_SENTINEL) { return ret; } else { @@ -432,14 +448,15 @@ STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { STATIC mp_obj_t class_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) { mp_obj_class_t *self = self_in; - mp_obj_t member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call)); - if (member == MP_OBJ_NULL) { - return member; + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(self, self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call), member); + if (member[0] == MP_OBJ_NULL) { + return MP_OBJ_NULL; } - if (member == MP_OBJ_SENTINEL) { + if (member[0] == MP_OBJ_SENTINEL) { return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args); } - mp_obj_t meth = mp_obj_new_bound_meth(member, self); + mp_obj_t meth = mp_obj_new_bound_meth(member[0], self); return mp_call_function_n_kw(meth, n_args, n_kw, args); } @@ -498,21 +515,22 @@ STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { return; } #endif - mp_obj_t member = mp_obj_class_lookup(NULL, self, attr, 0); - if (member != MP_OBJ_NULL) { + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(NULL, self, attr, 0, member); + if (member[0] != MP_OBJ_NULL) { // check if the methods are functions, static or class methods // see http://docs.python.org/3.3/howto/descriptor.html - if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) { + if (MP_OBJ_IS_TYPE(member[0], &mp_type_staticmethod)) { // return just the function - dest[0] = ((mp_obj_static_class_method_t*)member)->fun; - } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) { + dest[0] = ((mp_obj_static_class_method_t*)member[0])->fun; + } else if (MP_OBJ_IS_TYPE(member[0], &mp_type_classmethod)) { // return a bound method, with self being this class - dest[0] = ((mp_obj_static_class_method_t*)member)->fun; + dest[0] = ((mp_obj_static_class_method_t*)member[0])->fun; dest[1] = self_in; } else { // return just the function // TODO need to wrap in a type check for the first argument; eg list.append(1,1) needs to throw an exception - dest[0] = (mp_obj_t)member; + dest[0] = member[0]; } } } @@ -652,9 +670,10 @@ STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { mp_obj_tuple_get(type->bases_tuple, &len, &items); for (uint i = 0; i < len; i++) { assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type)); - mp_obj_t member = mp_obj_class_lookup(self->obj, (mp_obj_type_t*)items[i], attr, 0); - if (member != MP_OBJ_NULL) { - class_convert_return_attr(self->obj, member, dest); + mp_obj_t member[2] = {MP_OBJ_NULL}; + mp_obj_class_lookup(self->obj, (mp_obj_type_t*)items[i], attr, 0, member); + if (member[0] != MP_OBJ_NULL) { + class_convert_return_attr(self->obj, member[0], dest); return; } } From c963310123765baddf638c8d08b8fdb2f73b6ba6 Mon Sep 17 00:00:00 2001 From: Paul Sokolovsky Date: Wed, 30 Apr 2014 02:17:45 +0300 Subject: [PATCH 6/6] tests: Add test for calling inherited native method on subclass. --- tests/basics/subclass-native4.py | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 tests/basics/subclass-native4.py diff --git a/tests/basics/subclass-native4.py b/tests/basics/subclass-native4.py new file mode 100644 index 0000000000..b426793f59 --- /dev/null +++ b/tests/basics/subclass-native4.py @@ -0,0 +1,9 @@ +# Test calling non-special method inherited from native type + +class mylist(list): + pass + +l = mylist([1, 2, 3]) +print(l) +l.append(10) +print(l)