objtype.c 23 KB
Newer Older
1
2
#include <string.h>
#include <assert.h>
3
4
5
6

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
7
#include "qstr.h"
8
#include "obj.h"
9
#include "runtime0.h"
10
11
12
13
14
15
16
17
18
#include "runtime.h"

/******************************************************************************/
// 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;
Damien George's avatar
Damien George committed
19
    // TODO maybe cache __getattr__ and __setattr__ for efficient lookup of them
20
21
} mp_obj_class_t;

22
STATIC mp_obj_t mp_obj_new_class(mp_obj_t class) {
23
24
25
26
27
28
    mp_obj_class_t *o = m_new_obj(mp_obj_class_t);
    o->base.type = class;
    mp_map_init(&o->members, 0);
    return o;
}

29
// will return MP_OBJ_NULL if not found
30
STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) {
31
    for (;;) {
32
        if (type->locals_dict != NULL) {
33
            // search locals_dict (the set of methods/attributes)
34
            assert(MP_OBJ_IS_TYPE(type->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
35
            mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict);
36
37
38
39
            mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
            if (elem != NULL) {
                return elem->value;
            }
40
41
42
43
44
        }

        // attribute not found, keep searching base classes

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

        uint len;
        mp_obj_t *items;
51
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
52
        if (len == 0) {
53
            return MP_OBJ_NULL;
54
55
        }
        for (uint i = 0; i < len - 1; i++) {
56
            assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
57
58
59
            mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
            if (obj != MP_OBJ_NULL) {
                return obj;
60
61
62
63
            }
        }

        // search last base (simple tail recursion elimination)
64
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_type_type));
65
        type = (mp_obj_type_t*)items[len - 1];
66
67
68
    }
}

69
STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
70
71
72
73
74
75
76
77
78
    mp_obj_class_t *self = self_in;
    qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
    mp_obj_t member = mp_obj_class_lookup(self->base.type, meth);
    if (member == MP_OBJ_NULL && kind == PRINT_STR) {
        // If there's no __str__, fall back to __repr__
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___repr__);
    }

    if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
79
        mp_obj_t r = mp_call_function_1(member, self_in);
80
81
82
83
84
        mp_obj_print_helper(print, env, r, PRINT_STR);
        return;
    }

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

88
STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
89
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
90
    mp_obj_type_t *self = self_in;
91
92
93
94

    mp_obj_t o = mp_obj_new_class(self_in);

    // look for __init__ function
95
    mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__);
96

97
    if (init_fn != MP_OBJ_NULL) {
98
99
        // call __init__ function
        mp_obj_t init_ret;
100
        if (n_args == 0 && n_kw == 0) {
Damien George's avatar
Damien George committed
101
            init_ret = mp_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
102
        } else {
103
104
105
            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
106
            init_ret = mp_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
107
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
108
109
        }
        if (init_ret != mp_const_none) {
110
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
111
112
113
114
115
        }

    } else {
        // TODO
        if (n_args != 0) {
116
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 0 positional arguments but %d were given", n_args));
117
118
119
120
121
122
        }
    }

    return o;
}

123
STATIC const qstr unary_op_method_name[] = {
Damien George's avatar
Damien George committed
124
125
126
127
128
129
    [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
130
131
};

132
STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
133
134
135
    mp_obj_class_t *self = self_in;
    qstr op_name = unary_op_method_name[op];
    if (op_name == 0) {
136
        return MP_OBJ_NOT_SUPPORTED;
137
138
139
    }
    mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name);
    if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
140
        return mp_call_function_1(member, self_in);
141
    } else {
142
        return MP_OBJ_NOT_SUPPORTED;
143
144
145
    }
}

146
STATIC const qstr binary_op_method_name[] = {
147
    /*
Damien George's avatar
Damien George committed
148
149
150
151
152
    MP_BINARY_OP_OR,
    MP_BINARY_OP_XOR,
    MP_BINARY_OP_AND,
    MP_BINARY_OP_LSHIFT,
    MP_BINARY_OP_RSHIFT,
153
    */
Damien George's avatar
Damien George committed
154
155
    [MP_BINARY_OP_ADD] = MP_QSTR___add__,
    [MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
156
    /*
Damien George's avatar
Damien George committed
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
    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,
182
    */
Damien George's avatar
Damien George committed
183
    [MP_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
184
185
};

186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
// 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;
    }
}

208
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
209
210
    // Note: For ducktyping, CPython does not look in the instance members or use
    // __getattr__ or __getattribute__.  It only looks in the class dictionary.
211
    mp_obj_class_t *lhs = lhs_in;
212
213
    qstr op_name = binary_op_method_name[op];
    if (op_name == 0) {
214
        return MP_OBJ_NOT_SUPPORTED;
215
    }
216
    mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name);
217
    if (member != MP_OBJ_NULL) {
218
219
220
221
222
        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);
223
    } else {
224
        return MP_OBJ_NOT_SUPPORTED;
225
226
227
    }
}

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

232
233
234
    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
235
        // TODO should we check for properties?
236
        dest[0] = elem->value;
237
238
        return;
    }
239

240
241
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    if (member != MP_OBJ_NULL) {
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
        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
260
261
262
263
264
265
266
267
268
269
270
271
        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);
272
273
274
275
276
            return;
        }
    }
}

277
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
278
    mp_obj_class_t *self = self_in;
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298

#if MICROPY_ENABLE_PROPERTY
    // for property, we need to do a lookup first in the class dict
    // this makes all stores slow... how to fix?
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    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

299
300
    if (value == MP_OBJ_NULL) {
        // delete attribute
301
302
        mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
        return elem != NULL;
303
304
305
306
307
    } else {
        // store attribute
        mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
        return true;
    }
308
309
}

310
STATIC mp_obj_t class_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
311
312
313
    mp_obj_class_t *self = self_in;
    mp_obj_t member;
    uint meth_args;
314
315
    if (value == MP_OBJ_NULL) {
        // delete item
316
317
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___delitem__);
        meth_args = 2;
318
319
320
321
    } else if (value == MP_OBJ_SENTINEL) {
        // load item
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___getitem__);
        meth_args = 2;
322
    } else {
323
        // store item
324
325
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
        meth_args = 3;
326
    }
327
    if (member != MP_OBJ_NULL) {
328
        mp_obj_t args[3] = {self_in, index, value};
329
330
331
332
333
334
335
        // 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;
        }
336
    } else {
337
        return MP_OBJ_NOT_SUPPORTED;
338
339
340
    }
}

341
342
343
344
345
346
347
348
349
350
STATIC mp_obj_t class_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
    mp_obj_class_t *self = self_in;
    mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___call__);
    if (member == MP_OBJ_NULL) {
        return member;
    }
    mp_obj_t meth = mp_obj_new_bound_meth(member, self);
    return mp_call_function_n_kw(meth, n_args, n_kw, args);
}

351
352
353
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
354
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
355
//  - creating a new class (a new type) creates a new mp_obj_type_t
356

357
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
358
    mp_obj_type_t *self = self_in;
359
    print(env, "<class '%s'>", qstr_str(self->name));
360
361
}

362
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
363
364
    // TODO check n_kw == 0

365
366
367
368
369
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
370
            // args[0] = name
371
            // args[1] = bases tuple
372
            // args[2] = locals dict
373
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
374
375

        default:
376
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
377
378
379
    }
}

380
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
381
382
    // instantiate an instance of a class

383
    mp_obj_type_t *self = self_in;
384
385

    if (self->make_new == NULL) {
386
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
387
    }
388
389

    // make new instance
390
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
391
392
393
394
395

    // return new instance
    return o;
}

396
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
397
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
398
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
399
    mp_obj_type_t *self = self_in;
400
#if MICROPY_CPYTHON_COMPAT
401
402
403
404
    if (attr == MP_QSTR___name__) {
        dest[0] = MP_OBJ_NEW_QSTR(self->name);
        return;
    }
405
#endif
406
407
408
409
410
411
    mp_obj_t member = mp_obj_class_lookup(self, attr);
    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
412
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
413
414
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
415
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
416
417
418
419
420
            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;
421
422
        }
    }
423
424
}

425
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
426
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
427
428
    mp_obj_type_t *self = self_in;

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

431
    if (self->locals_dict != NULL) {
432
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
433
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
434
435
436
437
438
439
440
441
442
443
444
445
446
        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;
            }
447
        }
448
    }
449
450

    return false;
451
452
}

453
454
455
456
457
458
459
460
461
462
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;
}

463
464
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
465
    .name = MP_QSTR_type,
466
    .print = type_print,
467
    .make_new = type_make_new,
468
    .call = type_call,
469
470
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
471
    .binary_op = type_binary_op,
472
};
473

474
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
475
    assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
476
    assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
477
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
478
    o->base.type = &mp_type_type;
479
    o->name = name;
480
481
    o->print = class_print;
    o->make_new = class_make_new;
482
    o->unary_op = class_unary_op;
483
    o->binary_op = class_binary_op;
484
485
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
486
    o->subscr = class_subscr;
487
    o->call = class_call;
488
489
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
490
491
    return o;
}
492
493

/******************************************************************************/
Damien George's avatar
Damien George committed
494
495
496
497
498
499
500
501
// 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;

502
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
503
504
505
506
507
508
509
510
    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, ">");
}

511
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
512
513
514
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
515
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
516
517
518
519
520
    }
    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
521
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
522
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
Damien George's avatar
Damien George committed
523
524
    mp_obj_super_t *self = self_in;

525
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
526
527
528
529
530
531
532
533
534
535
536
537

    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++) {
538
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
Damien George's avatar
Damien George committed
539
540
        mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
        if (member != MP_OBJ_NULL) {
541
            class_convert_return_attr(self->obj, member, dest);
542
            return;
Damien George's avatar
Damien George committed
543
544
545
546
        }
    }
}

547
const mp_obj_type_t mp_type_super = {
548
    { &mp_type_type },
549
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
550
551
552
553
554
555
556
    .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);
557
    *o = (mp_obj_super_t){{&mp_type_super}, type, obj};
Damien George's avatar
Damien George committed
558
559
560
561
    return o;
}

/******************************************************************************/
562
// subclassing and built-ins specific to types
563

564
565
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
566
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
567
568
    for (;;) {
        if (object == classinfo) {
569
            return true;
570
571
572
573
        }

        // not equivalent classes, keep searching base classes

574
575
576
577
578
        // 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;
        }

579
        const mp_obj_type_t *self = object;
580
581
582

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

586
        // get the base objects (they should be type objects)
587
588
589
590
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
591
            return false;
592
        }
593
594

        // iterate through the base objects
595
        for (uint i = 0; i < len - 1; i++) {
596
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
597
                return true;
598
599
600
601
602
603
604
605
            }
        }

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

606
607
608
609
610
611
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;
612
    } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
613
614
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
615
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
616
617
    }

618
    for (uint i = 0; i < len; i++) {
619
620
        // 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])) {
621
622
            return mp_const_true;
        }
623
    }
624
    return mp_const_false;
625
626
}

627
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
628
    if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
629
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class"));
630
631
    }
    return mp_obj_is_subclass(object, classinfo);
632
633
}

634
635
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

636
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
637
    return mp_obj_is_subclass(mp_obj_get_type(object), classinfo);
638
639
640
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
641
642
643
644

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

645
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) {
646
647
648
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
649
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 1 positional argument but %d were given", n_args));
650
651
652
653
654
655
656
    }

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

657
const mp_obj_type_t mp_type_staticmethod = {
658
    { &mp_type_type },
659
    .name = MP_QSTR_staticmethod,
660
    .make_new = static_class_method_make_new
661
662
663
};

const mp_obj_type_t mp_type_classmethod = {
664
    { &mp_type_type },
665
    .name = MP_QSTR_classmethod,
666
    .make_new = static_class_method_make_new
667
};