objtype.c 28 KB
Newer Older
1
2
#include <stdio.h>
#include <stddef.h>
3
4
#include <string.h>
#include <assert.h>
5
6
7
8

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
9
#include "qstr.h"
10
#include "obj.h"
11
#include "runtime0.h"
12
13
#include "runtime.h"

14
15
16
17
18
19
20
#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

21
22
23
24
25
26
27
/******************************************************************************/
// class object
// creating an instance of a class makes one of these objects

typedef struct _mp_obj_class_t {
    mp_obj_base_t base;
    mp_map_t members;
28
    mp_obj_t subobj[];
Damien George's avatar
Damien George committed
29
    // TODO maybe cache __getattr__ and __setattr__ for efficient lookup of them
30
31
} mp_obj_class_t;

32
33
34
35
36
#define is_native_type(type) ((type)->make_new != class_make_new)
STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args);

STATIC mp_obj_t mp_obj_new_class(mp_obj_t class, uint subobjs) {
    mp_obj_class_t *o = m_new_obj_var(mp_obj_class_t, mp_obj_t, subobjs);
37
38
    o->base.type = class;
    mp_map_init(&o->members, 0);
39
    mp_seq_clear(o->subobj, 0, subobjs, sizeof(*o->subobj));
40
41
42
    return o;
}

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
STATIC int class_count_native_bases(const mp_obj_type_t *type, const mp_obj_type_t **last_native_base) {
    uint len;
    mp_obj_t *items;
    mp_obj_tuple_get(type->bases_tuple, &len, &items);

    int count = 0;
    for (uint i = 0; i < len; i++) {
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
        if (is_native_type((const mp_obj_type_t *)items[i])) {
            *last_native_base = items[i];
            count++;
        } else {
            count += class_count_native_bases(items[i], last_native_base);
        }
    }

    return count;
}

// TODO
// This implements depth-first left-to-right MRO, which is not compliant with Python3 MRO
// http://python-history.blogspot.com/2010/06/method-resolution-order.html
// https://www.python.org/download/releases/2.3/mro/
//
67
// will return MP_OBJ_NULL if not found
68
69
70
71
72
73
// will return MP_OBJ_SENTINEL if special method was found in a native type base
// via slot id (meth_offset). As there can be only one native base, it's known that it
// applies to instance->subobj[0]. In most cases, we also don't need to know which type
// it was - because instance->subobj[0] is of that type. The only exception is when
// object is not yet constructed, then we need to know base native type to construct
// instance->subobj[0]. This case is handled via class_count_native_bases() though.
74
STATIC mp_obj_t mp_obj_class_lookup(mp_obj_class_t *o, const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset) {
75
    for (;;) {
76
77
78
79
80
81
82
83
84
85
86
        // Optimize special method lookup for native types
        // This avoids extra method_name => slot lookup. On the other hand,
        // this should not be applied to class types, as will result in extra
        // lookup either.
        if (meth_offset != 0 && is_native_type(type)) {
            if (*(void**)((char*)type + meth_offset) != NULL) {
                DEBUG_printf("mp_obj_class_lookup: matched special meth slot for %s\n", qstr_str(attr));
                return MP_OBJ_SENTINEL;
            }
        }

87
        if (type->locals_dict != NULL) {
88
            // search locals_dict (the set of methods/attributes)
89
            assert(MP_OBJ_IS_TYPE(type->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
90
            mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict);
91
92
93
94
            mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
            if (elem != NULL) {
                return elem->value;
            }
95
96
        }

97
98
99
100
101
102
103
104
105
106
107
        if (o != MP_OBJ_NULL && is_native_type(type)) {
            mp_obj_t dest[2];
            mp_load_method_maybe(o->subobj[0], attr, dest);
            if (dest[0] != MP_OBJ_NULL) {
                if (dest[1] == MP_OBJ_NULL) {
                    return dest[0];
                }
                assert(0);
            }
        }

108
109
110
        // attribute not found, keep searching base classes

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

        uint len;
        mp_obj_t *items;
117
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
118
        if (len == 0) {
119
            return MP_OBJ_NULL;
120
121
        }
        for (uint i = 0; i < len - 1; i++) {
122
            assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
123
            mp_obj_t obj = mp_obj_class_lookup(o, (mp_obj_type_t*)items[i], attr, meth_offset);
124
125
            if (obj != MP_OBJ_NULL) {
                return obj;
126
127
128
129
            }
        }

        // search last base (simple tail recursion elimination)
130
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_type_type));
131
        type = (mp_obj_type_t*)items[len - 1];
132
133
134
    }
}

135
STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
136
137
    mp_obj_class_t *self = self_in;
    qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
138
    mp_obj_t member = mp_obj_class_lookup(self, self->base.type, meth, offsetof(mp_obj_type_t, print));
139
140
    if (member == MP_OBJ_NULL && kind == PRINT_STR) {
        // If there's no __str__, fall back to __repr__
141
        member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___repr__, 0);
142
143
144
145
146
    }

    if (member == MP_OBJ_SENTINEL) {
        mp_obj_print_helper(print, env, self->subobj[0], kind);
        return;
147
148
149
    }

    if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
150
        mp_obj_t r = mp_call_function_1(member, self_in);
151
152
153
154
155
        mp_obj_print_helper(print, env, r, PRINT_STR);
        return;
    }

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

159
STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
160
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
161
    mp_obj_type_t *self = self_in;
162

163
164
165
    const mp_obj_type_t *native_base;
    uint num_native_bases = class_count_native_bases(self, &native_base);
    assert(num_native_bases < 2);
166

167
    mp_obj_class_t *o = mp_obj_new_class(self_in, num_native_bases);
168

169
    // look for __init__ function
170
    mp_obj_t init_fn = mp_obj_class_lookup(NULL, self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new));
171
172
173
174
175
176
177
178
179
180
181

    if (init_fn == MP_OBJ_SENTINEL) {
        // Native type's constructor is what wins - it gets all our arguments,
        // and none Python classes are initialized at all.
        o->subobj[0] = native_base->make_new((mp_obj_type_t*)native_base, n_args, n_kw, args);
    } else if (init_fn != MP_OBJ_NULL) {
        // We need to default-initialize any native subobjs first
        if (num_native_bases > 0) {
            o->subobj[0] = native_base->make_new((mp_obj_type_t*)native_base, 0, 0, NULL);
        }
        // now call Python class __init__ function with all args
182
        mp_obj_t init_ret;
183
        if (n_args == 0 && n_kw == 0) {
Damien George's avatar
Damien George committed
184
            init_ret = mp_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
185
        } else {
186
187
188
            mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
            args2[0] = o;
            memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
Damien George's avatar
Damien George committed
189
            init_ret = mp_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
190
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
191
192
        }
        if (init_ret != mp_const_none) {
193
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
194
195
196
197
        }

    } else {
        if (n_args != 0) {
198
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "object() takes no parameters"));
199
200
201
202
203
204
        }
    }

    return o;
}

205
STATIC const qstr unary_op_method_name[] = {
Damien George's avatar
Damien George committed
206
207
208
209
210
211
    [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
212
213
};

214
STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
215
216
    mp_obj_class_t *self = self_in;
    qstr op_name = unary_op_method_name[op];
217
    /* Still try to lookup native slot
218
    if (op_name == 0) {
219
        return MP_OBJ_NOT_SUPPORTED;
220
    }
221
    */
222
    mp_obj_t member = mp_obj_class_lookup(self, self->base.type, op_name, offsetof(mp_obj_type_t, unary_op));
223
224
225
    if (member == MP_OBJ_SENTINEL) {
        return mp_unary_op(op, self->subobj[0]);
    } else if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
226
        return mp_call_function_1(member, self_in);
227
    } else {
228
        return MP_OBJ_NOT_SUPPORTED;
229
230
231
    }
}

232
STATIC const qstr binary_op_method_name[] = {
233
    /*
Damien George's avatar
Damien George committed
234
235
236
237
238
    MP_BINARY_OP_OR,
    MP_BINARY_OP_XOR,
    MP_BINARY_OP_AND,
    MP_BINARY_OP_LSHIFT,
    MP_BINARY_OP_RSHIFT,
239
    */
Damien George's avatar
Damien George committed
240
241
    [MP_BINARY_OP_ADD] = MP_QSTR___add__,
    [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
242
    /*
Damien George's avatar
Damien George committed
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
    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,
    MP_BINARY_OP_INPLACE_POWER,
    MP_BINARY_OP_LESS,
    MP_BINARY_OP_MORE,
    MP_BINARY_OP_EQUAL,
    MP_BINARY_OP_LESS_EQUAL,
    MP_BINARY_OP_MORE_EQUAL,
    MP_BINARY_OP_NOT_EQUAL,
    MP_BINARY_OP_IN,
    MP_BINARY_OP_IS,
268
    */
Damien George's avatar
Damien George committed
269
    [MP_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
270
271
};

272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
// 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.
// see http://docs.python.org/3.3/howto/descriptor.html
STATIC void class_convert_return_attr(mp_obj_t self, mp_obj_t member, mp_obj_t *dest) {
    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;
        dest[1] = mp_obj_get_type(self);
    } 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;
    }
}

294
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
295
296
    // Note: For ducktyping, CPython does not look in the instance members or use
    // __getattr__ or __getattribute__.  It only looks in the class dictionary.
297
    mp_obj_class_t *lhs = lhs_in;
298
    qstr op_name = binary_op_method_name[op];
299
    /* Still try to lookup native slot
300
    if (op_name == 0) {
301
        return MP_OBJ_NOT_SUPPORTED;
302
    }
303
    */
304
    mp_obj_t member = mp_obj_class_lookup(lhs, lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op));
305
306
307
    if (member == MP_OBJ_SENTINEL) {
        return mp_binary_op(op, lhs->subobj[0], rhs_in);
    } else if (member != MP_OBJ_NULL) {
308
309
310
311
312
        mp_obj_t dest[3];
        dest[1] = MP_OBJ_NULL;
        class_convert_return_attr(lhs_in, member, dest);
        dest[2] = rhs_in;
        return mp_call_method_n_kw(1, 0, dest);
313
    } else {
314
        return MP_OBJ_NOT_SUPPORTED;
315
316
317
    }
}

318
STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
319
320
    // logic: look in obj members then class locals (TODO check this against CPython)
    mp_obj_class_t *self = self_in;
321

322
323
324
    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
325
        // TODO should we check for properties?
326
        dest[0] = elem->value;
327
328
        return;
    }
329

330
    mp_obj_t member = mp_obj_class_lookup(self, self->base.type, attr, 0);
331
    if (member != MP_OBJ_NULL) {
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
        if (0) {
#if MICROPY_ENABLE_PROPERTY
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
            // object member is a property
            // delegate the store to the property
            // TODO should this be part of class_convert_return_attr?
            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);
                // TODO should we convert the returned value using class_convert_return_attr?
            }
#endif
        } else {
            // not a property
            class_convert_return_attr(self_in, member, dest);
        }
Damien George's avatar
Damien George committed
350
351
352
353
354
355
356
357
358
359
360
361
        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);
362
363
364
365
366
            return;
        }
    }
}

367
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
368
    mp_obj_class_t *self = self_in;
369
370
371
372

#if MICROPY_ENABLE_PROPERTY
    // for property, we need to do a lookup first in the class dict
    // this makes all stores slow... how to fix?
373
    mp_obj_t member = mp_obj_class_lookup(self, self->base.type, attr, 0);
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
    if (member != MP_OBJ_NULL && MP_OBJ_IS_TYPE(member, &mp_type_property)) {
        // attribute already exists and is a property
        // delegate the store to the property
        const mp_obj_t *proxy = mp_obj_property_get(member);
        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

389
390
    if (value == MP_OBJ_NULL) {
        // delete attribute
391
392
        mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
        return elem != NULL;
393
394
395
396
397
    } else {
        // store attribute
        mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
        return true;
    }
398
399
}

400
STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
401
402
403
    mp_obj_class_t *self = self_in;
    mp_obj_t member;
    uint meth_args;
404
405
    if (value == MP_OBJ_NULL) {
        // delete item
406
        member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr));
407
        meth_args = 2;
408
409
    } else if (value == MP_OBJ_SENTINEL) {
        // load item
410
        member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr));
411
        meth_args = 2;
412
    } else {
413
        // store item
414
        member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr));
415
        meth_args = 3;
416
    }
417
418
419
    if (member == MP_OBJ_SENTINEL) {
        return mp_obj_subscr(self->subobj[0], index, value);
    } else if (member != MP_OBJ_NULL) {
420
        mp_obj_t args[3] = {self_in, index, value};
421
422
423
424
425
426
427
        // TODO probably need to call class_convert_return_attr, and use mp_call_method_n_kw
        mp_obj_t ret = mp_call_function_n_kw(member, meth_args, 0, args);
        if (value == MP_OBJ_SENTINEL) {
            return ret;
        } else {
            return mp_const_none;
        }
428
    } else {
429
        return MP_OBJ_NOT_SUPPORTED;
430
431
432
    }
}

433
434
STATIC mp_obj_t class_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
    mp_obj_class_t *self = self_in;
435
    mp_obj_t member = mp_obj_class_lookup(self, self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call));
436
437
438
    if (member == MP_OBJ_NULL) {
        return member;
    }
439
440
441
    if (member == MP_OBJ_SENTINEL) {
        return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args);
    }
442
443
444
445
    mp_obj_t meth = mp_obj_new_bound_meth(member, self);
    return mp_call_function_n_kw(meth, n_args, n_kw, args);
}

446
447
448
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
449
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
450
//  - creating a new class (a new type) creates a new mp_obj_type_t
451

452
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
453
    mp_obj_type_t *self = self_in;
454
    print(env, "<class '%s'>", qstr_str(self->name));
455
456
}

457
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
458
459
    // TODO check n_kw == 0

460
461
462
463
464
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
465
            // args[0] = name
466
            // args[1] = bases tuple
467
            // args[2] = locals dict
468
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
469
470

        default:
471
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
472
473
474
    }
}

475
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
476
477
    // instantiate an instance of a class

478
    mp_obj_type_t *self = self_in;
479
480

    if (self->make_new == NULL) {
481
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
482
    }
483
484

    // make new instance
485
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
486
487
488
489
490

    // return new instance
    return o;
}

491
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
492
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
493
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
494
    mp_obj_type_t *self = self_in;
495
#if MICROPY_CPYTHON_COMPAT
496
497
498
499
    if (attr == MP_QSTR___name__) {
        dest[0] = MP_OBJ_NEW_QSTR(self->name);
        return;
    }
500
#endif
501
    mp_obj_t member = mp_obj_class_lookup(NULL, self, attr, 0);
502
503
504
505
506
    if (member != MP_OBJ_NULL) {
        // check if the methods are functions, static or class methods
        // see http://docs.python.org/3.3/howto/descriptor.html
        if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) {
            // return just the function
507
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
508
509
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
510
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
511
512
513
514
515
            dest[1] = self_in;
        } else {
            // return just the function
            // TODO need to wrap in a type check for the first argument; eg list.append(1,1) needs to throw an exception
            dest[0] = (mp_obj_t)member;
516
517
        }
    }
518
519
}

520
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
521
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
522
523
    mp_obj_type_t *self = self_in;

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

526
    if (self->locals_dict != NULL) {
527
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
528
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
529
530
531
532
533
534
535
536
537
538
539
540
541
        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;
            }
542
        }
543
    }
544
545

    return false;
546
547
}

548
549
550
551
552
553
554
555
556
557
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);
    }
    return NULL;
}

558
559
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
560
    .name = MP_QSTR_type,
561
    .print = type_print,
562
    .make_new = type_make_new,
563
    .call = type_call,
564
565
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
566
    .binary_op = type_binary_op,
567
};
568

569
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
570
    assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
571
    assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
572
573
574
575
576
577
578
579
580
581
582
583
584
585

    // 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)));
        }
    }

586
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
587
    o->base.type = &mp_type_type;
588
    o->name = name;
589
590
    o->print = class_print;
    o->make_new = class_make_new;
591
    o->unary_op = class_unary_op;
592
    o->binary_op = class_binary_op;
593
594
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
595
    o->subscr = class_subscr;
596
    o->call = class_call;
597
598
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
599
600
601
602
603
604
605

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

606
607
    return o;
}
608
609

/******************************************************************************/
Damien George's avatar
Damien George committed
610
611
612
613
614
615
616
617
// 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;

618
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
619
620
621
622
623
624
625
626
    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, ">");
}

627
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
628
629
630
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
631
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
632
633
634
635
636
    }
    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
637
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
638
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
Damien George's avatar
Damien George committed
639
640
    mp_obj_super_t *self = self_in;

641
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
642
643
644
645
646
647
648
649
650
651
652
653

    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);
    for (uint i = 0; i < len; i++) {
654
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
655
        mp_obj_t member = mp_obj_class_lookup(self->obj, (mp_obj_type_t*)items[i], attr, 0);
Damien George's avatar
Damien George committed
656
        if (member != MP_OBJ_NULL) {
657
            class_convert_return_attr(self->obj, member, dest);
658
            return;
Damien George's avatar
Damien George committed
659
660
661
662
        }
    }
}

663
const mp_obj_type_t mp_type_super = {
664
    { &mp_type_type },
665
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
666
667
668
669
670
671
672
    .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);
673
    *o = (mp_obj_super_t){{&mp_type_super}, type, obj};
Damien George's avatar
Damien George committed
674
675
676
677
    return o;
}

/******************************************************************************/
678
// subclassing and built-ins specific to types
679

680
681
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
682
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
683
684
    for (;;) {
        if (object == classinfo) {
685
            return true;
686
687
688
689
        }

        // not equivalent classes, keep searching base classes

690
691
692
693
694
        // 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;
        }

695
        const mp_obj_type_t *self = object;
696
697
698

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

702
        // get the base objects (they should be type objects)
703
704
705
706
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
707
            return false;
708
        }
709
710

        // iterate through the base objects
711
        for (uint i = 0; i < len - 1; i++) {
712
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
713
                return true;
714
715
716
717
718
719
720
721
            }
        }

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

722
723
724
725
726
727
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;
728
    } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
729
730
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
731
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
732
733
    }

734
    for (uint i = 0; i < len; i++) {
735
736
        // 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])) {
737
738
            return mp_const_true;
        }
739
    }
740
    return mp_const_false;
741
742
}

743
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
744
    if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
745
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class"));
746
747
    }
    return mp_obj_is_subclass(object, classinfo);
748
749
}

750
751
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

752
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
753
    return mp_obj_is_subclass(mp_obj_get_type(object), classinfo);
754
755
756
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
757
758
759
760

/******************************************************************************/
// staticmethod and classmethod types (probably should go in a different file)

761
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) {
762
763
764
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
765
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 1 positional argument but %d were given", n_args));
766
767
768
769
770
771
772
    }

    mp_obj_static_class_method_t *o = m_new_obj(mp_obj_static_class_method_t);
    *o = (mp_obj_static_class_method_t){{(mp_obj_type_t*)self_in}, args[0]};
    return o;
}

773
const mp_obj_type_t mp_type_staticmethod = {
774
    { &mp_type_type },
775
    .name = MP_QSTR_staticmethod,
776
    .make_new = static_class_method_make_new
777
778
779
};

const mp_obj_type_t mp_type_classmethod = {
780
    { &mp_type_type },
781
    .name = MP_QSTR_classmethod,
782
    .make_new = static_class_method_make_new
783
};