objtype.c 20.7 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
47
48
49
50
            return NULL;
        }

        uint len;
        mp_obj_t *items;
51
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
52
53
54
55
        if (len == 0) {
            return NULL;
        }
        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
136
137
138
139
    mp_obj_class_t *self = self_in;
    qstr op_name = unary_op_method_name[op];
    if (op_name == 0) {
        return MP_OBJ_NULL;
    }
    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
142
143
144
145
    } else {
        return MP_OBJ_NULL;
    }
}

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

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

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

229
STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
230
231
232
233
234
    // logic: look in obj members then class locals (TODO check this against CPython)
    mp_obj_class_t *self = self_in;
    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
        dest[0] = elem->value;
236
237
        return;
    }
238
239
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    if (member != MP_OBJ_NULL) {
240
        class_convert_return_attr(self_in, member, dest);
Damien George's avatar
Damien George committed
241
242
243
244
245
246
247
248
249
250
251
252
        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);
253
254
255
256
257
            return;
        }
    }
}

258
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
259
    mp_obj_class_t *self = self_in;
260
261
262
263
264
265
266
267
268
    if (value == MP_OBJ_NULL) {
        // delete attribute
        mp_map_elem_t *el = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
        return el != NULL;
    } else {
        // store attribute
        mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
        return true;
    }
269
270
}

271
bool class_store_item(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
272
273
274
275
276
    if (value == MP_OBJ_NULL) {
        // delete item
        // TODO implement me!
        return false;
    }
277
    mp_obj_class_t *self = self_in;
278
    mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
279
    if (member != MP_OBJ_NULL) {
280
        mp_obj_t args[3] = {self_in, index, value};
Damien George's avatar
Damien George committed
281
        mp_call_function_n_kw(member, 3, 0, args);
282
        return true;
283
    } else {
284
        return false;
285
286
287
    }
}

288
289
290
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
291
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
292
//  - creating a new class (a new type) creates a new mp_obj_type_t
293

294
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
295
    mp_obj_type_t *self = self_in;
296
    print(env, "<class '%s'>", qstr_str(self->name));
297
298
}

299
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
300
301
    // TODO check n_kw == 0

302
303
304
305
306
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
307
            // args[0] = name
308
            // args[1] = bases tuple
309
            // args[2] = locals dict
310
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
311
312

        default:
313
            nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
314
315
316
    }
}

317
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
318
319
    // instantiate an instance of a class

320
    mp_obj_type_t *self = self_in;
321
322

    if (self->make_new == NULL) {
323
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
324
    }
325
326

    // make new instance
327
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
328
329
330
331
332

    // return new instance
    return o;
}

333
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
334
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
335
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
336
    mp_obj_type_t *self = self_in;
337
#if MICROPY_CPYTHON_COMPAT
338
339
340
341
    if (attr == MP_QSTR___name__) {
        dest[0] = MP_OBJ_NEW_QSTR(self->name);
        return;
    }
342
#endif
343
344
345
346
347
348
    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
349
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
350
351
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
352
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
353
354
355
356
357
            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;
358
359
        }
    }
360
361
}

362
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
363
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
364
365
    mp_obj_type_t *self = self_in;

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

368
    if (self->locals_dict != NULL) {
369
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
370
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
371
372
373
374
375
376
377
378
379
380
381
382
383
        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;
            }
384
        }
385
    }
386
387

    return false;
388
389
}

390
391
392
393
394
395
396
397
398
399
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;
}

400
401
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
402
    .name = MP_QSTR_type,
403
    .print = type_print,
404
    .make_new = type_make_new,
405
    .call = type_call,
406
407
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
408
    .binary_op = type_binary_op,
409
};
410

411
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
412
    assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
413
    assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
414
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
415
    o->base.type = &mp_type_type;
416
    o->name = name;
417
418
    o->print = class_print;
    o->make_new = class_make_new;
419
    o->unary_op = class_unary_op;
420
    o->binary_op = class_binary_op;
421
422
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
423
    o->store_item = class_store_item;
424
425
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
426
427
    return o;
}
428
429

/******************************************************************************/
Damien George's avatar
Damien George committed
430
431
432
433
434
435
436
437
// 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;

438
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
439
440
441
442
443
444
445
446
    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, ">");
}

447
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
448
449
450
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
451
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
452
453
454
455
456
    }
    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
457
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
458
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
Damien George's avatar
Damien George committed
459
460
    mp_obj_super_t *self = self_in;

461
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
462
463
464
465
466
467
468
469
470
471
472
473

    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++) {
474
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
Damien George's avatar
Damien George committed
475
476
        mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
        if (member != MP_OBJ_NULL) {
477
            class_convert_return_attr(self, member, dest);
478
            return;
Damien George's avatar
Damien George committed
479
480
481
482
        }
    }
}

483
const mp_obj_type_t mp_type_super = {
484
    { &mp_type_type },
485
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
486
487
488
489
490
491
492
    .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);
493
    *o = (mp_obj_super_t){{&mp_type_super}, type, obj};
Damien George's avatar
Damien George committed
494
495
496
497
    return o;
}

/******************************************************************************/
498
// subclassing and built-ins specific to types
499

500
501
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
502
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
503
504
    for (;;) {
        if (object == classinfo) {
505
            return true;
506
507
508
509
        }

        // not equivalent classes, keep searching base classes

510
511
512
513
514
        // 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;
        }

515
        const mp_obj_type_t *self = object;
516
517
518

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

522
        // get the base objects (they should be type objects)
523
524
525
526
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
527
            return false;
528
        }
529
530

        // iterate through the base objects
531
        for (uint i = 0; i < len - 1; i++) {
532
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
533
                return true;
534
535
536
537
538
539
540
541
            }
        }

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

542
543
544
545
546
547
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;
548
    } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
549
550
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
551
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
552
553
    }

554
    for (uint i = 0; i < len; i++) {
555
556
        // 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])) {
557
558
            return mp_const_true;
        }
559
    }
560
    return mp_const_false;
561
562
}

563
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
564
    if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
565
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class"));
566
567
    }
    return mp_obj_is_subclass(object, classinfo);
568
569
}

570
571
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

572
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
573
    return mp_obj_is_subclass(mp_obj_get_type(object), classinfo);
574
575
576
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
577
578
579
580

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

581
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) {
582
583
584
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
585
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 1 positional argument but %d were given", n_args));
586
587
588
589
590
591
592
    }

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

593
const mp_obj_type_t mp_type_staticmethod = {
594
    { &mp_type_type },
595
    .name = MP_QSTR_staticmethod,
596
    .make_new = static_class_method_make_new
597
598
599
};

const mp_obj_type_t mp_type_classmethod = {
600
    { &mp_type_type },
601
    .name = MP_QSTR_classmethod,
602
    .make_new = static_class_method_make_new
603
};