objtype.c 27.6 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
74
// will return MP_OBJ_SENTINEL if special method was found in a native type base
// via slot id (meth_offset). As there can be only one native base, it's known that it
// applies to instance->subobj[0]. In most cases, we also don't need to know which type
// it was - because instance->subobj[0] is of that type. The only exception is when
// object is not yet constructed, then we need to know base native type to construct
// instance->subobj[0]. This case is handled via class_count_native_bases() though.
STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, machine_uint_t meth_offset) {
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
        }

        // attribute not found, keep searching base classes

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

        uint len;
        mp_obj_t *items;
106
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
107
        if (len == 0) {
108
            return MP_OBJ_NULL;
109
110
        }
        for (uint i = 0; i < len - 1; i++) {
111
            assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
112
            mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, meth_offset);
113
114
            if (obj != MP_OBJ_NULL) {
                return obj;
115
116
117
118
            }
        }

        // search last base (simple tail recursion elimination)
119
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_type_type));
120
        type = (mp_obj_type_t*)items[len - 1];
121
122
123
    }
}

124
STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
125
126
    mp_obj_class_t *self = self_in;
    qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
127
    mp_obj_t member = mp_obj_class_lookup(self->base.type, meth, offsetof(mp_obj_type_t, print));
128
129
    if (member == MP_OBJ_NULL && kind == PRINT_STR) {
        // If there's no __str__, fall back to __repr__
130
131
132
133
134
135
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___repr__, 0);
    }

    if (member == MP_OBJ_SENTINEL) {
        mp_obj_print_helper(print, env, self->subobj[0], kind);
        return;
136
137
138
    }

    if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
139
        mp_obj_t r = mp_call_function_1(member, self_in);
140
141
142
143
144
        mp_obj_print_helper(print, env, r, PRINT_STR);
        return;
    }

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

148
STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
149
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
150
    mp_obj_type_t *self = self_in;
151

152
153
154
    const mp_obj_type_t *native_base;
    uint num_native_bases = class_count_native_bases(self, &native_base);
    assert(num_native_bases < 2);
155

156
    mp_obj_class_t *o = mp_obj_new_class(self_in, num_native_bases);
157

158
159
160
161
162
163
164
165
166
167
168
169
170
    // look for __init__ function
    mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__, offsetof(mp_obj_type_t, make_new));

    if (init_fn == MP_OBJ_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
171
        mp_obj_t init_ret;
172
        if (n_args == 0 && n_kw == 0) {
Damien George's avatar
Damien George committed
173
            init_ret = mp_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
174
        } else {
175
176
177
            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
178
            init_ret = mp_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
179
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
180
181
        }
        if (init_ret != mp_const_none) {
182
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
183
184
185
186
        }

    } else {
        if (n_args != 0) {
187
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "object() takes no parameters"));
188
189
190
191
192
193
        }
    }

    return o;
}

194
STATIC const qstr unary_op_method_name[] = {
Damien George's avatar
Damien George committed
195
196
197
198
199
200
    [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
201
202
};

203
STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
204
205
    mp_obj_class_t *self = self_in;
    qstr op_name = unary_op_method_name[op];
206
    /* Still try to lookup native slot
207
    if (op_name == 0) {
208
        return MP_OBJ_NOT_SUPPORTED;
209
    }
210
211
212
213
214
    */
    mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name, offsetof(mp_obj_type_t, unary_op));
    if (member == MP_OBJ_SENTINEL) {
        return mp_unary_op(op, self->subobj[0]);
    } else if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
215
        return mp_call_function_1(member, self_in);
216
    } else {
217
        return MP_OBJ_NOT_SUPPORTED;
218
219
220
    }
}

221
STATIC const qstr binary_op_method_name[] = {
222
    /*
Damien George's avatar
Damien George committed
223
224
225
226
227
    MP_BINARY_OP_OR,
    MP_BINARY_OP_XOR,
    MP_BINARY_OP_AND,
    MP_BINARY_OP_LSHIFT,
    MP_BINARY_OP_RSHIFT,
228
    */
Damien George's avatar
Damien George committed
229
230
    [MP_BINARY_OP_ADD] = MP_QSTR___add__,
    [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
231
    /*
Damien George's avatar
Damien George committed
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
    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,
257
    */
Damien George's avatar
Damien George committed
258
    [MP_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
259
260
};

261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
// 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;
    }
}

283
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
284
285
    // Note: For ducktyping, CPython does not look in the instance members or use
    // __getattr__ or __getattribute__.  It only looks in the class dictionary.
286
    mp_obj_class_t *lhs = lhs_in;
287
    qstr op_name = binary_op_method_name[op];
288
    /* Still try to lookup native slot
289
    if (op_name == 0) {
290
        return MP_OBJ_NOT_SUPPORTED;
291
    }
292
293
294
295
296
    */
    mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name, offsetof(mp_obj_type_t, binary_op));
    if (member == MP_OBJ_SENTINEL) {
        return mp_binary_op(op, lhs->subobj[0], rhs_in);
    } else if (member != MP_OBJ_NULL) {
297
298
299
300
301
        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);
302
    } else {
303
        return MP_OBJ_NOT_SUPPORTED;
304
305
306
    }
}

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

311
312
313
    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
314
        // TODO should we check for properties?
315
        dest[0] = elem->value;
316
317
        return;
    }
318

319
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr, 0);
320
    if (member != MP_OBJ_NULL) {
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
        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
339
340
341
342
343
344
345
346
347
348
349
350
        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);
351
352
353
354
355
            return;
        }
    }
}

356
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
357
    mp_obj_class_t *self = self_in;
358
359
360
361

#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?
362
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr, 0);
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
    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

378
379
    if (value == MP_OBJ_NULL) {
        // delete attribute
380
381
        mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
        return elem != NULL;
382
383
384
385
386
    } else {
        // store attribute
        mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
        return true;
    }
387
388
}

389
STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
390
391
392
    mp_obj_class_t *self = self_in;
    mp_obj_t member;
    uint meth_args;
393
394
    if (value == MP_OBJ_NULL) {
        // delete item
395
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___delitem__, offsetof(mp_obj_type_t, subscr));
396
        meth_args = 2;
397
398
    } else if (value == MP_OBJ_SENTINEL) {
        // load item
399
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___getitem__, offsetof(mp_obj_type_t, subscr));
400
        meth_args = 2;
401
    } else {
402
        // store item
403
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__, offsetof(mp_obj_type_t, subscr));
404
        meth_args = 3;
405
    }
406
407
408
    if (member == MP_OBJ_SENTINEL) {
        return mp_obj_subscr(self->subobj[0], index, value);
    } else if (member != MP_OBJ_NULL) {
409
        mp_obj_t args[3] = {self_in, index, value};
410
411
412
413
414
415
416
        // 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;
        }
417
    } else {
418
        return MP_OBJ_NOT_SUPPORTED;
419
420
421
    }
}

422
423
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;
424
    mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___call__, offsetof(mp_obj_type_t, call));
425
426
427
    if (member == MP_OBJ_NULL) {
        return member;
    }
428
429
430
    if (member == MP_OBJ_SENTINEL) {
        return mp_call_function_n_kw(self->subobj[0], n_args, n_kw, args);
    }
431
432
433
434
    mp_obj_t meth = mp_obj_new_bound_meth(member, self);
    return mp_call_function_n_kw(meth, n_args, n_kw, args);
}

435
436
437
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
438
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
439
//  - creating a new class (a new type) creates a new mp_obj_type_t
440

441
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
442
    mp_obj_type_t *self = self_in;
443
    print(env, "<class '%s'>", qstr_str(self->name));
444
445
}

446
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
447
448
    // TODO check n_kw == 0

449
450
451
452
453
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
454
            // args[0] = name
455
            // args[1] = bases tuple
456
            // args[2] = locals dict
457
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
458
459

        default:
460
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
461
462
463
    }
}

464
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
465
466
    // instantiate an instance of a class

467
    mp_obj_type_t *self = self_in;
468
469

    if (self->make_new == NULL) {
470
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
471
    }
472
473

    // make new instance
474
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
475
476
477
478
479

    // return new instance
    return o;
}

480
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
481
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
482
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
483
    mp_obj_type_t *self = self_in;
484
#if MICROPY_CPYTHON_COMPAT
485
486
487
488
    if (attr == MP_QSTR___name__) {
        dest[0] = MP_OBJ_NEW_QSTR(self->name);
        return;
    }
489
#endif
490
    mp_obj_t member = mp_obj_class_lookup(self, attr, 0);
491
492
493
494
495
    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
496
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
497
498
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
499
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
500
501
502
503
504
            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;
505
506
        }
    }
507
508
}

509
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
510
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
511
512
    mp_obj_type_t *self = self_in;

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

515
    if (self->locals_dict != NULL) {
516
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
517
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
518
519
520
521
522
523
524
525
526
527
528
529
530
        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;
            }
531
        }
532
    }
533
534

    return false;
535
536
}

537
538
539
540
541
542
543
544
545
546
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;
}

547
548
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
549
    .name = MP_QSTR_type,
550
    .print = type_print,
551
    .make_new = type_make_new,
552
    .call = type_call,
553
554
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
555
    .binary_op = type_binary_op,
556
};
557

558
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
559
    assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
560
    assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
561
562
563
564
565
566
567
568
569
570
571
572
573
574

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

575
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
576
    o->base.type = &mp_type_type;
577
    o->name = name;
578
579
    o->print = class_print;
    o->make_new = class_make_new;
580
    o->unary_op = class_unary_op;
581
    o->binary_op = class_binary_op;
582
583
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
584
    o->subscr = class_subscr;
585
    o->call = class_call;
586
587
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
588
589
590
591
592
593
594

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

595
596
    return o;
}
597
598

/******************************************************************************/
Damien George's avatar
Damien George committed
599
600
601
602
603
604
605
606
// 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;

607
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
608
609
610
611
612
613
614
615
    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, ">");
}

616
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
617
618
619
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
620
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
621
622
623
624
625
    }
    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
626
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
627
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
Damien George's avatar
Damien George committed
628
629
    mp_obj_super_t *self = self_in;

630
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
631
632
633
634
635
636
637
638
639
640
641
642

    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++) {
643
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
644
        mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, 0);
Damien George's avatar
Damien George committed
645
        if (member != MP_OBJ_NULL) {
646
            class_convert_return_attr(self->obj, member, dest);
647
            return;
Damien George's avatar
Damien George committed
648
649
650
651
        }
    }
}

652
const mp_obj_type_t mp_type_super = {
653
    { &mp_type_type },
654
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
655
656
657
658
659
660
661
    .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);
662
    *o = (mp_obj_super_t){{&mp_type_super}, type, obj};
Damien George's avatar
Damien George committed
663
664
665
666
    return o;
}

/******************************************************************************/
667
// subclassing and built-ins specific to types
668

669
670
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
671
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
672
673
    for (;;) {
        if (object == classinfo) {
674
            return true;
675
676
677
678
        }

        // not equivalent classes, keep searching base classes

679
680
681
682
683
        // 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;
        }

684
        const mp_obj_type_t *self = object;
685
686
687

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

691
        // get the base objects (they should be type objects)
692
693
694
695
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
696
            return false;
697
        }
698
699

        // iterate through the base objects
700
        for (uint i = 0; i < len - 1; i++) {
701
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
702
                return true;
703
704
705
706
707
708
709
710
            }
        }

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

711
712
713
714
715
716
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;
717
    } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
718
719
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
720
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
721
722
    }

723
    for (uint i = 0; i < len; i++) {
724
725
        // 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])) {
726
727
            return mp_const_true;
        }
728
    }
729
    return mp_const_false;
730
731
}

732
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
733
    if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
734
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class"));
735
736
    }
    return mp_obj_is_subclass(object, classinfo);
737
738
}

739
740
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

741
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
742
    return mp_obj_is_subclass(mp_obj_get_type(object), classinfo);
743
744
745
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
746
747
748
749

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

750
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) {
751
752
753
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
754
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 1 positional argument but %d were given", n_args));
755
756
757
758
759
760
761
    }

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

762
const mp_obj_type_t mp_type_staticmethod = {
763
    { &mp_type_type },
764
    .name = MP_QSTR_staticmethod,
765
    .make_new = static_class_method_make_new
766
767
768
};

const mp_obj_type_t mp_type_classmethod = {
769
    { &mp_type_type },
770
    .name = MP_QSTR_classmethod,
771
    .make_new = static_class_method_make_new
772
};