2014-05-03 18:27:38 -04:00
|
|
|
/*
|
2017-06-30 03:22:17 -04:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 18:27:38 -04:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
2016-11-21 17:33:55 -05:00
|
|
|
* Copyright (c) 2014-2016 Paul Sokolovsky
|
2014-05-03 18:27:38 -04:00
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2014-04-28 19:42:28 -04:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stddef.h>
|
2014-01-09 15:57:50 -05:00
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
2013-12-21 13:17:45 -05:00
|
|
|
|
2015-01-01 15:27:54 -05:00
|
|
|
#include "py/objtype.h"
|
|
|
|
#include "py/runtime.h"
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2017-07-24 12:55:14 -04:00
|
|
|
#if MICROPY_DEBUG_VERBOSE // print debugging info
|
2014-04-28 19:42:28 -04:00
|
|
|
#define DEBUG_PRINT (1)
|
|
|
|
#define DEBUG_printf DEBUG_printf
|
|
|
|
#else // don't print debugging info
|
2014-11-05 16:16:41 -05:00
|
|
|
#define DEBUG_PRINT (0)
|
2014-04-28 19:42:28 -04:00
|
|
|
#define DEBUG_printf(...) (void)0
|
|
|
|
#endif
|
|
|
|
|
2016-01-03 10:55:55 -05:00
|
|
|
STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
|
2014-07-05 00:55:00 -04:00
|
|
|
|
2014-01-09 15:57:50 -05:00
|
|
|
/******************************************************************************/
|
2014-05-01 19:13:04 -04:00
|
|
|
// instance object
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2017-03-24 01:58:13 -04:00
|
|
|
STATIC mp_obj_t mp_obj_new_instance(const mp_obj_type_t *class, size_t subobjs) {
|
2014-05-01 19:13:04 -04:00
|
|
|
mp_obj_instance_t *o = m_new_obj_var(mp_obj_instance_t, mp_obj_t, subobjs);
|
2016-01-03 10:55:55 -05:00
|
|
|
o->base.type = class;
|
2014-01-09 15:57:50 -05:00
|
|
|
mp_map_init(&o->members, 0);
|
2014-04-28 19:42:28 -04:00
|
|
|
mp_seq_clear(o->subobj, 0, subobjs, sizeof(*o->subobj));
|
2015-11-27 12:01:44 -05:00
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
|
|
|
|
2014-05-03 12:19:35 -04:00
|
|
|
STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_type_t **last_native_base) {
|
2014-04-28 19:42:28 -04:00
|
|
|
int count = 0;
|
2017-04-05 22:09:01 -04:00
|
|
|
for (;;) {
|
|
|
|
if (type == &mp_type_object) {
|
|
|
|
// Not a "real" type, end search here.
|
|
|
|
return count;
|
|
|
|
} else if (mp_obj_is_native_type(type)) {
|
|
|
|
// Native types don't have parents (at least not from our perspective) so end.
|
|
|
|
*last_native_base = type;
|
|
|
|
return count + 1;
|
|
|
|
} else if (type->parent == NULL) {
|
|
|
|
// No parents so end search here.
|
|
|
|
return count;
|
2017-04-01 08:52:24 -04:00
|
|
|
#if MICROPY_MULTIPLE_INHERITANCE
|
2017-04-05 22:09:01 -04:00
|
|
|
} else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
|
|
|
|
// Multiple parents, search through them all recursively.
|
|
|
|
const mp_obj_tuple_t *parent_tuple = type->parent;
|
|
|
|
const mp_obj_t *item = parent_tuple->items;
|
|
|
|
const mp_obj_t *top = item + parent_tuple->len;
|
|
|
|
for (; item < top; ++item) {
|
|
|
|
assert(MP_OBJ_IS_TYPE(*item, &mp_type_type));
|
|
|
|
const mp_obj_type_t *bt = (const mp_obj_type_t *)MP_OBJ_TO_PTR(*item);
|
|
|
|
count += instance_count_native_bases(bt, last_native_base);
|
|
|
|
}
|
|
|
|
return count;
|
2017-04-01 08:52:24 -04:00
|
|
|
#endif
|
2014-04-28 19:42:28 -04:00
|
|
|
} else {
|
2017-04-05 22:09:01 -04:00
|
|
|
// A single parent, use iteration to continue the search.
|
|
|
|
type = type->parent;
|
2014-04-28 19:42:28 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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/
|
|
|
|
//
|
2015-03-16 07:32:03 -04:00
|
|
|
// will keep lookup->dest[0]'s value (should be MP_OBJ_NULL on invocation) if attribute
|
|
|
|
// is not found
|
|
|
|
// will set lookup->dest[0] to MP_OBJ_SENTINEL if special method was found in a native
|
|
|
|
// type base via slot id (as specified by lookup->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 its instance->subobj[0] from. But this case is handled via
|
|
|
|
// instance_count_native_bases(), which returns a native base which it saw.
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data {
|
|
|
|
mp_obj_instance_t *obj;
|
|
|
|
qstr attr;
|
2017-03-24 01:58:13 -04:00
|
|
|
size_t meth_offset;
|
2014-06-08 13:50:12 -04:00
|
|
|
mp_obj_t *dest;
|
2014-06-08 15:28:44 -04:00
|
|
|
bool is_type;
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
STATIC void mp_obj_class_lookup(struct class_lookup_data *lookup, const mp_obj_type_t *type) {
|
2015-11-27 12:01:44 -05:00
|
|
|
assert(lookup->dest[0] == MP_OBJ_NULL);
|
|
|
|
assert(lookup->dest[1] == MP_OBJ_NULL);
|
2014-01-09 16:43:51 -05:00
|
|
|
for (;;) {
|
2017-08-30 17:44:51 -04:00
|
|
|
DEBUG_printf("mp_obj_class_lookup: Looking up %s in %s\n", qstr_str(lookup->attr), qstr_str(type->name));
|
2014-04-28 19:42:28 -04:00
|
|
|
// 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.
|
2015-05-03 18:23:18 -04:00
|
|
|
if (lookup->meth_offset != 0 && mp_obj_is_native_type(type)) {
|
2014-06-08 13:50:12 -04:00
|
|
|
if (*(void**)((char*)type + lookup->meth_offset) != NULL) {
|
2017-08-30 17:44:51 -04:00
|
|
|
DEBUG_printf("mp_obj_class_lookup: Matched special meth slot (off=%d) for %s\n",
|
|
|
|
lookup->meth_offset, qstr_str(lookup->attr));
|
2014-06-08 13:50:12 -04:00
|
|
|
lookup->dest[0] = MP_OBJ_SENTINEL;
|
2014-04-29 19:14:30 -04:00
|
|
|
return;
|
2014-04-28 19:42:28 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-18 12:52:41 -05:00
|
|
|
if (type->locals_dict != NULL) {
|
2014-03-26 18:35:10 -04:00
|
|
|
// search locals_dict (the set of methods/attributes)
|
2015-11-27 12:01:44 -05:00
|
|
|
assert(type->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
|
|
|
|
mp_map_t *locals_map = &type->locals_dict->map;
|
2014-06-08 13:50:12 -04:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(lookup->attr), MP_MAP_LOOKUP);
|
2014-01-18 12:52:41 -05:00
|
|
|
if (elem != NULL) {
|
2014-06-08 15:28:44 -04:00
|
|
|
if (lookup->is_type) {
|
2015-03-19 18:51:26 -04:00
|
|
|
// If we look up a class method, we need to return original type for which we
|
|
|
|
// do a lookup, not a (base) type in which we found the class method.
|
2014-06-08 15:28:44 -04:00
|
|
|
const mp_obj_type_t *org_type = (const mp_obj_type_t*)lookup->obj;
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_convert_member_lookup(MP_OBJ_NULL, org_type, elem->value, lookup->dest);
|
2014-05-18 13:37:18 -04:00
|
|
|
} else {
|
2015-03-16 07:58:08 -04:00
|
|
|
mp_obj_instance_t *obj = lookup->obj;
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_t obj_obj;
|
|
|
|
if (obj != NULL && mp_obj_is_native_type(type) && type != &mp_type_object /* object is not a real type */) {
|
2015-03-16 07:58:08 -04:00
|
|
|
// If we're dealing with native base class, then it applies to native sub-object
|
2015-11-27 12:01:44 -05:00
|
|
|
obj_obj = obj->subobj[0];
|
|
|
|
} else {
|
|
|
|
obj_obj = MP_OBJ_FROM_PTR(obj);
|
2015-03-16 07:58:08 -04:00
|
|
|
}
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_convert_member_lookup(obj_obj, type, elem->value, lookup->dest);
|
2014-04-29 19:14:30 -04:00
|
|
|
}
|
2014-06-08 15:28:44 -04:00
|
|
|
#if DEBUG_PRINT
|
|
|
|
printf("mp_obj_class_lookup: Returning: ");
|
|
|
|
mp_obj_print(lookup->dest[0], PRINT_REPR); printf(" ");
|
2017-08-30 17:44:51 -04:00
|
|
|
// Don't try to repr() lookup->dest[1], as we can be called recursively
|
|
|
|
printf("<%s @%p>\n", mp_obj_get_type_str(lookup->dest[1]), lookup->dest[1]);
|
2014-06-08 15:28:44 -04:00
|
|
|
#endif
|
2014-04-29 19:14:30 -04:00
|
|
|
return;
|
2014-01-18 12:52:41 -05:00
|
|
|
}
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
|
2015-03-16 20:07:00 -04:00
|
|
|
// Previous code block takes care about attributes defined in .locals_dict,
|
|
|
|
// but some attributes of native types may be handled using .load_attr method,
|
|
|
|
// so make sure we try to lookup those too.
|
2015-11-27 12:01:44 -05:00
|
|
|
if (lookup->obj != NULL && !lookup->is_type && mp_obj_is_native_type(type) && type != &mp_type_object /* object is not a real type */) {
|
2014-06-08 13:50:12 -04:00
|
|
|
mp_load_method_maybe(lookup->obj->subobj[0], lookup->attr, lookup->dest);
|
|
|
|
if (lookup->dest[0] != MP_OBJ_NULL) {
|
2014-04-29 19:14:30 -04:00
|
|
|
return;
|
2014-04-28 20:16:38 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 16:43:51 -05:00
|
|
|
// attribute not found, keep searching base classes
|
|
|
|
|
2017-04-05 22:09:01 -04:00
|
|
|
if (type->parent == NULL) {
|
2017-08-30 17:44:51 -04:00
|
|
|
DEBUG_printf("mp_obj_class_lookup: No more parents\n");
|
2014-04-29 19:14:30 -04:00
|
|
|
return;
|
2017-04-01 08:52:24 -04:00
|
|
|
#if MICROPY_MULTIPLE_INHERITANCE
|
2017-04-05 22:09:01 -04:00
|
|
|
} else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
|
|
|
|
const mp_obj_tuple_t *parent_tuple = type->parent;
|
|
|
|
const mp_obj_t *item = parent_tuple->items;
|
|
|
|
const mp_obj_t *top = item + parent_tuple->len - 1;
|
|
|
|
for (; item < top; ++item) {
|
|
|
|
assert(MP_OBJ_IS_TYPE(*item, &mp_type_type));
|
|
|
|
mp_obj_type_t *bt = (mp_obj_type_t*)MP_OBJ_TO_PTR(*item);
|
|
|
|
if (bt == &mp_type_object) {
|
|
|
|
// Not a "real" type
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mp_obj_class_lookup(lookup, bt);
|
|
|
|
if (lookup->dest[0] != MP_OBJ_NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
|
2017-04-05 22:09:01 -04:00
|
|
|
// search last base (simple tail recursion elimination)
|
|
|
|
assert(MP_OBJ_IS_TYPE(*item, &mp_type_type));
|
|
|
|
type = (mp_obj_type_t*)MP_OBJ_TO_PTR(*item);
|
2017-04-01 08:52:24 -04:00
|
|
|
#endif
|
2017-04-05 22:09:01 -04:00
|
|
|
} else {
|
|
|
|
type = type->parent;
|
|
|
|
}
|
2014-05-09 19:03:43 -04:00
|
|
|
if (type == &mp_type_object) {
|
|
|
|
// Not a "real" type
|
|
|
|
return;
|
|
|
|
}
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-09 18:56:15 -04:00
|
|
|
STATIC void instance_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-03-16 09:16:54 -04:00
|
|
|
qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = meth,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, print),
|
|
|
|
.dest = member,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-29 19:14:30 -04:00
|
|
|
if (member[0] == MP_OBJ_NULL && kind == PRINT_STR) {
|
2014-03-16 09:16:54 -04:00
|
|
|
// If there's no __str__, fall back to __repr__
|
2014-06-08 13:50:12 -04:00
|
|
|
lookup.attr = MP_QSTR___repr__;
|
|
|
|
lookup.meth_offset = 0;
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-28 19:42:28 -04:00
|
|
|
}
|
|
|
|
|
2014-04-29 19:14:30 -04:00
|
|
|
if (member[0] == MP_OBJ_SENTINEL) {
|
2014-05-01 18:51:25 -04:00
|
|
|
// Handle Exception subclasses specially
|
|
|
|
if (mp_obj_is_native_exception_instance(self->subobj[0])) {
|
|
|
|
if (kind != PRINT_STR) {
|
2015-04-09 18:56:15 -04:00
|
|
|
mp_print_str(print, qstr_str(self->base.type->name));
|
2014-05-01 18:51:25 -04:00
|
|
|
}
|
2015-04-09 18:56:15 -04:00
|
|
|
mp_obj_print_helper(print, self->subobj[0], kind | PRINT_EXC_SUBCLASS);
|
2014-05-01 18:51:25 -04:00
|
|
|
} else {
|
2015-04-09 18:56:15 -04:00
|
|
|
mp_obj_print_helper(print, self->subobj[0], kind);
|
2014-05-01 18:51:25 -04:00
|
|
|
}
|
2014-04-28 19:42:28 -04:00
|
|
|
return;
|
2014-03-16 09:16:54 -04:00
|
|
|
}
|
|
|
|
|
2014-04-29 19:14:30 -04:00
|
|
|
if (member[0] != MP_OBJ_NULL) {
|
|
|
|
mp_obj_t r = mp_call_function_1(member[0], self_in);
|
2015-04-09 18:56:15 -04:00
|
|
|
mp_obj_print_helper(print, r, PRINT_STR);
|
2014-03-16 09:16:54 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: CPython prints fully-qualified type name
|
2016-03-14 18:41:14 -04:00
|
|
|
mp_printf(print, "<%s object at %p>", mp_obj_get_type_str(self_in), self);
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
|
|
|
|
2016-01-03 10:55:55 -05:00
|
|
|
mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-05-03 18:23:18 -04:00
|
|
|
assert(mp_obj_is_instance_type(self));
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2017-04-01 08:52:24 -04:00
|
|
|
const mp_obj_type_t *native_base = NULL;
|
2017-03-24 01:58:13 -04:00
|
|
|
size_t num_native_bases = instance_count_native_bases(self, &native_base);
|
2014-04-28 19:42:28 -04:00
|
|
|
assert(num_native_bases < 2);
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2016-01-03 10:55:55 -05:00
|
|
|
mp_obj_instance_t *o = MP_OBJ_TO_PTR(mp_obj_new_instance(self, num_native_bases));
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2017-08-30 13:44:18 -04:00
|
|
|
// This executes only "__new__" part of instance creation.
|
|
|
|
// TODO: This won't work well for classes with native bases.
|
|
|
|
// TODO: This is a hack, should be resolved along the lines of
|
2014-05-21 17:32:00 -04:00
|
|
|
// https://github.com/micropython/micropython/issues/606#issuecomment-43685883
|
|
|
|
if (n_args == 1 && *args == MP_OBJ_SENTINEL) {
|
2015-11-27 12:01:44 -05:00
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2014-05-21 17:32:00 -04:00
|
|
|
}
|
|
|
|
|
2014-05-18 13:37:18 -04:00
|
|
|
// look for __new__ function
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t init_fn[2] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = NULL,
|
|
|
|
.attr = MP_QSTR___new__,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, make_new),
|
|
|
|
.dest = init_fn,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self);
|
2014-04-28 19:42:28 -04:00
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_t new_ret = MP_OBJ_FROM_PTR(o);
|
2014-04-29 19:14:30 -04:00
|
|
|
if (init_fn[0] == MP_OBJ_SENTINEL) {
|
2014-04-28 19:42:28 -04:00
|
|
|
// Native type's constructor is what wins - it gets all our arguments,
|
|
|
|
// and none Python classes are initialized at all.
|
2016-01-03 10:55:55 -05:00
|
|
|
o->subobj[0] = native_base->make_new(native_base, n_args, n_kw, args);
|
2014-04-29 19:14:30 -04:00
|
|
|
} else if (init_fn[0] != MP_OBJ_NULL) {
|
2014-05-18 13:37:18 -04:00
|
|
|
// now call Python class __new__ function with all args
|
2014-01-18 09:10:48 -05:00
|
|
|
if (n_args == 0 && n_kw == 0) {
|
2016-01-03 10:55:55 -05:00
|
|
|
mp_obj_t args2[1] = {MP_OBJ_FROM_PTR(self)};
|
|
|
|
new_ret = mp_call_function_n_kw(init_fn[0], 1, 0, args2);
|
2014-01-09 15:57:50 -05:00
|
|
|
} else {
|
2014-01-18 09:10:48 -05:00
|
|
|
mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
|
2016-01-03 10:55:55 -05:00
|
|
|
args2[0] = MP_OBJ_FROM_PTR(self);
|
2014-01-18 09:10:48 -05:00
|
|
|
memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
|
2014-05-18 13:37:18 -04:00
|
|
|
new_ret = mp_call_function_n_kw(init_fn[0], n_args + 1, n_kw, args2);
|
2014-01-18 09:10:48 -05:00
|
|
|
m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
2014-05-18 13:37:18 -04:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// https://docs.python.org/3.4/reference/datamodel.html#object.__new__
|
2017-02-14 04:55:31 -05:00
|
|
|
// "If __new__() does not return an instance of cls, then the new instance's __init__() method will not be invoked."
|
2015-11-27 12:01:44 -05:00
|
|
|
if (mp_obj_get_type(new_ret) != self) {
|
2014-05-18 13:37:18 -04:00
|
|
|
return new_ret;
|
|
|
|
}
|
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
o = MP_OBJ_TO_PTR(new_ret);
|
2014-05-18 13:37:18 -04:00
|
|
|
|
|
|
|
// now call Python class __init__ function with all args
|
2014-10-23 07:06:53 -04:00
|
|
|
init_fn[0] = init_fn[1] = MP_OBJ_NULL;
|
2014-06-08 13:50:12 -04:00
|
|
|
lookup.obj = o;
|
|
|
|
lookup.attr = MP_QSTR___init__;
|
|
|
|
lookup.meth_offset = 0;
|
|
|
|
mp_obj_class_lookup(&lookup, self);
|
2014-05-18 13:37:18 -04:00
|
|
|
if (init_fn[0] != MP_OBJ_NULL) {
|
|
|
|
mp_obj_t init_ret;
|
|
|
|
if (n_args == 0 && n_kw == 0) {
|
|
|
|
init_ret = mp_call_method_n_kw(0, 0, init_fn);
|
|
|
|
} else {
|
|
|
|
mp_obj_t *args2 = m_new(mp_obj_t, 2 + n_args + 2 * n_kw);
|
|
|
|
args2[0] = init_fn[0];
|
|
|
|
args2[1] = init_fn[1];
|
|
|
|
memcpy(args2 + 2, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
|
|
|
|
init_ret = mp_call_method_n_kw(n_args, n_kw, args2);
|
|
|
|
m_del(mp_obj_t, args2, 2 + n_args + 2 * n_kw);
|
|
|
|
}
|
2014-01-09 15:57:50 -05:00
|
|
|
if (init_ret != mp_const_none) {
|
2014-11-06 12:36:16 -05:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("__init__() should return None");
|
2014-11-06 12:36:16 -05:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
|
|
|
|
}
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
|
|
|
|
2017-10-21 04:06:32 -04:00
|
|
|
// Qstrs for special methods are guaranteed to have a small value, so we use byte
|
|
|
|
// type to represent them.
|
|
|
|
const byte mp_unary_op_method_name[MP_UNARY_OP_NUM_RUNTIME] = {
|
2014-03-30 08:35:08 -04:00
|
|
|
[MP_UNARY_OP_BOOL] = MP_QSTR___bool__,
|
|
|
|
[MP_UNARY_OP_LEN] = MP_QSTR___len__,
|
2015-05-11 08:25:19 -04:00
|
|
|
[MP_UNARY_OP_HASH] = MP_QSTR___hash__,
|
2015-03-29 19:29:59 -04:00
|
|
|
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
|
|
|
[MP_UNARY_OP_POSITIVE] = MP_QSTR___pos__,
|
|
|
|
[MP_UNARY_OP_NEGATIVE] = MP_QSTR___neg__,
|
|
|
|
[MP_UNARY_OP_INVERT] = MP_QSTR___invert__,
|
2017-10-21 06:55:02 -04:00
|
|
|
[MP_UNARY_OP_ABS] = MP_QSTR___abs__,
|
2015-03-29 19:29:59 -04:00
|
|
|
#endif
|
2017-08-11 02:42:39 -04:00
|
|
|
#if MICROPY_PY_SYS_GETSIZEOF
|
2017-10-19 05:40:41 -04:00
|
|
|
[MP_UNARY_OP_SIZEOF] = MP_QSTR___sizeof__,
|
2017-08-11 02:42:39 -04:00
|
|
|
#endif
|
2014-01-30 05:05:33 -05:00
|
|
|
};
|
|
|
|
|
2017-08-28 23:04:01 -04:00
|
|
|
STATIC mp_obj_t instance_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2017-08-11 02:42:39 -04:00
|
|
|
|
|
|
|
#if MICROPY_PY_SYS_GETSIZEOF
|
|
|
|
if (MP_UNLIKELY(op == MP_UNARY_OP_SIZEOF)) {
|
|
|
|
// TODO: This doesn't count inherited objects (self->subobj)
|
|
|
|
const mp_obj_type_t *native_base;
|
|
|
|
size_t num_native_bases = instance_count_native_bases(mp_obj_get_type(self_in), &native_base);
|
|
|
|
|
|
|
|
size_t sz = sizeof(*self) + sizeof(*self->subobj) * num_native_bases
|
|
|
|
+ sizeof(*self->members.table) * self->members.alloc;
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(sz);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-01-27 13:02:25 -05:00
|
|
|
qstr op_name = mp_unary_op_method_name[op];
|
2014-04-28 19:42:28 -04:00
|
|
|
/* Still try to lookup native slot
|
2014-01-30 05:05:33 -05:00
|
|
|
if (op_name == 0) {
|
2014-05-21 14:42:43 -04:00
|
|
|
return MP_OBJ_NULL;
|
2014-01-30 05:05:33 -05:00
|
|
|
}
|
2014-04-28 19:42:28 -04:00
|
|
|
*/
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = op_name,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, unary_op),
|
|
|
|
.dest = member,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-29 19:14:30 -04:00
|
|
|
if (member[0] == MP_OBJ_SENTINEL) {
|
2014-04-28 19:42:28 -04:00
|
|
|
return mp_unary_op(op, self->subobj[0]);
|
2014-04-29 19:14:30 -04:00
|
|
|
} else if (member[0] != MP_OBJ_NULL) {
|
2015-05-11 08:25:19 -04:00
|
|
|
mp_obj_t val = mp_call_function_1(member[0], self_in);
|
|
|
|
// __hash__ must return a small int
|
|
|
|
if (op == MP_UNARY_OP_HASH) {
|
2015-05-12 18:05:53 -04:00
|
|
|
val = MP_OBJ_NEW_SMALL_INT(mp_obj_get_int_truncated(val));
|
2015-05-11 08:25:19 -04:00
|
|
|
}
|
|
|
|
return val;
|
2014-01-30 05:05:33 -05:00
|
|
|
} else {
|
2015-05-11 08:25:19 -04:00
|
|
|
if (op == MP_UNARY_OP_HASH) {
|
|
|
|
lookup.attr = MP_QSTR___eq__;
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
|
|
|
if (member[0] == MP_OBJ_NULL) {
|
|
|
|
// https://docs.python.org/3/reference/datamodel.html#object.__hash__
|
|
|
|
// "User-defined classes have __eq__() and __hash__() methods by default;
|
2017-07-18 23:12:10 -04:00
|
|
|
// with them, all objects compare unequal (except with themselves) and
|
2015-05-11 08:25:19 -04:00
|
|
|
// x.__hash__() returns an appropriate value such that x == y implies
|
|
|
|
// both that x is y and hash(x) == hash(y)."
|
|
|
|
return MP_OBJ_NEW_SMALL_INT((mp_uint_t)self_in);
|
|
|
|
}
|
|
|
|
// "A class that overrides __eq__() and does not define __hash__() will have its __hash__() implicitly set to None.
|
|
|
|
// When the __hash__() method of a class is None, instances of the class will raise an appropriate TypeError"
|
|
|
|
}
|
|
|
|
|
2014-05-21 14:42:43 -04:00
|
|
|
return MP_OBJ_NULL; // op not supported
|
2014-01-30 05:05:33 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-04 19:47:22 -04:00
|
|
|
// Binary-op enum values not listed here will have the default value of 0 in the
|
2017-10-21 04:06:32 -04:00
|
|
|
// table, corresponding to MP_QSTR_NULL, and are therefore unsupported (a lookup will
|
2017-10-04 19:47:22 -04:00
|
|
|
// fail). They can be added at the expense of code size for the qstr.
|
2017-10-21 04:06:32 -04:00
|
|
|
// Qstrs for special methods are guaranteed to have a small value, so we use byte
|
|
|
|
// type to represent them.
|
|
|
|
const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
|
2017-10-04 19:47:22 -04:00
|
|
|
[MP_BINARY_OP_LESS] = MP_QSTR___lt__,
|
|
|
|
[MP_BINARY_OP_MORE] = MP_QSTR___gt__,
|
|
|
|
[MP_BINARY_OP_EQUAL] = MP_QSTR___eq__,
|
|
|
|
[MP_BINARY_OP_LESS_EQUAL] = MP_QSTR___le__,
|
|
|
|
[MP_BINARY_OP_MORE_EQUAL] = MP_QSTR___ge__,
|
|
|
|
// MP_BINARY_OP_NOT_EQUAL, // a != b calls a == b and inverts result
|
2017-11-23 21:04:24 -05:00
|
|
|
[MP_BINARY_OP_CONTAINS] = MP_QSTR___contains__,
|
2017-10-04 19:47:22 -04:00
|
|
|
|
2017-10-21 06:55:02 -04:00
|
|
|
// All inplace methods are optional, and normal methods will be used
|
|
|
|
// as a fallback.
|
2017-10-04 19:47:22 -04:00
|
|
|
[MP_BINARY_OP_INPLACE_ADD] = MP_QSTR___iadd__,
|
|
|
|
[MP_BINARY_OP_INPLACE_SUBTRACT] = MP_QSTR___isub__,
|
2017-10-27 15:29:15 -04:00
|
|
|
#if MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS
|
2017-10-21 06:55:02 -04:00
|
|
|
[MP_BINARY_OP_INPLACE_MULTIPLY] = MP_QSTR___imul__,
|
|
|
|
[MP_BINARY_OP_INPLACE_FLOOR_DIVIDE] = MP_QSTR___ifloordiv__,
|
|
|
|
[MP_BINARY_OP_INPLACE_TRUE_DIVIDE] = MP_QSTR___itruediv__,
|
|
|
|
[MP_BINARY_OP_INPLACE_MODULO] = MP_QSTR___imod__,
|
|
|
|
[MP_BINARY_OP_INPLACE_POWER] = MP_QSTR___ipow__,
|
|
|
|
[MP_BINARY_OP_INPLACE_OR] = MP_QSTR___ior__,
|
|
|
|
[MP_BINARY_OP_INPLACE_XOR] = MP_QSTR___ixor__,
|
|
|
|
[MP_BINARY_OP_INPLACE_AND] = MP_QSTR___iand__,
|
|
|
|
[MP_BINARY_OP_INPLACE_LSHIFT] = MP_QSTR___ilshift__,
|
|
|
|
[MP_BINARY_OP_INPLACE_RSHIFT] = MP_QSTR___irshift__,
|
2017-10-04 19:47:22 -04:00
|
|
|
#endif
|
|
|
|
|
2014-03-30 08:35:08 -04:00
|
|
|
[MP_BINARY_OP_ADD] = MP_QSTR___add__,
|
|
|
|
[MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
|
2015-02-21 12:35:09 -05:00
|
|
|
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
|
|
|
[MP_BINARY_OP_MULTIPLY] = MP_QSTR___mul__,
|
|
|
|
[MP_BINARY_OP_FLOOR_DIVIDE] = MP_QSTR___floordiv__,
|
|
|
|
[MP_BINARY_OP_TRUE_DIVIDE] = MP_QSTR___truediv__,
|
2017-10-21 06:55:02 -04:00
|
|
|
[MP_BINARY_OP_MODULO] = MP_QSTR___mod__,
|
|
|
|
[MP_BINARY_OP_DIVMOD] = MP_QSTR___divmod__,
|
|
|
|
[MP_BINARY_OP_POWER] = MP_QSTR___pow__,
|
|
|
|
[MP_BINARY_OP_OR] = MP_QSTR___or__,
|
|
|
|
[MP_BINARY_OP_XOR] = MP_QSTR___xor__,
|
|
|
|
[MP_BINARY_OP_AND] = MP_QSTR___and__,
|
|
|
|
[MP_BINARY_OP_LSHIFT] = MP_QSTR___lshift__,
|
|
|
|
[MP_BINARY_OP_RSHIFT] = MP_QSTR___rshift__,
|
2015-02-21 12:35:09 -05:00
|
|
|
#endif
|
2017-09-10 10:05:20 -04:00
|
|
|
|
|
|
|
#if MICROPY_PY_REVERSE_SPECIAL_METHODS
|
|
|
|
[MP_BINARY_OP_REVERSE_ADD] = MP_QSTR___radd__,
|
|
|
|
[MP_BINARY_OP_REVERSE_SUBTRACT] = MP_QSTR___rsub__,
|
2017-10-21 06:55:02 -04:00
|
|
|
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
2017-09-10 10:05:20 -04:00
|
|
|
[MP_BINARY_OP_REVERSE_MULTIPLY] = MP_QSTR___rmul__,
|
2017-10-21 06:55:02 -04:00
|
|
|
[MP_BINARY_OP_REVERSE_FLOOR_DIVIDE] = MP_QSTR___rfloordiv__,
|
|
|
|
[MP_BINARY_OP_REVERSE_TRUE_DIVIDE] = MP_QSTR___rtruediv__,
|
|
|
|
[MP_BINARY_OP_REVERSE_MODULO] = MP_QSTR___rmod__,
|
|
|
|
[MP_BINARY_OP_REVERSE_POWER] = MP_QSTR___rpow__,
|
|
|
|
[MP_BINARY_OP_REVERSE_OR] = MP_QSTR___ror__,
|
|
|
|
[MP_BINARY_OP_REVERSE_XOR] = MP_QSTR___rxor__,
|
|
|
|
[MP_BINARY_OP_REVERSE_AND] = MP_QSTR___rand__,
|
|
|
|
[MP_BINARY_OP_REVERSE_LSHIFT] = MP_QSTR___rlshift__,
|
|
|
|
[MP_BINARY_OP_REVERSE_RSHIFT] = MP_QSTR___rrshift__,
|
|
|
|
#endif
|
2017-09-10 10:05:20 -04:00
|
|
|
#endif
|
2014-01-18 10:31:13 -05:00
|
|
|
};
|
|
|
|
|
2017-08-28 23:04:01 -04:00
|
|
|
STATIC mp_obj_t instance_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
|
2014-04-02 09:13:26 -04:00
|
|
|
// Note: For ducktyping, CPython does not look in the instance members or use
|
|
|
|
// __getattr__ or __getattribute__. It only looks in the class dictionary.
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *lhs = MP_OBJ_TO_PTR(lhs_in);
|
2017-09-01 19:39:27 -04:00
|
|
|
retry:;
|
2014-12-28 14:41:58 -05:00
|
|
|
qstr op_name = mp_binary_op_method_name[op];
|
2014-04-28 19:42:28 -04:00
|
|
|
/* Still try to lookup native slot
|
2014-01-24 19:17:36 -05:00
|
|
|
if (op_name == 0) {
|
2014-05-21 14:42:43 -04:00
|
|
|
return MP_OBJ_NULL;
|
2014-01-18 10:31:13 -05:00
|
|
|
}
|
2014-04-28 19:42:28 -04:00
|
|
|
*/
|
2014-05-18 13:37:18 -04:00
|
|
|
mp_obj_t dest[3] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = lhs,
|
|
|
|
.attr = op_name,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, binary_op),
|
|
|
|
.dest = dest,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, lhs->base.type);
|
2017-08-29 18:35:48 -04:00
|
|
|
|
|
|
|
mp_obj_t res;
|
2014-05-18 13:37:18 -04:00
|
|
|
if (dest[0] == MP_OBJ_SENTINEL) {
|
2017-08-29 18:35:48 -04:00
|
|
|
res = mp_binary_op(op, lhs->subobj[0], rhs_in);
|
2014-05-18 13:37:18 -04:00
|
|
|
} else if (dest[0] != MP_OBJ_NULL) {
|
2014-04-02 09:13:26 -04:00
|
|
|
dest[2] = rhs_in;
|
2017-08-29 18:35:48 -04:00
|
|
|
res = mp_call_method_n_kw(1, 0, dest);
|
2014-01-18 10:31:13 -05:00
|
|
|
} else {
|
2017-09-01 19:39:27 -04:00
|
|
|
// If this was an inplace method, fallback to normal method
|
|
|
|
// https://docs.python.org/3/reference/datamodel.html#object.__iadd__ :
|
|
|
|
// "If a specific method is not defined, the augmented assignment
|
|
|
|
// falls back to the normal methods."
|
|
|
|
if (op >= MP_BINARY_OP_INPLACE_OR && op <= MP_BINARY_OP_INPLACE_POWER) {
|
|
|
|
op -= MP_BINARY_OP_INPLACE_OR - MP_BINARY_OP_OR;
|
|
|
|
goto retry;
|
|
|
|
}
|
2014-05-21 14:42:43 -04:00
|
|
|
return MP_OBJ_NULL; // op not supported
|
2014-01-18 10:31:13 -05:00
|
|
|
}
|
2017-08-29 18:35:48 -04:00
|
|
|
|
|
|
|
#if MICROPY_PY_BUILTINS_NOTIMPLEMENTED
|
|
|
|
// NotImplemented means "try other fallbacks (like calling __rop__
|
|
|
|
// instead of __op__) and if nothing works, raise TypeError". As
|
|
|
|
// MicroPython doesn't implement any fallbacks, signal to raise
|
|
|
|
// TypeError right away.
|
|
|
|
if (res == mp_const_notimplemented) {
|
|
|
|
return MP_OBJ_NULL; // op not supported
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return res;
|
2014-01-18 10:31:13 -05:00
|
|
|
}
|
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
2015-01-08 12:48:44 -05:00
|
|
|
// logic: look in instance members then class locals
|
2015-05-03 18:23:18 -04:00
|
|
|
assert(mp_obj_is_instance_type(mp_obj_get_type(self_in)));
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-04-13 13:59:45 -04:00
|
|
|
|
2014-01-09 15:57:50 -05:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
|
|
|
|
if (elem != NULL) {
|
|
|
|
// object member, always treated as a value
|
2014-04-13 13:59:45 -04:00
|
|
|
// TODO should we check for properties?
|
2014-01-18 09:10:48 -05:00
|
|
|
dest[0] = elem->value;
|
2014-01-09 15:57:50 -05:00
|
|
|
return;
|
|
|
|
}
|
2014-12-23 08:06:55 -05:00
|
|
|
#if MICROPY_CPYTHON_COMPAT
|
|
|
|
if (attr == MP_QSTR___dict__) {
|
|
|
|
// Create a new dict with a copy of the instance's map items.
|
|
|
|
// This creates, unlike CPython, a 'read-only' __dict__: modifying
|
|
|
|
// it will not result in modifications to the actual instance members.
|
|
|
|
mp_map_t *map = &self->members;
|
|
|
|
mp_obj_t attr_dict = mp_obj_new_dict(map->used);
|
2017-03-24 01:58:13 -04:00
|
|
|
for (size_t i = 0; i < map->alloc; ++i) {
|
2014-12-23 08:06:55 -05:00
|
|
|
if (MP_MAP_SLOT_IS_FILLED(map, i)) {
|
|
|
|
mp_obj_dict_store(attr_dict, map->table[i].key, map->table[i].value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dest[0] = attr_dict;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = attr,
|
|
|
|
.meth_offset = 0,
|
|
|
|
.dest = dest,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t member = dest[0];
|
2014-01-18 12:52:41 -05:00
|
|
|
if (member != MP_OBJ_NULL) {
|
2015-02-14 12:43:54 -05:00
|
|
|
#if MICROPY_PY_BUILTINS_PROPERTY
|
2014-05-18 13:37:18 -04:00
|
|
|
if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
|
2015-02-14 12:43:54 -05:00
|
|
|
// object member is a property; delegate the load to the property
|
|
|
|
// Note: This is an optimisation for code size and execution time.
|
|
|
|
// The proper way to do it is have the functionality just below
|
|
|
|
// in a __get__ method of the property object, and then it would
|
|
|
|
// be called by the descriptor code down below. But that way
|
|
|
|
// requires overhead for the nested mp_call's and overhead for
|
|
|
|
// the code.
|
2014-04-13 13:59:45 -04:00
|
|
|
const mp_obj_t *proxy = mp_obj_property_get(member);
|
|
|
|
if (proxy[0] == mp_const_none) {
|
2016-10-16 21:17:37 -04:00
|
|
|
mp_raise_msg(&mp_type_AttributeError, "unreadable attribute");
|
2014-04-13 13:59:45 -04:00
|
|
|
} else {
|
|
|
|
dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in);
|
|
|
|
}
|
2015-02-14 12:43:54 -05:00
|
|
|
return;
|
2014-04-13 13:59:45 -04:00
|
|
|
}
|
2015-02-14 12:43:54 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if MICROPY_PY_DESCRIPTORS
|
|
|
|
// found a class attribute; if it has a __get__ method then call it with the
|
|
|
|
// class instance and class as arguments and return the result
|
|
|
|
// Note that this is functionally correct but very slow: each load_attr
|
|
|
|
// requires an extra mp_load_method_maybe to check for the __get__.
|
|
|
|
mp_obj_t attr_get_method[4];
|
|
|
|
mp_load_method_maybe(member, MP_QSTR___get__, attr_get_method);
|
|
|
|
if (attr_get_method[0] != MP_OBJ_NULL) {
|
|
|
|
attr_get_method[2] = self_in;
|
2015-11-27 12:01:44 -05:00
|
|
|
attr_get_method[3] = MP_OBJ_FROM_PTR(mp_obj_get_type(self_in));
|
2015-02-14 12:43:54 -05:00
|
|
|
dest[0] = mp_call_method_n_kw(2, 0, attr_get_method);
|
|
|
|
}
|
|
|
|
#endif
|
2014-03-31 17:57:56 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// try __getattr__
|
|
|
|
if (attr != MP_QSTR___getattr__) {
|
2017-01-03 05:00:12 -05:00
|
|
|
#if MICROPY_PY_DELATTR_SETATTR
|
|
|
|
// If the requested attr is __setattr__/__delattr__ then don't delegate the lookup
|
|
|
|
// to __getattr__. If we followed CPython's behaviour then __setattr__/__delattr__
|
|
|
|
// would have already been found in the "object" base class.
|
|
|
|
if (attr == MP_QSTR___setattr__ || attr == MP_QSTR___delattr__) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-03-31 17:57:56 -04:00
|
|
|
mp_obj_t dest2[3];
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR___getattr__, dest2);
|
|
|
|
if (dest2[0] != MP_OBJ_NULL) {
|
|
|
|
// __getattr__ exists, call it and return its result
|
|
|
|
// XXX if this fails to load the requested attr, should we catch the attribute error and return silently?
|
|
|
|
dest2[2] = MP_OBJ_NEW_QSTR(attr);
|
|
|
|
dest[0] = mp_call_method_n_kw(1, 0, dest2);
|
2014-01-09 15:57:50 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-04-13 13:59:45 -04:00
|
|
|
|
2015-02-14 12:43:54 -05:00
|
|
|
#if MICROPY_PY_BUILTINS_PROPERTY || MICROPY_PY_DESCRIPTORS
|
|
|
|
// With property and/or descriptors enabled we need to do a lookup
|
|
|
|
// first in the class dict for the attribute to see if the store should
|
|
|
|
// be delegated.
|
|
|
|
// Note: this makes all stores slow... how to fix?
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = attr,
|
|
|
|
.meth_offset = 0,
|
|
|
|
.dest = member,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2015-02-14 12:43:54 -05:00
|
|
|
|
|
|
|
if (member[0] != MP_OBJ_NULL) {
|
|
|
|
#if MICROPY_PY_BUILTINS_PROPERTY
|
|
|
|
if (MP_OBJ_IS_TYPE(member[0], &mp_type_property)) {
|
2015-04-04 15:15:31 -04:00
|
|
|
// attribute exists and is a property; delegate the store/delete
|
2015-02-14 12:43:54 -05:00
|
|
|
// Note: This is an optimisation for code size and execution time.
|
2015-04-04 15:15:31 -04:00
|
|
|
// The proper way to do it is have the functionality just below in
|
|
|
|
// a __set__/__delete__ method of the property object, and then it
|
|
|
|
// would be called by the descriptor code down below. But that way
|
2015-02-14 12:43:54 -05:00
|
|
|
// requires overhead for the nested mp_call's and overhead for
|
|
|
|
// the code.
|
|
|
|
const mp_obj_t *proxy = mp_obj_property_get(member[0]);
|
2015-04-04 15:15:31 -04:00
|
|
|
mp_obj_t dest[2] = {self_in, value};
|
|
|
|
if (value == MP_OBJ_NULL) {
|
|
|
|
// delete attribute
|
|
|
|
if (proxy[2] == mp_const_none) {
|
|
|
|
// TODO better error message?
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
mp_call_function_n_kw(proxy[2], 1, 0, dest);
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-14 12:43:54 -05:00
|
|
|
} else {
|
2015-04-04 15:15:31 -04:00
|
|
|
// store attribute
|
|
|
|
if (proxy[1] == mp_const_none) {
|
|
|
|
// TODO better error message?
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
mp_call_function_n_kw(proxy[1], 2, 0, dest);
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-14 12:43:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if MICROPY_PY_DESCRIPTORS
|
2015-04-04 15:15:31 -04:00
|
|
|
// found a class attribute; if it has a __set__/__delete__ method then
|
|
|
|
// call it with the class instance (and value) as arguments
|
|
|
|
if (value == MP_OBJ_NULL) {
|
|
|
|
// delete attribute
|
|
|
|
mp_obj_t attr_delete_method[3];
|
|
|
|
mp_load_method_maybe(member[0], MP_QSTR___delete__, attr_delete_method);
|
|
|
|
if (attr_delete_method[0] != MP_OBJ_NULL) {
|
|
|
|
attr_delete_method[2] = self_in;
|
|
|
|
mp_call_method_n_kw(1, 0, attr_delete_method);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// store attribute
|
|
|
|
mp_obj_t attr_set_method[4];
|
|
|
|
mp_load_method_maybe(member[0], MP_QSTR___set__, attr_set_method);
|
|
|
|
if (attr_set_method[0] != MP_OBJ_NULL) {
|
|
|
|
attr_set_method[2] = self_in;
|
|
|
|
attr_set_method[3] = value;
|
|
|
|
mp_call_method_n_kw(2, 0, attr_set_method);
|
|
|
|
return true;
|
|
|
|
}
|
2014-04-13 13:59:45 -04:00
|
|
|
}
|
2015-02-14 12:43:54 -05:00
|
|
|
#endif
|
2014-04-13 13:59:45 -04:00
|
|
|
}
|
2015-02-14 12:43:54 -05:00
|
|
|
#endif
|
2014-04-13 13:59:45 -04:00
|
|
|
|
2014-04-08 16:11:49 -04:00
|
|
|
if (value == MP_OBJ_NULL) {
|
|
|
|
// delete attribute
|
2017-01-03 05:00:12 -05:00
|
|
|
#if MICROPY_PY_DELATTR_SETATTR
|
|
|
|
// try __delattr__ first
|
|
|
|
mp_obj_t attr_delattr_method[3];
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR___delattr__, attr_delattr_method);
|
|
|
|
if (attr_delattr_method[0] != MP_OBJ_NULL) {
|
|
|
|
// __delattr__ exists, so call it
|
|
|
|
attr_delattr_method[2] = MP_OBJ_NEW_QSTR(attr);
|
|
|
|
mp_call_method_n_kw(1, 0, attr_delattr_method);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-04-13 13:59:45 -04:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
|
|
|
|
return elem != NULL;
|
2014-04-08 16:11:49 -04:00
|
|
|
} else {
|
|
|
|
// store attribute
|
2017-01-03 05:00:12 -05:00
|
|
|
#if MICROPY_PY_DELATTR_SETATTR
|
|
|
|
// try __setattr__ first
|
|
|
|
mp_obj_t attr_setattr_method[4];
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR___setattr__, attr_setattr_method);
|
|
|
|
if (attr_setattr_method[0] != MP_OBJ_NULL) {
|
|
|
|
// __setattr__ exists, so call it
|
|
|
|
attr_setattr_method[2] = MP_OBJ_NEW_QSTR(attr);
|
|
|
|
attr_setattr_method[3] = value;
|
|
|
|
mp_call_method_n_kw(2, 0, attr_setattr_method);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-04-08 16:11:49 -04:00
|
|
|
mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
|
|
|
|
return true;
|
|
|
|
}
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
void mp_obj_instance_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
|
|
|
if (dest[0] == MP_OBJ_NULL) {
|
|
|
|
mp_obj_instance_load_attr(self_in, attr, dest);
|
|
|
|
} else {
|
|
|
|
if (mp_obj_instance_store_attr(self_in, attr, dest[1])) {
|
|
|
|
dest[0] = MP_OBJ_NULL; // indicate success
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-03 12:19:35 -04:00
|
|
|
STATIC mp_obj_t instance_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, subscr),
|
|
|
|
.dest = member,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
2017-03-24 01:58:13 -04:00
|
|
|
size_t meth_args;
|
2014-04-08 16:32:29 -04:00
|
|
|
if (value == MP_OBJ_NULL) {
|
|
|
|
// delete item
|
2014-06-08 13:50:12 -04:00
|
|
|
lookup.attr = MP_QSTR___delitem__;
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-14 18:20:52 -04:00
|
|
|
meth_args = 2;
|
2014-04-17 17:10:53 -04:00
|
|
|
} else if (value == MP_OBJ_SENTINEL) {
|
|
|
|
// load item
|
2014-06-08 13:50:12 -04:00
|
|
|
lookup.attr = MP_QSTR___getitem__;
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-17 17:10:53 -04:00
|
|
|
meth_args = 2;
|
2014-04-14 18:20:52 -04:00
|
|
|
} else {
|
2014-04-17 17:10:53 -04:00
|
|
|
// store item
|
2014-06-08 13:50:12 -04:00
|
|
|
lookup.attr = MP_QSTR___setitem__;
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-04-14 18:20:52 -04:00
|
|
|
meth_args = 3;
|
2014-04-08 16:32:29 -04:00
|
|
|
}
|
2014-04-29 19:14:30 -04:00
|
|
|
if (member[0] == MP_OBJ_SENTINEL) {
|
2014-04-28 19:42:28 -04:00
|
|
|
return mp_obj_subscr(self->subobj[0], index, value);
|
2014-04-29 19:14:30 -04:00
|
|
|
} else if (member[0] != MP_OBJ_NULL) {
|
2014-01-18 10:31:13 -05:00
|
|
|
mp_obj_t args[3] = {self_in, index, value};
|
2015-03-21 10:21:54 -04:00
|
|
|
// TODO probably need to call mp_convert_member_lookup, and use mp_call_method_n_kw
|
2014-04-29 19:14:30 -04:00
|
|
|
mp_obj_t ret = mp_call_function_n_kw(member[0], meth_args, 0, args);
|
2014-04-17 17:10:53 -04:00
|
|
|
if (value == MP_OBJ_SENTINEL) {
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
2014-01-18 10:31:13 -05:00
|
|
|
} else {
|
2014-05-21 14:42:43 -04:00
|
|
|
return MP_OBJ_NULL; // op not supported
|
2014-01-18 10:31:13 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 17:33:55 -05:00
|
|
|
STATIC mp_obj_t mp_obj_instance_get_call(mp_obj_t self_in, mp_obj_t *member) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = MP_QSTR___call__,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, call),
|
|
|
|
.dest = member,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2015-02-14 12:41:15 -05:00
|
|
|
return member[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool mp_obj_instance_is_callable(mp_obj_t self_in) {
|
2016-11-21 17:33:55 -05:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL, MP_OBJ_NULL};
|
|
|
|
return mp_obj_instance_get_call(self_in, member) != MP_OBJ_NULL;
|
2014-11-03 11:09:39 -05:00
|
|
|
}
|
|
|
|
|
2016-01-03 04:59:18 -05:00
|
|
|
mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2016-11-21 17:33:55 -05:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL, MP_OBJ_NULL};
|
|
|
|
mp_obj_t call = mp_obj_instance_get_call(self_in, member);
|
2015-02-14 12:41:15 -05:00
|
|
|
if (call == MP_OBJ_NULL) {
|
2014-11-06 12:36:16 -05:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("object not callable");
|
2014-11-06 12:36:16 -05:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"'%s' object is not callable", mp_obj_get_type_str(self_in)));
|
|
|
|
}
|
2014-04-25 14:15:16 -04:00
|
|
|
}
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2015-02-14 12:41:15 -05:00
|
|
|
if (call == MP_OBJ_SENTINEL) {
|
2014-04-28 19:42:28 -04:00
|
|
|
return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args);
|
|
|
|
}
|
2016-11-21 17:33:55 -05:00
|
|
|
|
|
|
|
return mp_call_method_self_n_kw(member[0], member[1], n_args, n_kw, args);
|
2014-04-25 14:15:16 -04:00
|
|
|
}
|
|
|
|
|
2016-01-09 18:14:54 -05:00
|
|
|
STATIC mp_obj_t instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-05-10 14:09:18 -04:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL};
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = MP_QSTR___iter__,
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, getiter),
|
|
|
|
.dest = member,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
2014-05-10 14:09:18 -04:00
|
|
|
if (member[0] == MP_OBJ_NULL) {
|
|
|
|
return MP_OBJ_NULL;
|
2015-02-14 20:10:13 -05:00
|
|
|
} else if (member[0] == MP_OBJ_SENTINEL) {
|
2014-05-10 14:09:18 -04:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
|
2016-01-09 18:14:54 -05:00
|
|
|
return type->getiter(self->subobj[0], iter_buf);
|
2015-02-14 20:10:13 -05:00
|
|
|
} else {
|
|
|
|
return mp_call_method_n_kw(0, 0, member);
|
2014-05-10 14:09:18 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-09 10:08:00 -05:00
|
|
|
STATIC mp_int_t instance_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
|
2015-02-09 10:08:00 -05:00
|
|
|
mp_obj_t member[2] = {MP_OBJ_NULL};
|
|
|
|
struct class_lookup_data lookup = {
|
|
|
|
.obj = self,
|
|
|
|
.attr = MP_QSTR_, // don't actually look for a method
|
|
|
|
.meth_offset = offsetof(mp_obj_type_t, buffer_p.get_buffer),
|
|
|
|
.dest = member,
|
|
|
|
.is_type = false,
|
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self->base.type);
|
|
|
|
if (member[0] == MP_OBJ_SENTINEL) {
|
|
|
|
mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
|
|
|
|
return type->buffer_p.get_buffer(self->subobj[0], bufinfo, flags);
|
|
|
|
} else {
|
|
|
|
return 1; // object does not support buffer protocol
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 15:57:50 -05:00
|
|
|
/******************************************************************************/
|
|
|
|
// type object
|
|
|
|
// - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
|
2014-02-15 11:10:44 -05:00
|
|
|
// - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
|
2014-01-09 15:57:50 -05:00
|
|
|
// - creating a new class (a new type) creates a new mp_obj_type_t
|
2013-12-21 13:17:45 -05:00
|
|
|
|
2015-04-09 18:56:15 -04:00
|
|
|
STATIC void type_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
2015-01-20 07:47:20 -05:00
|
|
|
(void)kind;
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
|
2015-04-11 08:03:37 -04:00
|
|
|
mp_printf(print, "<class '%q'>", self->name);
|
2014-01-04 15:21:15 -05:00
|
|
|
}
|
|
|
|
|
2016-01-03 10:55:55 -05:00
|
|
|
STATIC mp_obj_t type_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-01-20 07:47:20 -05:00
|
|
|
(void)type_in;
|
|
|
|
|
2014-05-11 13:37:21 -04:00
|
|
|
mp_arg_check_num(n_args, n_kw, 1, 3, false);
|
2014-01-18 09:10:48 -05:00
|
|
|
|
2014-01-08 13:48:12 -05:00
|
|
|
switch (n_args) {
|
|
|
|
case 1:
|
2015-11-27 12:01:44 -05:00
|
|
|
return MP_OBJ_FROM_PTR(mp_obj_get_type(args[0]));
|
2014-01-08 13:48:12 -05:00
|
|
|
|
|
|
|
case 3:
|
2014-01-18 09:10:48 -05:00
|
|
|
// args[0] = name
|
2014-01-08 13:48:12 -05:00
|
|
|
// args[1] = bases tuple
|
2014-01-18 09:10:48 -05:00
|
|
|
// args[2] = locals dict
|
2014-02-15 06:34:50 -05:00
|
|
|
return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
|
2014-01-08 13:48:12 -05:00
|
|
|
|
|
|
|
default:
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("type takes 1 or 3 arguments");
|
2014-01-08 13:48:12 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-03 04:59:18 -05:00
|
|
|
STATIC mp_obj_t type_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2014-01-09 15:57:50 -05:00
|
|
|
// instantiate an instance of a class
|
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-01-09 15:57:50 -05:00
|
|
|
|
|
|
|
if (self->make_new == NULL) {
|
2014-11-06 12:36:16 -05:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("cannot create instance");
|
2014-11-06 12:36:16 -05:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
2015-04-11 08:03:37 -04:00
|
|
|
"cannot create '%q' instances", self->name));
|
2014-11-06 12:36:16 -05:00
|
|
|
}
|
2014-01-04 15:21:15 -05:00
|
|
|
}
|
2014-01-09 15:57:50 -05:00
|
|
|
|
|
|
|
// make new instance
|
2016-01-03 10:55:55 -05:00
|
|
|
mp_obj_t o = self->make_new(self, n_args, n_kw, args);
|
2014-01-09 15:57:50 -05:00
|
|
|
|
|
|
|
// return new instance
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
2014-02-15 11:10:44 -05:00
|
|
|
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
if (dest[0] == MP_OBJ_NULL) {
|
|
|
|
// load attribute
|
|
|
|
#if MICROPY_CPYTHON_COMPAT
|
|
|
|
if (attr == MP_QSTR___name__) {
|
|
|
|
dest[0] = MP_OBJ_NEW_QSTR(self->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
struct class_lookup_data lookup = {
|
2015-11-27 12:01:44 -05:00
|
|
|
.obj = (mp_obj_instance_t*)self,
|
2015-04-01 10:10:50 -04:00
|
|
|
.attr = attr,
|
|
|
|
.meth_offset = 0,
|
|
|
|
.dest = dest,
|
|
|
|
.is_type = true,
|
|
|
|
};
|
|
|
|
mp_obj_class_lookup(&lookup, self);
|
|
|
|
} else {
|
|
|
|
// delete/store attribute
|
2014-01-11 14:22:29 -05:00
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
// TODO CPython allows STORE_ATTR to a class, but is this the correct implementation?
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
if (self->locals_dict != NULL) {
|
2015-11-27 12:01:44 -05:00
|
|
|
assert(self->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
|
|
|
|
mp_map_t *locals_map = &self->locals_dict->map;
|
2015-04-01 10:10:50 -04:00
|
|
|
if (dest[1] == MP_OBJ_NULL) {
|
|
|
|
// delete attribute
|
|
|
|
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
|
|
|
|
// note that locals_map may be in ROM, so remove will fail in that case
|
|
|
|
if (elem != NULL) {
|
|
|
|
dest[0] = MP_OBJ_NULL; // indicate success
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// store attribute
|
|
|
|
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
|
|
|
|
// note that locals_map may be in ROM, so add will fail in that case
|
|
|
|
if (elem != NULL) {
|
|
|
|
elem->value = dest[1];
|
|
|
|
dest[0] = MP_OBJ_NULL; // indicate success
|
|
|
|
}
|
2014-04-08 16:11:49 -04:00
|
|
|
}
|
2014-03-27 05:32:26 -04:00
|
|
|
}
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
2013-12-21 13:17:45 -05:00
|
|
|
}
|
|
|
|
|
2014-02-15 11:10:44 -05:00
|
|
|
const mp_obj_type_t mp_type_type = {
|
|
|
|
{ &mp_type_type },
|
2014-02-15 06:34:50 -05:00
|
|
|
.name = MP_QSTR_type,
|
2014-01-05 15:34:09 -05:00
|
|
|
.print = type_print,
|
2014-01-08 13:48:12 -05:00
|
|
|
.make_new = type_make_new,
|
2014-01-18 09:10:48 -05:00
|
|
|
.call = type_call,
|
2015-05-11 08:25:19 -04:00
|
|
|
.unary_op = mp_generic_unary_op,
|
2015-04-01 10:10:50 -04:00
|
|
|
.attr = type_attr,
|
2013-12-21 13:17:45 -05:00
|
|
|
};
|
2014-01-09 15:57:50 -05:00
|
|
|
|
2014-02-15 06:34:50 -05:00
|
|
|
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
|
2017-06-30 03:22:17 -04:00
|
|
|
assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // MicroPython restriction, for now
|
|
|
|
assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // MicroPython restriction, for now
|
2014-04-28 19:42:28 -04:00
|
|
|
|
2014-07-05 00:55:00 -04:00
|
|
|
// TODO might need to make a copy of locals_dict; at least that's how CPython does it
|
|
|
|
|
2014-04-28 19:42:28 -04:00
|
|
|
// Basic validation of base classes
|
2017-11-10 17:11:24 -05:00
|
|
|
size_t bases_len;
|
|
|
|
mp_obj_t *bases_items;
|
|
|
|
mp_obj_tuple_get(bases_tuple, &bases_len, &bases_items);
|
|
|
|
for (size_t i = 0; i < bases_len; i++) {
|
|
|
|
assert(MP_OBJ_IS_TYPE(bases_items[i], &mp_type_type));
|
|
|
|
mp_obj_type_t *t = MP_OBJ_TO_PTR(bases_items[i]);
|
2014-04-28 19:42:28 -04:00
|
|
|
// TODO: Verify with CPy, tested on function type
|
|
|
|
if (t->make_new == NULL) {
|
2014-11-06 12:36:16 -05:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("type is not an acceptable base type");
|
2014-11-06 12:36:16 -05:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
2015-04-11 08:03:37 -04:00
|
|
|
"type '%q' is not an acceptable base type", t->name));
|
2014-11-06 12:36:16 -05:00
|
|
|
}
|
2014-04-28 19:42:28 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-09 15:57:50 -05:00
|
|
|
mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
|
2014-02-15 11:10:44 -05:00
|
|
|
o->base.type = &mp_type_type;
|
2014-01-22 09:35:10 -05:00
|
|
|
o->name = name;
|
2014-05-03 12:19:35 -04:00
|
|
|
o->print = instance_print;
|
2015-05-03 18:23:18 -04:00
|
|
|
o->make_new = mp_obj_instance_make_new;
|
2015-02-09 10:08:00 -05:00
|
|
|
o->call = mp_obj_instance_call;
|
2014-05-03 12:19:35 -04:00
|
|
|
o->unary_op = instance_unary_op;
|
|
|
|
o->binary_op = instance_binary_op;
|
2015-04-01 10:10:50 -04:00
|
|
|
o->attr = mp_obj_instance_attr;
|
2014-05-03 12:19:35 -04:00
|
|
|
o->subscr = instance_subscr;
|
2014-05-10 14:09:18 -04:00
|
|
|
o->getiter = instance_getiter;
|
2015-02-09 10:08:00 -05:00
|
|
|
//o->iternext = ; not implemented
|
|
|
|
o->buffer_p.get_buffer = instance_get_buffer;
|
2017-04-05 22:09:01 -04:00
|
|
|
|
2017-11-10 17:11:24 -05:00
|
|
|
if (bases_len > 0) {
|
2017-04-05 22:09:01 -04:00
|
|
|
// Inherit protocol from a base class. This allows to define an
|
|
|
|
// abstract base class which would translate C-level protocol to
|
|
|
|
// Python method calls, and any subclass inheriting from it will
|
|
|
|
// support this feature.
|
2017-11-10 17:11:24 -05:00
|
|
|
o->protocol = ((mp_obj_type_t*)MP_OBJ_TO_PTR(bases_items[0]))->protocol;
|
2017-04-05 22:09:01 -04:00
|
|
|
|
2017-11-10 17:11:24 -05:00
|
|
|
if (bases_len >= 2) {
|
2017-04-01 08:52:24 -04:00
|
|
|
#if MICROPY_MULTIPLE_INHERITANCE
|
2017-04-05 22:09:01 -04:00
|
|
|
o->parent = MP_OBJ_TO_PTR(bases_tuple);
|
2017-04-01 08:52:24 -04:00
|
|
|
#else
|
|
|
|
mp_raise_NotImplementedError("multiple inheritance not supported");
|
|
|
|
#endif
|
2017-04-05 22:09:01 -04:00
|
|
|
} else {
|
2017-11-10 17:11:24 -05:00
|
|
|
o->parent = MP_OBJ_TO_PTR(bases_items[0]);
|
2017-04-05 22:09:01 -04:00
|
|
|
}
|
2016-06-18 17:56:06 -04:00
|
|
|
}
|
2017-04-05 22:09:01 -04:00
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
o->locals_dict = MP_OBJ_TO_PTR(locals_dict);
|
2014-04-28 19:42:28 -04:00
|
|
|
|
|
|
|
const mp_obj_type_t *native_base;
|
2017-03-24 01:58:13 -04:00
|
|
|
size_t num_native_bases = instance_count_native_bases(o, &native_base);
|
2014-04-28 19:42:28 -04:00
|
|
|
if (num_native_bases > 1) {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("multiple bases have instance lay-out conflict");
|
2014-04-28 19:42:28 -04:00
|
|
|
}
|
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_map_t *locals_map = &o->locals_dict->map;
|
2014-07-05 00:55:00 -04:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(MP_QSTR___new__), MP_MAP_LOOKUP);
|
|
|
|
if (elem != NULL) {
|
|
|
|
// __new__ slot exists; check if it is a function
|
2014-08-24 11:28:17 -04:00
|
|
|
if (MP_OBJ_IS_FUN(elem->value)) {
|
2014-07-05 00:55:00 -04:00
|
|
|
// __new__ is a function, wrap it in a staticmethod decorator
|
2016-01-03 10:55:55 -05:00
|
|
|
elem->value = static_class_method_make_new(&mp_type_staticmethod, 1, 0, &elem->value);
|
2014-07-05 00:55:00 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2014-01-09 15:57:50 -05:00
|
|
|
}
|
2014-01-09 16:43:51 -05:00
|
|
|
|
|
|
|
/******************************************************************************/
|
2014-02-04 19:51:47 -05:00
|
|
|
// super object
|
|
|
|
|
|
|
|
typedef struct _mp_obj_super_t {
|
|
|
|
mp_obj_base_t base;
|
|
|
|
mp_obj_t type;
|
|
|
|
mp_obj_t obj;
|
|
|
|
} mp_obj_super_t;
|
|
|
|
|
2015-04-09 18:56:15 -04:00
|
|
|
STATIC void super_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
2015-01-20 07:47:20 -05:00
|
|
|
(void)kind;
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_super_t *self = MP_OBJ_TO_PTR(self_in);
|
2015-04-09 18:56:15 -04:00
|
|
|
mp_print_str(print, "<super: ");
|
|
|
|
mp_obj_print_helper(print, self->type, PRINT_STR);
|
|
|
|
mp_print_str(print, ", ");
|
|
|
|
mp_obj_print_helper(print, self->obj, PRINT_STR);
|
|
|
|
mp_print_str(print, ">");
|
2014-02-04 19:51:47 -05:00
|
|
|
}
|
|
|
|
|
2016-01-03 10:55:55 -05:00
|
|
|
STATIC mp_obj_t super_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-01-20 07:47:20 -05:00
|
|
|
(void)type_in;
|
2015-01-20 09:11:27 -05:00
|
|
|
// 0 arguments are turned into 2 in the compiler
|
|
|
|
// 1 argument is not yet implemented
|
|
|
|
mp_arg_check_num(n_args, n_kw, 2, 2, false);
|
2017-04-21 22:14:04 -04:00
|
|
|
mp_obj_super_t *o = m_new_obj(mp_obj_super_t);
|
|
|
|
*o = (mp_obj_super_t){{type_in}, args[0], args[1]};
|
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2014-02-04 19:51:47 -05:00
|
|
|
}
|
|
|
|
|
2015-04-01 10:10:50 -04:00
|
|
|
STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// not load attribute
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-03-29 09:43:38 -04:00
|
|
|
assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_super_t *self = MP_OBJ_TO_PTR(self_in);
|
2014-02-04 19:51:47 -05:00
|
|
|
|
2014-02-15 11:10:44 -05:00
|
|
|
assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
|
2014-02-04 19:51:47 -05:00
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_type_t *type = MP_OBJ_TO_PTR(self->type);
|
2014-02-04 19:51:47 -05:00
|
|
|
|
2014-06-08 13:50:12 -04:00
|
|
|
struct class_lookup_data lookup = {
|
2015-11-27 12:01:44 -05:00
|
|
|
.obj = MP_OBJ_TO_PTR(self->obj),
|
2014-06-08 13:50:12 -04:00
|
|
|
.attr = attr,
|
|
|
|
.meth_offset = 0,
|
|
|
|
.dest = dest,
|
2014-11-03 11:18:51 -05:00
|
|
|
.is_type = false,
|
2014-06-08 13:50:12 -04:00
|
|
|
};
|
2017-04-05 22:09:01 -04:00
|
|
|
|
|
|
|
if (type->parent == NULL) {
|
|
|
|
// no parents, do nothing
|
2017-04-01 08:52:24 -04:00
|
|
|
#if MICROPY_MULTIPLE_INHERITANCE
|
2017-04-05 22:09:01 -04:00
|
|
|
} else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
|
|
|
|
const mp_obj_tuple_t *parent_tuple = type->parent;
|
|
|
|
size_t len = parent_tuple->len;
|
|
|
|
const mp_obj_t *items = parent_tuple->items;
|
|
|
|
for (size_t i = 0; i < len; i++) {
|
|
|
|
assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
|
|
|
|
mp_obj_class_lookup(&lookup, (mp_obj_type_t*)MP_OBJ_TO_PTR(items[i]));
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2017-04-01 08:52:24 -04:00
|
|
|
#endif
|
2017-04-05 22:09:01 -04:00
|
|
|
} else {
|
|
|
|
mp_obj_class_lookup(&lookup, type->parent);
|
2014-05-20 17:54:46 -04:00
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2014-02-04 19:51:47 -05:00
|
|
|
}
|
2017-04-05 22:09:01 -04:00
|
|
|
|
2014-06-08 13:50:12 -04:00
|
|
|
mp_obj_class_lookup(&lookup, &mp_type_object);
|
2014-02-04 19:51:47 -05:00
|
|
|
}
|
|
|
|
|
2014-03-29 09:43:38 -04:00
|
|
|
const mp_obj_type_t mp_type_super = {
|
2014-02-15 11:10:44 -05:00
|
|
|
{ &mp_type_type },
|
2014-02-15 06:34:50 -05:00
|
|
|
.name = MP_QSTR_super,
|
2014-02-04 19:51:47 -05:00
|
|
|
.print = super_print,
|
|
|
|
.make_new = super_make_new,
|
2015-04-01 10:10:50 -04:00
|
|
|
.attr = super_attr,
|
2014-02-04 19:51:47 -05:00
|
|
|
};
|
|
|
|
|
2017-04-18 19:45:59 -04:00
|
|
|
void mp_load_super_method(qstr attr, mp_obj_t *dest) {
|
|
|
|
mp_obj_super_t super = {{&mp_type_super}, dest[1], dest[2]};
|
|
|
|
mp_load_method(MP_OBJ_FROM_PTR(&super), attr, dest);
|
|
|
|
}
|
|
|
|
|
2014-02-04 19:51:47 -05:00
|
|
|
/******************************************************************************/
|
2014-02-15 11:10:44 -05:00
|
|
|
// subclassing and built-ins specific to types
|
2014-01-09 16:43:51 -05:00
|
|
|
|
2014-03-03 17:38:13 -05:00
|
|
|
// object and classinfo should be type objects
|
|
|
|
// (but the function will fail gracefully if they are not)
|
2014-03-26 14:37:06 -04:00
|
|
|
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
|
2014-01-09 16:43:51 -05:00
|
|
|
for (;;) {
|
|
|
|
if (object == classinfo) {
|
2014-02-15 11:10:44 -05:00
|
|
|
return true;
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// not equivalent classes, keep searching base classes
|
|
|
|
|
2014-03-03 17:38:13 -05:00
|
|
|
// object should always be a type object, but just return false if it's not
|
|
|
|
if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-11-27 12:01:44 -05:00
|
|
|
const mp_obj_type_t *self = MP_OBJ_TO_PTR(object);
|
2014-01-09 16:43:51 -05:00
|
|
|
|
2017-04-05 22:09:01 -04:00
|
|
|
if (self->parent == NULL) {
|
|
|
|
// type has no parents
|
2014-02-15 11:10:44 -05:00
|
|
|
return false;
|
2017-04-01 08:52:24 -04:00
|
|
|
#if MICROPY_MULTIPLE_INHERITANCE
|
2017-04-05 22:09:01 -04:00
|
|
|
} else if (((mp_obj_base_t*)self->parent)->type == &mp_type_tuple) {
|
|
|
|
// get the base objects (they should be type objects)
|
|
|
|
const mp_obj_tuple_t *parent_tuple = self->parent;
|
|
|
|
const mp_obj_t *item = parent_tuple->items;
|
|
|
|
const mp_obj_t *top = item + parent_tuple->len - 1;
|
|
|
|
|
|
|
|
// iterate through the base objects
|
|
|
|
for (; item < top; ++item) {
|
|
|
|
if (mp_obj_is_subclass_fast(*item, classinfo)) {
|
|
|
|
return true;
|
|
|
|
}
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
|
2017-04-05 22:09:01 -04:00
|
|
|
// search last base (simple tail recursion elimination)
|
|
|
|
object = *item;
|
2017-04-01 08:52:24 -04:00
|
|
|
#endif
|
2017-04-05 22:09:01 -04:00
|
|
|
} else {
|
|
|
|
// type has 1 parent
|
|
|
|
object = MP_OBJ_FROM_PTR(self->parent);
|
|
|
|
}
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-03 17:38:13 -05:00
|
|
|
STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) {
|
2017-03-25 04:35:08 -04:00
|
|
|
size_t len;
|
2014-03-03 17:38:13 -05:00
|
|
|
mp_obj_t *items;
|
|
|
|
if (MP_OBJ_IS_TYPE(classinfo, &mp_type_type)) {
|
|
|
|
len = 1;
|
|
|
|
items = &classinfo;
|
2014-03-29 09:15:08 -04:00
|
|
|
} else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
|
2014-03-03 17:38:13 -05:00
|
|
|
mp_obj_tuple_get(classinfo, &len, &items);
|
|
|
|
} else {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("issubclass() arg 2 must be a class or a tuple of classes");
|
2014-02-27 15:48:25 -05:00
|
|
|
}
|
|
|
|
|
2017-03-24 01:58:13 -04:00
|
|
|
for (size_t i = 0; i < len; i++) {
|
2014-04-05 17:45:23 -04:00
|
|
|
// We explicitly check for 'object' here since no-one explicitly derives from it
|
2015-11-27 12:01:44 -05:00
|
|
|
if (items[i] == MP_OBJ_FROM_PTR(&mp_type_object) || mp_obj_is_subclass_fast(object, items[i])) {
|
2014-03-03 17:38:13 -05:00
|
|
|
return mp_const_true;
|
|
|
|
}
|
2014-02-27 15:48:25 -05:00
|
|
|
}
|
2014-03-03 17:38:13 -05:00
|
|
|
return mp_const_false;
|
2014-02-27 15:48:25 -05:00
|
|
|
}
|
|
|
|
|
2014-02-15 11:10:44 -05:00
|
|
|
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
|
2014-03-03 17:38:13 -05:00
|
|
|
if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
|
2017-03-28 07:37:26 -04:00
|
|
|
mp_raise_TypeError("issubclass() arg 1 must be a class");
|
2014-03-03 17:38:13 -05:00
|
|
|
}
|
|
|
|
return mp_obj_is_subclass(object, classinfo);
|
2014-02-15 11:10:44 -05:00
|
|
|
}
|
|
|
|
|
2014-01-09 16:43:51 -05:00
|
|
|
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);
|
|
|
|
|
2014-02-12 11:15:40 -05:00
|
|
|
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
|
2015-11-27 12:01:44 -05:00
|
|
|
return mp_obj_is_subclass(MP_OBJ_FROM_PTR(mp_obj_get_type(object)), classinfo);
|
2014-01-09 16:43:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
|
2014-01-11 14:22:29 -05:00
|
|
|
|
2014-05-10 20:16:04 -04:00
|
|
|
mp_obj_t mp_instance_cast_to_native_base(mp_const_obj_t self_in, mp_const_obj_t native_type) {
|
|
|
|
mp_obj_type_t *self_type = mp_obj_get_type(self_in);
|
2015-11-27 12:01:44 -05:00
|
|
|
if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(self_type), native_type)) {
|
2014-05-10 20:16:04 -04:00
|
|
|
return MP_OBJ_NULL;
|
|
|
|
}
|
2015-11-27 12:01:44 -05:00
|
|
|
mp_obj_instance_t *self = (mp_obj_instance_t*)MP_OBJ_TO_PTR(self_in);
|
2014-05-10 20:16:04 -04:00
|
|
|
return self->subobj[0];
|
|
|
|
}
|
|
|
|
|
2014-01-11 14:22:29 -05:00
|
|
|
/******************************************************************************/
|
|
|
|
// staticmethod and classmethod types (probably should go in a different file)
|
|
|
|
|
2016-01-03 10:55:55 -05:00
|
|
|
STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-11-27 12:01:44 -05:00
|
|
|
assert(self == &mp_type_staticmethod || self == &mp_type_classmethod);
|
2014-02-06 15:31:44 -05:00
|
|
|
|
2014-11-06 12:36:16 -05:00
|
|
|
mp_arg_check_num(n_args, n_kw, 1, 1, false);
|
2014-02-06 15:31:44 -05:00
|
|
|
|
|
|
|
mp_obj_static_class_method_t *o = m_new_obj(mp_obj_static_class_method_t);
|
2015-11-27 12:01:44 -05:00
|
|
|
*o = (mp_obj_static_class_method_t){{self}, args[0]};
|
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2014-02-06 15:31:44 -05:00
|
|
|
}
|
|
|
|
|
2014-01-11 14:22:29 -05:00
|
|
|
const mp_obj_type_t mp_type_staticmethod = {
|
2014-02-15 11:10:44 -05:00
|
|
|
{ &mp_type_type },
|
2014-02-15 06:34:50 -05:00
|
|
|
.name = MP_QSTR_staticmethod,
|
2015-04-04 10:53:11 -04:00
|
|
|
.make_new = static_class_method_make_new,
|
2014-01-11 14:22:29 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
const mp_obj_type_t mp_type_classmethod = {
|
2014-02-15 11:10:44 -05:00
|
|
|
{ &mp_type_type },
|
2014-02-15 06:34:50 -05:00
|
|
|
.name = MP_QSTR_classmethod,
|
2015-04-04 10:53:11 -04:00
|
|
|
.make_new = static_class_method_make_new,
|
2014-01-11 14:22:29 -05:00
|
|
|
};
|