objtype.c 35.4 KB
Newer Older
1
2
3
4
5
6
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
7
 * Copyright (c) 2014 Paul Sokolovsky
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 *
 * 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.
 */

28
29
#include <stdio.h>
#include <stddef.h>
30
31
#include <string.h>
#include <assert.h>
32

33
#include "mpconfig.h"
34
35
#include "nlr.h"
#include "misc.h"
36
#include "qstr.h"
37
#include "obj.h"
38
#include "runtime0.h"
39
#include "runtime.h"
40
#include "objtype.h"
41

42
43
44
45
46
47
48
#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

49
50
STATIC mp_obj_t static_class_method_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args);

51
/******************************************************************************/
52
// instance object
53

54
#define is_instance_type(type) ((type)->make_new == instance_make_new)
55
#define is_native_type(type) ((type)->make_new != instance_make_new)
56
mp_obj_t instance_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args);
57
STATIC void instance_convert_return_attr(mp_obj_t self, const mp_obj_type_t *type, mp_obj_t member, mp_obj_t *dest);
58

59
STATIC mp_obj_t mp_obj_new_instance(mp_obj_t class, uint subobjs) {
60
    mp_obj_instance_t *o = m_new_obj_var(mp_obj_instance_t, mp_obj_t, subobjs);
61
62
    o->base.type = class;
    mp_map_init(&o->members, 0);
63
    mp_seq_clear(o->subobj, 0, subobjs, sizeof(*o->subobj));
64
65
66
    return o;
}

67
STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_type_t **last_native_base) {
68
69
70
71
72
73
74
    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));
75
76
77
78
79
80
        const mp_obj_type_t *bt = (const mp_obj_type_t *)items[i];
        if (bt == &mp_type_object) {
            // Not a "real" type
            continue;
        }
        if (is_native_type(bt)) {
81
82
83
            *last_native_base = items[i];
            count++;
        } else {
84
            count += instance_count_native_bases(items[i], last_native_base);
85
86
87
88
89
90
91
92
93
94
95
        }
    }

    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/
//
96
// will return MP_OBJ_NULL if not found
97
98
99
100
101
// 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
102
// instance->subobj[0]. This case is handled via instance_count_native_bases() though.
103
104
105
struct class_lookup_data {
    mp_obj_instance_t *obj;
    qstr attr;
106
    mp_uint_t meth_offset;
107
    mp_obj_t *dest;
108
    bool is_type;
109
110
111
112
113
};

STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_type_t *type) {
    assert(lookup->dest[0] == NULL);
    assert(lookup->dest[1] == NULL);
114
    for (;;) {
115
116
117
118
        // 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.
119
120
121
122
        if (lookup->meth_offset != 0 && is_native_type(type)) {
            if (*(void**)((char*)type + lookup->meth_offset) != NULL) {
                DEBUG_printf("mp_obj_class_lookup: matched special meth slot for %s\n", qstr_str(lookup->attr));
                lookup->dest[0] = MP_OBJ_SENTINEL;
123
                return;
124
125
126
            }
        }

127
        if (type->locals_dict != NULL) {
128
            // search locals_dict (the set of methods/attributes)
129
            assert(MP_OBJ_IS_TYPE(type->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
130
            mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict);
131
            mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(lookup->attr), MP_MAP_LOOKUP);
132
            if (elem != NULL) {
133
                lookup->dest[0] = elem->value;
134
135
136
137
138
139
                if (lookup->is_type) {
                    // If we look up class method, we need to pass original type there,
                    // not type where we found a class method.
                    const mp_obj_type_t *org_type = (const mp_obj_type_t*)lookup->obj;
                    instance_convert_return_attr(NULL, org_type, elem->value, lookup->dest);
                } else if (lookup->obj != MP_OBJ_NULL && !lookup->is_type && is_native_type(type)) {
140
                    instance_convert_return_attr(lookup->obj->subobj[0], type, elem->value, lookup->dest);
141
                } else {
142
                    instance_convert_return_attr(lookup->obj, type, elem->value, lookup->dest);
143
                }
144
145
146
147
148
#if DEBUG_PRINT
                printf("mp_obj_class_lookup: Returning: ");
                mp_obj_print(lookup->dest[0], PRINT_REPR); printf(" ");
                mp_obj_print(lookup->dest[1], PRINT_REPR); printf("\n");
#endif
149
                return;
150
            }
151
152
        }

153
        // Try this for completeness, but all native methods should be statically defined
154
        // in locals_dict, and would be handled by above.
155
        if (lookup->obj != MP_OBJ_NULL && !lookup->is_type && is_native_type(type)) {
156
157
            mp_load_method_maybe(lookup->obj->subobj[0], lookup->attr, lookup->dest);
            if (lookup->dest[0] != MP_OBJ_NULL) {
158
                return;
159
160
161
            }
        }

162
163
164
        // attribute not found, keep searching base classes

        // for a const struct, this entry might be NULL
165
        if (type->bases_tuple == MP_OBJ_NULL) {
166
            return;
167
168
169
170
        }

        uint len;
        mp_obj_t *items;
171
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
172
        if (len == 0) {
173
            return;
174
175
        }
        for (uint i = 0; i < len - 1; i++) {
176
            assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
177
178
179
180
181
            mp_obj_type_t *bt = (mp_obj_type_t*)items[i];
            if (bt == &mp_type_object) {
                // Not a "real" type
                continue;
            }
182
183
            mp_obj_class_lookup(lookup, bt);
            if (lookup->dest[0] != MP_OBJ_NULL) {
184
                return;
185
186
187
188
            }
        }

        // search last base (simple tail recursion elimination)
189
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_type_type));
190
        type = (mp_obj_type_t*)items[len - 1];
191
192
193
194
        if (type == &mp_type_object) {
            // Not a "real" type
            return;
        }
195
196
197
    }
}

198
STATIC void instance_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
199
    mp_obj_instance_t *self = self_in;
200
    qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
201
    mp_obj_t member[2] = {MP_OBJ_NULL};
202
203
204
205
206
207
208
    struct class_lookup_data lookup = {
        .obj = self,
        .attr = meth,
        .meth_offset = offsetof(mp_obj_type_t, print),
        .dest = member,
    };
    mp_obj_class_lookup(&lookup, self->base.type);
209
    if (member[0] == MP_OBJ_NULL && kind == PRINT_STR) {
210
        // If there's no __str__, fall back to __repr__
211
212
213
        lookup.attr = MP_QSTR___repr__;
        lookup.meth_offset = 0;
        mp_obj_class_lookup(&lookup, self->base.type);
214
215
    }

216
    if (member[0] == MP_OBJ_SENTINEL) {
217
218
219
220
221
222
223
224
225
        // Handle Exception subclasses specially
        if (mp_obj_is_native_exception_instance(self->subobj[0])) {
            if (kind != PRINT_STR) {
                print(env, "%s", qstr_str(self->base.type->name));
            }
            mp_obj_print_helper(print, env, self->subobj[0], kind | PRINT_EXC_SUBCLASS);
        } else {
            mp_obj_print_helper(print, env, self->subobj[0], kind);
        }
226
        return;
227
228
    }

229
230
    if (member[0] != MP_OBJ_NULL) {
        mp_obj_t r = mp_call_function_1(member[0], self_in);
231
232
233
234
235
        mp_obj_print_helper(print, env, r, PRINT_STR);
        return;
    }

    // TODO: CPython prints fully-qualified type name
236
237
238
    print(env, "<%s object at %p>", mp_obj_get_type_str(self_in), self_in);
}

239
mp_obj_t instance_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
240
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
241
    mp_obj_type_t *self = self_in;
242

243
    const mp_obj_type_t *native_base;
244
    uint num_native_bases = instance_count_native_bases(self, &native_base);
245
    assert(num_native_bases < 2);
246

247
    mp_obj_instance_t *o = mp_obj_new_instance(self_in, num_native_bases);
248

249
250
251
252
253
254
255
256
    // This executes only "__new__" part of obejection creation.
    // TODO: This won't work will for classes with native bases.
    // TODO: This is hack, should be resolved along the lines of
    // https://github.com/micropython/micropython/issues/606#issuecomment-43685883
    if (n_args == 1 && *args == MP_OBJ_SENTINEL) {
        return o;
    }

257
    // look for __new__ function
258
    mp_obj_t init_fn[2] = {MP_OBJ_NULL};
259
260
261
262
263
264
265
    struct class_lookup_data lookup = {
        .obj = NULL,
        .attr = MP_QSTR___new__,
        .meth_offset = offsetof(mp_obj_type_t, make_new),
        .dest = init_fn,
    };
    mp_obj_class_lookup(&lookup, self);
266

267
    mp_obj_t new_ret = o;
268
    if (init_fn[0] == MP_OBJ_SENTINEL) {
269
270
271
        // 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);
272
    } else if (init_fn[0] != MP_OBJ_NULL) {
273
        // now call Python class __new__ function with all args
274
        if (n_args == 0 && n_kw == 0) {
275
            new_ret = mp_call_function_n_kw(init_fn[0], 1, 0, (mp_obj_t*)(void*)&self_in);
276
        } else {
277
            mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
278
            args2[0] = self_in;
279
            memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
280
            new_ret = mp_call_function_n_kw(init_fn[0], n_args + 1, n_kw, args2);
281
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
282
        }
283
284
285
286
287
288
289
290
291
292
293
294
295

    }

    // https://docs.python.org/3.4/reference/datamodel.html#object.__new__
    // "If __new__() does not return an instance of cls, then the new instance’s __init__() method will not be invoked."
    if (mp_obj_get_type(new_ret) != self_in) {
        return new_ret;
    }

    o = new_ret;

    // now call Python class __init__ function with all args
    init_fn[0] = init_fn[1] = NULL;
296
297
298
299
    lookup.obj = o;
    lookup.attr = MP_QSTR___init__;
    lookup.meth_offset = 0;
    mp_obj_class_lookup(&lookup, self);
300
301
302
303
304
305
306
307
308
309
310
311
    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);
        }
312
        if (init_ret != mp_const_none) {
313
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
314
315
316
317
318
319
320
        }

    }

    return o;
}

321
STATIC const qstr unary_op_method_name[] = {
Damien George's avatar
Damien George committed
322
323
324
325
326
327
    [MP_UNARY_OP_BOOL] = MP_QSTR___bool__,
    [MP_UNARY_OP_LEN] = MP_QSTR___len__,
    //[MP_UNARY_OP_POSITIVE,
    //[MP_UNARY_OP_NEGATIVE,
    //[MP_UNARY_OP_INVERT,
    [MP_UNARY_OP_NOT] = MP_QSTR_, // don't need to implement this, used to make sure array has full size
328
329
};

330
STATIC mp_obj_t instance_unary_op(int op, mp_obj_t self_in) {
331
    mp_obj_instance_t *self = self_in;
332
    qstr op_name = unary_op_method_name[op];
333
    /* Still try to lookup native slot
334
    if (op_name == 0) {
335
        return MP_OBJ_NULL;
336
    }
337
    */
338
    mp_obj_t member[2] = {MP_OBJ_NULL};
339
340
341
342
343
344
345
    struct class_lookup_data lookup = {
        .obj = self,
        .attr = op_name,
        .meth_offset = offsetof(mp_obj_type_t, unary_op),
        .dest = member,
    };
    mp_obj_class_lookup(&lookup, self->base.type);
346
    if (member[0] == MP_OBJ_SENTINEL) {
347
        return mp_unary_op(op, self->subobj[0]);
348
349
    } else if (member[0] != MP_OBJ_NULL) {
        return mp_call_function_1(member[0], self_in);
350
    } else {
351
        return MP_OBJ_NULL; // op not supported
352
353
354
    }
}

355
STATIC const qstr binary_op_method_name[] = {
356
    /*
Damien George's avatar
Damien George committed
357
358
359
360
361
    MP_BINARY_OP_OR,
    MP_BINARY_OP_XOR,
    MP_BINARY_OP_AND,
    MP_BINARY_OP_LSHIFT,
    MP_BINARY_OP_RSHIFT,
362
    */
Damien George's avatar
Damien George committed
363
364
    [MP_BINARY_OP_ADD] = MP_QSTR___add__,
    [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
365
    /*
Damien George's avatar
Damien George committed
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
    MP_BINARY_OP_MULTIPLY,
    MP_BINARY_OP_FLOOR_DIVIDE,
    MP_BINARY_OP_TRUE_DIVIDE,
    MP_BINARY_OP_MODULO,
    MP_BINARY_OP_POWER,
    MP_BINARY_OP_INPLACE_OR,
    MP_BINARY_OP_INPLACE_XOR,
    MP_BINARY_OP_INPLACE_AND,
    MP_BINARY_OP_INPLACE_LSHIFT,
    MP_BINARY_OP_INPLACE_RSHIFT,
    MP_BINARY_OP_INPLACE_ADD,
    MP_BINARY_OP_INPLACE_SUBTRACT,
    MP_BINARY_OP_INPLACE_MULTIPLY,
    MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
    MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
    MP_BINARY_OP_INPLACE_MODULO,
382
383
384
    MP_BINARY_OP_INPLACE_POWER,*/
    [MP_BINARY_OP_LESS] = MP_QSTR___lt__,
    /*MP_BINARY_OP_MORE,
Damien George's avatar
Damien George committed
385
386
387
388
    MP_BINARY_OP_EQUAL,
    MP_BINARY_OP_LESS_EQUAL,
    MP_BINARY_OP_MORE_EQUAL,
    MP_BINARY_OP_NOT_EQUAL,
389
390
391
    */
    [MP_BINARY_OP_IN] = MP_QSTR___contains__,
    /*
Damien George's avatar
Damien George committed
392
    MP_BINARY_OP_IS,
393
    */
Damien George's avatar
Damien George committed
394
    [MP_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
395
396
};

397
398
399
// Given a member that was extracted from an instance, convert it correctly
// and put the result in the dest[] array for a possible method call.
// Conversion means dealing with static/class methods, callables, and values.
400
// see http://docs.python.org/3/howto/descriptor.html
401
STATIC void instance_convert_return_attr(mp_obj_t self, const mp_obj_type_t *type, mp_obj_t member, mp_obj_t *dest) {
402
    assert(dest[1] == NULL);
403
404
405
406
407
408
    if (MP_OBJ_IS_TYPE(member, &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)) {
        // return a bound method, with self being the type of this object
        dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
409
        dest[1] = (mp_obj_t)type;
410
411
412
    } else if (MP_OBJ_IS_TYPE(member, &mp_type_type)) {
        // Don't try to bind types
        dest[0] = member;
413
414
415
416
417
418
419
420
421
422
    } else if (mp_obj_is_callable(member)) {
        // return a bound method, with self being this object
        dest[0] = member;
        dest[1] = self;
    } else {
        // class member is a value, so just return that value
        dest[0] = member;
    }
}

423
STATIC mp_obj_t instance_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
424
425
    // Note: For ducktyping, CPython does not look in the instance members or use
    // __getattr__ or __getattribute__.  It only looks in the class dictionary.
426
    mp_obj_instance_t *lhs = lhs_in;
427
    qstr op_name = binary_op_method_name[op];
428
    /* Still try to lookup native slot
429
    if (op_name == 0) {
430
        return MP_OBJ_NULL;
431
    }
432
    */
433
    mp_obj_t dest[3] = {MP_OBJ_NULL};
434
435
436
437
438
439
440
    struct class_lookup_data lookup = {
        .obj = lhs,
        .attr = op_name,
        .meth_offset = offsetof(mp_obj_type_t, binary_op),
        .dest = dest,
    };
    mp_obj_class_lookup(&lookup, lhs->base.type);
441
    if (dest[0] == MP_OBJ_SENTINEL) {
442
        return mp_binary_op(op, lhs->subobj[0], rhs_in);
443
    } else if (dest[0] != MP_OBJ_NULL) {
444
445
        dest[2] = rhs_in;
        return mp_call_method_n_kw(1, 0, dest);
446
    } else {
447
        return MP_OBJ_NULL; // op not supported
448
449
450
    }
}

451
STATIC void instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
452
    // logic: look in obj members then class locals (TODO check this against CPython)
453
    assert(is_instance_type(mp_obj_get_type(self_in)));
454
    mp_obj_instance_t *self = self_in;
455

456
457
458
    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
459
        // TODO should we check for properties?
460
        dest[0] = elem->value;
461
462
        return;
    }
463

464
465
466
467
468
469
470
    struct class_lookup_data lookup = {
        .obj = self,
        .attr = attr,
        .meth_offset = 0,
        .dest = dest,
    };
    mp_obj_class_lookup(&lookup, self->base.type);
471
    mp_obj_t member = dest[0];
472
    if (member != MP_OBJ_NULL) {
473
#if MICROPY_PY_BUILTINS_PROPERTY
474
        if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
475
476
            // object member is a property
            // delegate the store to the property
477
            // TODO should this be part of instance_convert_return_attr?
478
479
480
481
482
            const mp_obj_t *proxy = mp_obj_property_get(member);
            if (proxy[0] == mp_const_none) {
                // TODO
            } else {
                dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in);
483
                // TODO should we convert the returned value using instance_convert_return_attr?
484
485
            }
        }
486
#endif
Damien George's avatar
Damien George committed
487
488
489
490
491
492
493
494
495
496
497
498
        return;
    }

    // try __getattr__
    if (attr != MP_QSTR___getattr__) {
        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);
499
500
501
502
503
            return;
        }
    }
}

504
STATIC bool instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
505
    mp_obj_instance_t *self = self_in;
506

507
#if MICROPY_PY_BUILTINS_PROPERTY
508
509
    // for property, we need to do a lookup first in the class dict
    // this makes all stores slow... how to fix?
510
    mp_obj_t member[2] = {MP_OBJ_NULL};
511
512
513
514
515
516
517
    struct class_lookup_data lookup = {
        .obj = self,
        .attr = attr,
        .meth_offset = 0,
        .dest = member,
    };
    mp_obj_class_lookup(&lookup, self->base.type);
518
    if (member[0] != MP_OBJ_NULL && MP_OBJ_IS_TYPE(member[0], &mp_type_property)) {
519
520
        // attribute already exists and is a property
        // delegate the store to the property
521
        const mp_obj_t *proxy = mp_obj_property_get(member[0]);
522
523
524
525
526
527
528
529
530
531
532
        if (proxy[1] == mp_const_none) {
            // TODO better error message
            return false;
        } else {
            mp_obj_t dest[2] = {self_in, value};
            mp_call_function_n_kw(proxy[1], 2, 0, dest);
            return true;
        }
    }
#endif

533
534
    if (value == MP_OBJ_NULL) {
        // delete attribute
535
536
        mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
        return elem != NULL;
537
538
539
540
541
    } else {
        // store attribute
        mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
        return true;
    }
542
543
}

544
STATIC mp_obj_t instance_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
545
    mp_obj_instance_t *self = self_in;
546
    mp_obj_t member[2] = {MP_OBJ_NULL};
547
548
549
550
551
    struct class_lookup_data lookup = {
        .obj = self,
        .meth_offset = offsetof(mp_obj_type_t, subscr),
        .dest = member,
    };
552
    uint meth_args;
553
554
    if (value == MP_OBJ_NULL) {
        // delete item
555
556
        lookup.attr = MP_QSTR___delitem__;
        mp_obj_class_lookup(&lookup, self->base.type);
557
        meth_args = 2;
558
559
    } else if (value == MP_OBJ_SENTINEL) {
        // load item
560
561
        lookup.attr = MP_QSTR___getitem__;
        mp_obj_class_lookup(&lookup, self->base.type);
562
        meth_args = 2;
563
    } else {
564
        // store item
565
566
        lookup.attr = MP_QSTR___setitem__;
        mp_obj_class_lookup(&lookup, self->base.type);
567
        meth_args = 3;
568
    }
569
    if (member[0] == MP_OBJ_SENTINEL) {
570
        return mp_obj_subscr(self->subobj[0], index, value);
571
    } else if (member[0] != MP_OBJ_NULL) {
572
        mp_obj_t args[3] = {self_in, index, value};
573
        // TODO probably need to call instance_convert_return_attr, and use mp_call_method_n_kw
574
        mp_obj_t ret = mp_call_function_n_kw(member[0], meth_args, 0, args);
575
576
577
578
579
        if (value == MP_OBJ_SENTINEL) {
            return ret;
        } else {
            return mp_const_none;
        }
580
    } else {
581
        return MP_OBJ_NULL; // op not supported
582
583
584
    }
}

585
STATIC mp_obj_t instance_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
586
    mp_obj_instance_t *self = self_in;
587
    mp_obj_t member[2] = {MP_OBJ_NULL};
588
589
590
591
592
593
594
    struct class_lookup_data lookup = {
        .obj = self,
        .attr = MP_QSTR___call__,
        .meth_offset = offsetof(mp_obj_type_t, call),
        .dest = member,
    };
    mp_obj_class_lookup(&lookup, self->base.type);
595
    if (member[0] == MP_OBJ_NULL) {
596
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object is not callable", mp_obj_get_type_str(self_in)));
597
    }
598
    if (member[0] == MP_OBJ_SENTINEL) {
599
600
        return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args);
    }
601
    mp_obj_t meth = mp_obj_new_bound_meth(member[0], self);
602
603
604
    return mp_call_function_n_kw(meth, n_args, n_kw, args);
}

605
606
607
STATIC mp_obj_t instance_getiter(mp_obj_t self_in) {
    mp_obj_instance_t *self = self_in;
    mp_obj_t member[2] = {MP_OBJ_NULL};
608
609
610
611
612
613
614
    struct class_lookup_data lookup = {
        .obj = self,
        .attr = MP_QSTR___iter__,
        .meth_offset = offsetof(mp_obj_type_t, getiter),
        .dest = member,
    };
    mp_obj_class_lookup(&lookup, self->base.type);
615
616
    if (member[0] == MP_OBJ_NULL) {
        // This kinda duplicates code in mp_getiter()
617
618
619
        lookup.attr = MP_QSTR___getitem__;
        lookup.meth_offset = 0; // TODO
        mp_obj_class_lookup(&lookup, self->base.type);
620
621
622
623
624
625
626
627
628
629
630
631
632
633
        if (member[0] != MP_OBJ_NULL) {
            // __getitem__ exists, create an iterator
            return mp_obj_new_getitem_iter(member);
        }
        return MP_OBJ_NULL;
    }
    if (member[0] == MP_OBJ_SENTINEL) {
        mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
        return type->getiter(self->subobj[0]);
    }
    mp_obj_t meth = mp_obj_new_bound_meth(member[0], self);
    return mp_call_function_n_kw(meth, 0, 0, NULL);
}

634
635
636
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
637
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
638
//  - creating a new class (a new type) creates a new mp_obj_type_t
639

640
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
641
    mp_obj_type_t *self = self_in;
642
    print(env, "<class '%s'>", qstr_str(self->name));
643
644
}

645
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
646
    mp_arg_check_num(n_args, n_kw, 1, 3, false);
647

648
649
650
651
652
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
653
            // args[0] = name
654
            // args[1] = bases tuple
655
            // args[2] = locals dict
656
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
657
658

        default:
659
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
660
661
662
    }
}

663
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
664
665
    // instantiate an instance of a class

666
    mp_obj_type_t *self = self_in;
667
668

    if (self->make_new == NULL) {
669
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
670
    }
671
672

    // make new instance
673
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
674
675
676
677
678

    // return new instance
    return o;
}

679
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
680
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
681
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
682
    mp_obj_type_t *self = self_in;
683
#if MICROPY_CPYTHON_COMPAT
684
685
686
687
    if (attr == MP_QSTR___name__) {
        dest[0] = MP_OBJ_NEW_QSTR(self->name);
        return;
    }
688
#endif
689
    struct class_lookup_data lookup = {
690
        .obj = self_in,
691
692
693
        .attr = attr,
        .meth_offset = 0,
        .dest = dest,
694
        .is_type = true,
695
696
    };
    mp_obj_class_lookup(&lookup, self);
697
698
}

699
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
700
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
701
702
    mp_obj_type_t *self = self_in;

703
704
    // TODO CPython allows STORE_ATTR to a class, but is this the correct implementation?

705
    if (self->locals_dict != NULL) {
706
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
707
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
708
709
710
711
712
713
714
715
716
717
718
719
720
        if (value == 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
            return elem != NULL;
        } 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 = value;
                return true;
            }
721
        }
722
    }
723
724

    return false;
725
726
}

727
728
729
730
731
732
STATIC mp_obj_t type_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
    switch (op) {
        case MP_BINARY_OP_EQUAL:
            // Types can be equal only if it's the same type structure,
            // we don't even need to check for 2nd arg type.
            return MP_BOOL(lhs_in == rhs_in);
733
734

        default:
735
            return MP_OBJ_NULL; // op not supported
736
737
738
    }
}

739
740
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
741
    .name = MP_QSTR_type,
742
    .print = type_print,
743
    .make_new = type_make_new,
744
    .call = type_call,
745
746
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
747
    .binary_op = type_binary_op,
748
};
749

750
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
751
    assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
752
    assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
753

754
755
    // TODO might need to make a copy of locals_dict; at least that's how CPython does it

756
757
758
759
760
761
762
763
764
765
766
767
768
    // 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)));
        }
    }

769
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
770
    o->base.type = &mp_type_type;
771
    o->name = name;
772
773
774
775
776
777
778
779
    o->print = instance_print;
    o->make_new = instance_make_new;
    o->unary_op = instance_unary_op;
    o->binary_op = instance_binary_op;
    o->load_attr = instance_load_attr;
    o->store_attr = instance_store_attr;
    o->subscr = instance_subscr;
    o->call = instance_call;
780
    o->getiter = instance_getiter;
781
782
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
783
784

    const mp_obj_type_t *native_base;
785
    uint num_native_bases = instance_count_native_bases(o, &native_base);
786
787
788
789
    if (num_native_bases > 1) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "multiple bases have instance lay-out conflict"));
    }

790
791
792
793
794
795
796
797
798
799
    mp_map_t *locals_map = mp_obj_dict_get_map(o->locals_dict);
    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
        if (MP_OBJ_IS_TYPE(elem->value, &mp_type_fun_native) || MP_OBJ_IS_TYPE(elem->value, &mp_type_fun_bc)) {
            // __new__ is a function, wrap it in a staticmethod decorator
            elem->value = static_class_method_make_new((mp_obj_t)&mp_type_staticmethod, 1, 0, &elem->value);
        }
    }

800
801
    return o;
}
802
803

/******************************************************************************/
Damien George's avatar
Damien George committed
804
805
806
807
808
809
810
811
// 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;

812
STATIC void super_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
Damien George's avatar
Damien George committed
813
814
815
816
817
818
819
820
    mp_obj_super_t *self = self_in;
    print(env, "<super: ");
    mp_obj_print_helper(print, env, self->type, PRINT_STR);
    print(env, ", ");
    mp_obj_print_helper(print, env, self->obj, PRINT_STR);
    print(env, ">");
}

821
STATIC mp_obj_t super_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
Damien George's avatar
Damien George committed
822
823
824
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
825
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
826
827
828
829
830
    }
    return mp_obj_new_super(args[0], args[1]);
}

// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
831
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
832
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
Damien George's avatar
Damien George committed
833
834
    mp_obj_super_t *self = self_in;

835
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
836
837
838
839
840
841
842
843
844
845
846

    mp_obj_type_t *type = self->type;

    // for a const struct, this entry might be NULL
    if (type->bases_tuple == MP_OBJ_NULL) {
        return;
    }

    uint len;
    mp_obj_t *items;
    mp_obj_tuple_get(type->bases_tuple, &len, &items);
847
848
849
850
851
852
    struct class_lookup_data lookup = {
        .obj = self->obj,
        .attr = attr,
        .meth_offset = 0,
        .dest = dest,
    };
Damien George's avatar
Damien George committed
853
    for (uint i = 0; i < len; i++) {
854
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
855
        mp_obj_class_lookup(&lookup, (mp_obj_type_t*)items[i]);
856
857
858
        if (dest[0] != MP_OBJ_NULL) {
            return;
        }
Damien George's avatar
Damien George committed
859
    }
860
    mp_obj_class_lookup(&lookup, &mp_type_object);
Damien George's avatar
Damien George committed
861
862
}

863
const mp_obj_type_t mp_type_super = {
864
    { &mp_type_type },
865
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
866
867
868
869
870
871
872
    .print = super_print,
    .make_new = super_make_new,
    .load_attr = super_load_attr,
};

mp_obj_t mp_obj_new_super(mp_obj_t type, mp_obj_t obj) {
    mp_obj_super_t *o = m_new_obj(mp_obj_super_t);
873
    *o = (mp_obj_super_t){{&mp_type_super}, type, obj};
Damien George's avatar
Damien George committed
874
875
876
877
    return o;
}

/******************************************************************************/
878
// subclassing and built-ins specific to types
879

880
881
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
882
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
883
884
    for (;;) {
        if (object == classinfo) {
885
            return true;
886
887
888
889
        }

        // not equivalent classes, keep searching base classes

890
891
892
893
894
        // 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;
        }

895
        const mp_obj_type_t *self = object;
896
897
898

        // for a const struct, this entry might be NULL
        if (self->bases_tuple == MP_OBJ_NULL) {
899
            return false;
900
901
        }

902
        // get the base objects (they should be type objects)
903
904
905
906
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
907
            return false;
908
        }
909
910

        // iterate through the base objects
911
        for (uint i = 0; i < len - 1; i++) {
912
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
913
                return true;
914
915
916
917
918
919
920
921
            }
        }

        // search last base (simple tail recursion elimination)
        object = items[len - 1];
    }
}

922
923
924
925
926
927
STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) {
    uint len;
    mp_obj_t *items;
    if (MP_OBJ_IS_TYPE(classinfo, &mp_type_type)) {
        len = 1;
        items = &classinfo;
928
    } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
929
930
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
931
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
932
933
    }

934
    for (uint i = 0; i < len; i++) {
935
936
        // We explicitly check for 'object' here since no-one explicitly derives from it
        if (items[i] == &mp_type_object || mp_obj_is_subclass_fast(object, items[i])) {
937
938
            return mp_const_true;
        }
939
    }