objtype.c 18.5 KB
Newer Older
1
2
#include <stdlib.h>
#include <stdint.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 "map.h"
12
#include "runtime0.h"
13
14
15
16
17
18
19
20
21
22
23
#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;
} mp_obj_class_t;

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

31
// will return MP_OBJ_NULL if not found
32
STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) {
33
    for (;;) {
34
35
36
37
        if (type->locals_dict != NULL) {
            // search locals_dict (the dynamically created set of methods/attributes)

            assert(MP_OBJ_IS_TYPE(type->locals_dict, &dict_type)); // Micro Python restriction, for now
38
            mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict);
39
40
41
42
43
44
45
46
47
48
49
50
            mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
            if (elem != NULL) {
                return elem->value;
            }
        } else if (type->methods != NULL) {
            // search methods (the const set of methods)

            for (const mp_method_t *meth = type->methods; meth->name != NULL; meth++) {
                if (strcmp(meth->name, qstr_str(attr)) == 0) {
                    return (mp_obj_t)meth->fun;
                }
            }
51
52
53
54
55
        }

        // attribute not found, keep searching base classes

        // for a const struct, this entry might be NULL
56
        if (type->bases_tuple == MP_OBJ_NULL) {
57
58
59
60
61
            return NULL;
        }

        uint len;
        mp_obj_t *items;
62
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
63
64
65
66
        if (len == 0) {
            return NULL;
        }
        for (uint i = 0; i < len - 1; i++) {
67
            assert(MP_OBJ_IS_TYPE(items[i], &mp_const_type));
68
69
70
            mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
            if (obj != MP_OBJ_NULL) {
                return obj;
71
72
73
74
            }
        }

        // search last base (simple tail recursion elimination)
75
76
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_const_type));
        type = (mp_obj_type_t*)items[len - 1];
77
78
79
    }
}

80
STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
81
82
83
    print(env, "<%s object at %p>", mp_obj_get_type_str(self_in), self_in);
}

84
STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
85
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
86
    mp_obj_type_t *self = self_in;
87
88
89
90

    mp_obj_t o = mp_obj_new_class(self_in);

    // look for __init__ function
91
    mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__);
92

93
    if (init_fn != MP_OBJ_NULL) {
94
95
        // call __init__ function
        mp_obj_t init_ret;
96
        if (n_args == 0 && n_kw == 0) {
97
            init_ret = rt_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
98
        } else {
99
100
101
            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));
102
            init_ret = rt_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
103
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
104
105
        }
        if (init_ret != mp_const_none) {
106
            nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
107
108
109
110
111
        }

    } else {
        // TODO
        if (n_args != 0) {
112
            nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "function takes 0 positional arguments but %d were given", n_args));
113
114
115
116
117
118
        }
    }

    return o;
}

119
STATIC const qstr unary_op_method_name[] = {
120
121
122
123
124
    [RT_UNARY_OP_BOOL] = MP_QSTR___bool__,
    [RT_UNARY_OP_LEN] = MP_QSTR___len__,
    //[RT_UNARY_OP_POSITIVE,
    //[RT_UNARY_OP_NEGATIVE,
    //[RT_UNARY_OP_INVERT,
125
    [RT_UNARY_OP_NOT] = MP_QSTR_, // don't need to implement this, used to make sure array has full size
126
127
};

128
STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
129
130
131
132
133
134
135
136
137
138
139
140
141
    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) {
        return rt_call_function_1(member, self_in);
    } else {
        return MP_OBJ_NULL;
    }
}

142
STATIC const qstr binary_op_method_name[] = {
143
    [RT_BINARY_OP_SUBSCR] = MP_QSTR___getitem__,
144
145
146
147
148
149
150
    /*
    RT_BINARY_OP_OR,
    RT_BINARY_OP_XOR,
    RT_BINARY_OP_AND,
    RT_BINARY_OP_LSHIFT,
    RT_BINARY_OP_RSHIFT,
    */
151
152
    [RT_BINARY_OP_ADD] = MP_QSTR___add__,
    [RT_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
    /*
    RT_BINARY_OP_MULTIPLY,
    RT_BINARY_OP_FLOOR_DIVIDE,
    RT_BINARY_OP_TRUE_DIVIDE,
    RT_BINARY_OP_MODULO,
    RT_BINARY_OP_POWER,
    RT_BINARY_OP_INPLACE_OR,
    RT_BINARY_OP_INPLACE_XOR,
    RT_BINARY_OP_INPLACE_AND,
    RT_BINARY_OP_INPLACE_LSHIFT,
    RT_BINARY_OP_INPLACE_RSHIFT,
    RT_BINARY_OP_INPLACE_ADD,
    RT_BINARY_OP_INPLACE_SUBTRACT,
    RT_BINARY_OP_INPLACE_MULTIPLY,
    RT_BINARY_OP_INPLACE_FLOOR_DIVIDE,
    RT_BINARY_OP_INPLACE_TRUE_DIVIDE,
    RT_BINARY_OP_INPLACE_MODULO,
    RT_BINARY_OP_INPLACE_POWER,
171
172
173
174
175
176
177
178
    RT_BINARY_OP_LESS,
    RT_BINARY_OP_MORE,
    RT_BINARY_OP_EQUAL,
    RT_BINARY_OP_LESS_EQUAL,
    RT_BINARY_OP_MORE_EQUAL,
    RT_BINARY_OP_NOT_EQUAL,
    RT_BINARY_OP_IN,
    RT_BINARY_OP_IS,
179
    */
180
    [RT_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
181
182
};

183
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
184
    mp_obj_class_t *lhs = lhs_in;
185
186
    qstr op_name = binary_op_method_name[op];
    if (op_name == 0) {
187
188
        return MP_OBJ_NULL;
    }
189
    mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name);
190
191
    if (member != MP_OBJ_NULL) {
        return rt_call_function_2(member, lhs_in, rhs_in);
192
193
194
195
196
    } else {
        return MP_OBJ_NULL;
    }
}

197
STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
198
199
200
201
202
    // 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
203
        dest[0] = elem->value;
204
205
        return;
    }
206
207
208
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    if (member != MP_OBJ_NULL) {
        if (mp_obj_is_callable(member)) {
209
            // class member is callable so build a bound method
210
211
212
213
214
            // 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
215
                dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
216
217
            } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
                // return a bound method, with self being the type of this object
218
                dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
219
220
221
222
223
224
                dest[1] = mp_obj_get_type(self_in);
            } else {
                // return a bound method, with self being this object
                dest[0] = member;
                dest[1] = self_in;
            }
225
226
227
            return;
        } else {
            // class member is a value, so just return that value
228
            dest[0] = member;
229
230
231
232
233
            return;
        }
    }
}

234
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
235
    mp_obj_class_t *self = self_in;
236
    mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
237
238
239
    return true;
}

240
241
bool class_store_item(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
    mp_obj_class_t *self = self_in;
242
    mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
243
    if (member != MP_OBJ_NULL) {
244
        mp_obj_t args[3] = {self_in, index, value};
245
246
        rt_call_function_n_kw(member, 3, 0, args);
        return true;
247
    } else {
248
        return false;
249
250
251
    }
}

252
253
254
255
256
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
//  - there is a constant mp_obj_type_t (called mp_const_type) for the 'type' object
//  - creating a new class (a new type) creates a new mp_obj_type_t
257

258
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
259
260
261
262
    mp_obj_type_t *self = self_in;
    print(env, "<class '%s'>", self->name);
}

263
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
264
265
    // TODO check n_kw == 0

266
267
268
269
270
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
271
            // args[0] = name
272
            // args[1] = bases tuple
273
            // args[2] = locals dict
274
            return mp_obj_new_type(mp_obj_str_get_str(args[0]), args[1], args[2]);
275
276

        default:
277
            nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "type takes 1 or 3 arguments"));
278
279
280
    }
}

281
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
282
283
    // instantiate an instance of a class

284
    mp_obj_type_t *self = self_in;
285
286

    if (self->make_new == NULL) {
287
        nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "cannot create '%s' instances", self->name));
288
    }
289
290

    // make new instance
291
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
292
293
294
295
296

    // return new instance
    return o;
}

297
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
298
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
299
300
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
    mp_obj_type_t *self = self_in;
301
302
303
304
305
306
    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
307
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
308
309
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
310
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
311
312
313
314
315
            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;
316
317
        }
    }
318
319
}

320
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
321
322
323
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
    mp_obj_type_t *self = self_in;

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

326
327
328
329
    if (self->locals_dict != NULL) {
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &dict_type)); // Micro Python restriction, for now
        mp_map_t *locals_map = ((void*)self->locals_dict + sizeof(mp_obj_base_t)); // XXX hack to get map object from dict object
        mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
330
331
332
333
        return true;
    } else {
        return false;
    }
334
335
336
337
}

const mp_obj_type_t mp_const_type = {
    { &mp_const_type },
338
    "type",
339
    .print = type_print,
340
    .make_new = type_make_new,
341
    .call = type_call,
342
343
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
344
};
345

346
mp_obj_t mp_obj_new_type(const char *name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
347
348
    assert(MP_OBJ_IS_TYPE(bases_tuple, &tuple_type)); // Micro Python restriction, for now
    assert(MP_OBJ_IS_TYPE(locals_dict, &dict_type)); // Micro Python restriction, for now
349
350
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
    o->base.type = &mp_const_type;
351
    o->name = name;
352
353
    o->print = class_print;
    o->make_new = class_make_new;
354
    o->unary_op = class_unary_op;
355
    o->binary_op = class_binary_op;
356
357
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
358
    o->store_item = class_store_item;
359
360
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
361
362
    return o;
}
363
364

/******************************************************************************/
Damien George's avatar
Damien George committed
365
366
367
368
369
370
371
372
// 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;

373
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
374
375
376
377
378
379
380
381
    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, ">");
}

382
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
383
384
385
386
387
388
389
390
391
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "super() requires 2 arguments"));
    }
    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
392
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
Damien George's avatar
Damien George committed
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
    assert(MP_OBJ_IS_TYPE(self_in, &super_type));
    mp_obj_super_t *self = self_in;

    assert(MP_OBJ_IS_TYPE(self->type, &mp_const_type));

    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++) {
        assert(MP_OBJ_IS_TYPE(items[i], &mp_const_type));
        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
            if (mp_obj_is_callable(member)) {
                // class member is callable so build a bound method
                // 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
420
                    dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
Damien George's avatar
Damien George committed
421
422
                } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
                    // return a bound method, with self being the type of this object
423
                    dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
Damien George's avatar
Damien George committed
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
                    dest[1] = mp_obj_get_type(self->obj);
                } else {
                    // return a bound method, with self being this object
                    dest[0] = member;
                    dest[1] = self->obj;
                }
                return;
            } else {
                // class member is a value, so just return that value
                dest[0] = member;
                return;
            }
        }
    }
}

const mp_obj_type_t super_type = {
    { &mp_const_type },
    "super",
    .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);
    *o = (mp_obj_super_t){{&super_type}, type, obj};
    return o;
}

/******************************************************************************/
455
456
// built-ins specific to types

457
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
    if (!MP_OBJ_IS_TYPE(object, &mp_const_type)) {
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "issubclass() arg 1 must be a class"));
    }

    // TODO support a tuple of classes for second argument
    if (!MP_OBJ_IS_TYPE(classinfo, &mp_const_type)) {
        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "issubclass() arg 2 must be a class"));
    }

    for (;;) {
        if (object == classinfo) {
            return mp_const_true;
        }

        // not equivalent classes, keep searching base classes

        assert(MP_OBJ_IS_TYPE(object, &mp_const_type));
        mp_obj_type_t *self = object;

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

        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
            return mp_const_false;
        }
        for (uint i = 0; i < len - 1; i++) {
            if (mp_builtin_issubclass(items[i], classinfo) == mp_const_true) {
                return mp_const_true;
            }
        }

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

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

501
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
502
503
504
505
    return mp_builtin_issubclass(mp_obj_get_type(object), classinfo);
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
506
507
508
509

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

510
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) {
511
512
513
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
514
        nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "function takes 1 positional argument but %d were given", n_args));
515
516
517
518
519
520
521
    }

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

522
523
524
const mp_obj_type_t mp_type_staticmethod = {
    { &mp_const_type },
    "staticmethod",
525
    .make_new = static_class_method_make_new
526
527
528
529
530
};

const mp_obj_type_t mp_type_classmethod = {
    { &mp_const_type },
    "classmethod",
531
    .make_new = static_class_method_make_new
532
};