objtype.c 14.7 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
24
25
26
27
28
29
30
#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;

static mp_obj_t mp_obj_new_class(mp_obj_t class) {
    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
32
// will return MP_OBJ_NULL if not found
static mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) {
33
    for (;;) {
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
        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
            mp_map_t *locals_map = ((void*)type->locals_dict + sizeof(mp_obj_base_t)); // XXX hack to get map object from dict object
            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
106
107
108
109
110
111
112
113
114
115
116
117
118
        }
        if (init_ret != mp_const_none) {
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
        }

    } else {
        // TODO
        if (n_args != 0) {
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "function takes 0 positional arguments but %d were given", (void*)(machine_int_t)n_args));
        }
    }

    return o;
}

119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
static const qstr unary_op_method_name[] = {
    [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,
    [RT_UNARY_OP_NOT] = MP_QSTR_, // not implemented, used to make sure array has full size
};

static mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
    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
143
static const qstr binary_op_method_name[] = {
    [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
171
172
173
174
175
176
177
178
179
180
181
    /*
    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,
    RT_COMPARE_OP_LESS,
    RT_COMPARE_OP_MORE,
    RT_COMPARE_OP_EQUAL,
    RT_COMPARE_OP_LESS_EQUAL,
    RT_COMPARE_OP_MORE_EQUAL,
    RT_COMPARE_OP_NOT_EQUAL,
    RT_COMPARE_OP_IN,
    RT_COMPARE_OP_NOT_IN,
    RT_COMPARE_OP_IS,
    RT_COMPARE_OP_IS_NOT,
    */
182
    [RT_COMPARE_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
183
184
185
186
};

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

199
200
201
202
203
204
static void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
    // 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
205
        dest[0] = elem->value;
206
207
        return;
    }
208
209
210
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    if (member != MP_OBJ_NULL) {
        if (mp_obj_is_callable(member)) {
211
            // class member is callable so build a bound method
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
            // 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_staticmethod_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_classmethod_t*)member)->fun;
                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;
            }
227
228
229
            return;
        } else {
            // class member is a value, so just return that value
230
            dest[0] = member;
231
232
233
234
235
236
237
            return;
        }
    }
}

static bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
    mp_obj_class_t *self = self_in;
238
    mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
239
240
241
    return true;
}

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

254
255
256
257
258
/******************************************************************************/
// 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
259

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

265
266
267
static mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
    // TODO check n_kw == 0

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

        case 3:
273
            // args[0] = name
274
            // args[1] = bases tuple
275
            // args[2] = locals dict
276
            return mp_obj_new_type(mp_obj_str_get_str(args[0]), args[1], args[2]);
277
278
279
280
281
282

        default:
            nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "type takes at 1 or 3 arguments"));
    }
}

283
static mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
284
285
    // instantiate an instance of a class

286
    mp_obj_type_t *self = self_in;
287
288

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

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

    // return new instance
    return o;
}

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

static bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
323
324
325
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
    mp_obj_type_t *self = self_in;

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

328
329
330
331
    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;
332
333
334
335
        return true;
    } else {
        return false;
    }
336
337
338
339
}

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

348
mp_obj_t mp_obj_new_type(const char *name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
349
350
    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
351
352
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
    o->base.type = &mp_const_type;
353
    o->name = name;
354
355
    o->print = class_print;
    o->make_new = class_make_new;
356
    o->unary_op = class_unary_op;
357
    o->binary_op = class_binary_op;
358
359
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
360
    o->store_item = class_store_item;
361
362
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
363
364
    return o;
}
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
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

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

static mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
    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);

static mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
    return mp_builtin_issubclass(mp_obj_get_type(object), classinfo);
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
418
419
420
421
422
423
424
425
426
427
428
429
430

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

const mp_obj_type_t mp_type_staticmethod = {
    { &mp_const_type },
    "staticmethod",
};

const mp_obj_type_t mp_type_classmethod = {
    { &mp_const_type },
    "classmethod",
};