objtype.c 20 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_jump(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_jump(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
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
188
    mp_obj_class_t *lhs = lhs_in;
189
190
    qstr op_name = binary_op_method_name[op];
    if (op_name == 0) {
191
192
        return MP_OBJ_NULL;
    }
193
    mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name);
194
    if (member != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
195
        return mp_call_function_2(member, lhs_in, rhs_in);
196
197
198
199
200
    } else {
        return MP_OBJ_NULL;
    }
}

201
STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
202
203
204
205
206
    // 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
207
        dest[0] = elem->value;
208
209
        return;
    }
210
211
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    if (member != MP_OBJ_NULL) {
212
213
214
215
216
217
218
219
220
221
222
223
224
225
        // check if the methods are functions, static or class methods
        // see http://docs.python.org/3.3/howto/descriptor.html
        // TODO check that this is the correct place to have this logic
        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_in);
        } else if (mp_obj_is_callable(member)) {
            // return a bound method, with self being this object
            dest[0] = member;
            dest[1] = self_in;
226
227
        } else {
            // class member is a value, so just return that value
228
            dest[0] = member;
Damien George's avatar
Damien George committed
229
230
231
232
233
234
235
236
237
238
239
240
241
        }
        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);
242
243
244
245
246
            return;
        }
    }
}

247
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
248
    mp_obj_class_t *self = self_in;
249
    mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
250
251
252
    return true;
}

253
254
bool class_store_item(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
    mp_obj_class_t *self = self_in;
255
    mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
256
    if (member != MP_OBJ_NULL) {
257
        mp_obj_t args[3] = {self_in, index, value};
Damien George's avatar
Damien George committed
258
        mp_call_function_n_kw(member, 3, 0, args);
259
        return true;
260
    } else {
261
        return false;
262
263
264
    }
}

265
266
267
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
268
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
269
//  - creating a new class (a new type) creates a new mp_obj_type_t
270

271
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
272
    mp_obj_type_t *self = self_in;
273
    print(env, "<class '%s'>", qstr_str(self->name));
274
275
}

276
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
277
278
    // TODO check n_kw == 0

279
280
281
282
283
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
284
            // args[0] = name
285
            // args[1] = bases tuple
286
            // args[2] = locals dict
287
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
288
289

        default:
290
            nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
291
292
293
    }
}

294
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
295
296
    // instantiate an instance of a class

297
    mp_obj_type_t *self = self_in;
298
299

    if (self->make_new == NULL) {
300
        nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
301
    }
302
303

    // make new instance
304
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
305
306
307
308
309

    // return new instance
    return o;
}

310
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
311
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
312
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
313
    mp_obj_type_t *self = self_in;
314
#if MICROPY_CPYTHON_COMPAT
315
316
317
318
    if (attr == MP_QSTR___name__) {
        dest[0] = MP_OBJ_NEW_QSTR(self->name);
        return;
    }
319
#endif
320
321
322
323
324
325
    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
326
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
327
328
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
329
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
330
331
332
333
334
            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;
335
336
        }
    }
337
338
}

339
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
340
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
341
342
    mp_obj_type_t *self = self_in;

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

345
    if (self->locals_dict != NULL) {
346
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
347
348
349
350
351
352
353
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
        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;
        }
354
    }
355
356

    return false;
357
358
}

359
360
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
361
    .name = MP_QSTR_type,
362
    .print = type_print,
363
    .make_new = type_make_new,
364
    .call = type_call,
365
366
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
367
};
368

369
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
370
    assert(MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)); // Micro Python restriction, for now
371
    assert(MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)); // Micro Python restriction, for now
372
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
373
    o->base.type = &mp_type_type;
374
    o->name = name;
375
376
    o->print = class_print;
    o->make_new = class_make_new;
377
    o->unary_op = class_unary_op;
378
    o->binary_op = class_binary_op;
379
380
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
381
    o->store_item = class_store_item;
382
383
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
384
385
    return o;
}
386
387

/******************************************************************************/
Damien George's avatar
Damien George committed
388
389
390
391
392
393
394
395
// 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;

396
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
397
398
399
400
401
402
403
404
    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, ">");
}

405
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
406
407
408
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
409
        nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
410
411
412
413
414
    }
    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
415
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
416
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_super));
Damien George's avatar
Damien George committed
417
418
    mp_obj_super_t *self = self_in;

419
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
420
421
422
423
424
425
426
427
428
429
430
431

    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++) {
432
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
Damien George's avatar
Damien George committed
433
434
435
        mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
        if (member != MP_OBJ_NULL) {
            // XXX this and the code in class_load_attr need to be factored out
436
437
438
439
440
441
442
443
444
445
446
447
448
449
            // check if the methods are functions, static or class methods
            // see http://docs.python.org/3.3/howto/descriptor.html
            // TODO check that this is the correct place to have this logic
            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->obj);
            } if (mp_obj_is_callable(member)) {
                // return a bound method, with self being this object
                dest[0] = member;
                dest[1] = self->obj;
Damien George's avatar
Damien George committed
450
451
452
453
            } else {
                // class member is a value, so just return that value
                dest[0] = member;
            }
454
            return;
Damien George's avatar
Damien George committed
455
456
457
458
        }
    }
}

459
const mp_obj_type_t mp_type_super = {
460
    { &mp_type_type },
461
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
462
463
464
465
466
467
468
    .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);
469
    *o = (mp_obj_super_t){{&mp_type_super}, type, obj};
Damien George's avatar
Damien George committed
470
471
472
473
    return o;
}

/******************************************************************************/
474
// subclassing and built-ins specific to types
475

476
477
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
478
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
479
480
    for (;;) {
        if (object == classinfo) {
481
            return true;
482
483
484
485
        }

        // not equivalent classes, keep searching base classes

486
487
488
489
490
        // 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;
        }

491
        const mp_obj_type_t *self = object;
492
493
494

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

498
        // get the base objects (they should be type objects)
499
500
501
502
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
503
            return false;
504
        }
505
506

        // iterate through the base objects
507
        for (uint i = 0; i < len - 1; i++) {
508
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
509
                return true;
510
511
512
513
514
515
516
517
            }
        }

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

518
519
520
521
522
523
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;
524
    } else if (MP_OBJ_IS_TYPE(classinfo, &mp_type_tuple)) {
525
526
527
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
        nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
528
529
    }

530
531
532
533
    for (uint i = 0; i < len; i++) {
        if (mp_obj_is_subclass_fast(object, items[i])) {
            return mp_const_true;
        }
534
    }
535
    return mp_const_false;
536
537
}

538
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
539
540
541
542
    if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
        nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class"));
    }
    return mp_obj_is_subclass(object, classinfo);
543
544
}

545
546
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

547
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
548
    return mp_obj_is_subclass(mp_obj_get_type(object), classinfo);
549
550
551
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
552
553
554
555

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

556
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) {
557
558
559
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
560
        nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 1 positional argument but %d were given", n_args));
561
562
563
564
565
566
567
    }

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

568
const mp_obj_type_t mp_type_staticmethod = {
569
    { &mp_type_type },
570
    .name = MP_QSTR_staticmethod,
571
    .make_new = static_class_method_make_new
572
573
574
};

const mp_obj_type_t mp_type_classmethod = {
575
    { &mp_type_type },
576
    .name = MP_QSTR_classmethod,
577
    .make_new = static_class_method_make_new
578
};