objtype.c 11.3 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 "mpqstr.h"
10
#include "obj.h"
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include "map.h"
#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;
}

30
static mp_map_elem_t *mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr, mp_map_lookup_kind_t lookup_kind) {
31
    for (;;) {
32
        if (type->locals_dict == NULL) {
33
34
            return NULL;
        }
35
36
        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
37
38
39
40
41
42
43
44
        mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), lookup_kind);
        if (elem != NULL) {
            return elem;
        }

        // 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
57
            assert(MP_OBJ_IS_TYPE(items[i], &mp_const_type));
            elem = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr, lookup_kind);
58
59
60
61
62
63
            if (elem != NULL) {
                return elem;
            }
        }

        // search last base (simple tail recursion elimination)
64
65
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_const_type));
        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
    print(env, "<%s object at %p>", mp_obj_get_type_str(self_in), self_in);
}

73
static mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
74
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
75
    mp_obj_type_t *self = self_in;
76
77
78
79

    mp_obj_t o = mp_obj_new_class(self_in);

    // look for __init__ function
80
    mp_map_elem_t *init_fn = mp_obj_class_lookup(self, MP_QSTR___init__, MP_MAP_LOOKUP);
81
82
83
84

    if (init_fn != NULL) {
        // call __init__ function
        mp_obj_t init_ret;
85
86
        if (n_args == 0 && n_kw == 0) {
            init_ret = rt_call_function_n_kw(init_fn->value, 1, 0, (mp_obj_t*)&o);
87
        } else {
88
89
90
91
92
            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));
            init_ret = rt_call_function_n_kw(init_fn->value, n_args + 1, n_kw, args2);
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
        }
        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;
}

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
114
        dest[0] = elem->value;
115
116
        return;
    }
117
    elem = mp_obj_class_lookup(self->base.type, attr, MP_MAP_LOOKUP);
118
119
120
    if (elem != NULL) {
        if (mp_obj_is_callable(elem->value)) {
            // class member is callable so build a bound method
121
122
            dest[0] = elem->value;
            dest[1] = self_in;
123
124
125
            return;
        } else {
            // class member is a value, so just return that value
126
            dest[0] = elem->value;
127
128
129
130
131
132
133
134
            return;
        }
    }
}

static bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
    // logic: look in class locals (no add) then obj members (add) (TODO check this against CPython)
    mp_obj_class_t *self = self_in;
135
    mp_map_elem_t *elem = mp_obj_class_lookup(self->base.type, attr, MP_MAP_LOOKUP);
136
137
138
139
140
141
142
143
144
145
146
147
148
    if (elem != NULL) {
        elem->value = value;
    } else {
        mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
    }
    return true;
}

/******************************************************************************/
// 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
149

150
static void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
151
152
153
154
    mp_obj_type_t *self = self_in;
    print(env, "<class '%s'>", self->name);
}

155
156
157
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

158
159
160
161
162
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
163
            // args[0] = name
164
            // args[1] = bases tuple
165
166
            // args[2] = locals dict
            return mp_obj_new_type(mp_obj_get_qstr(args[0]), args[1], args[2]);
167
168
169
170
171
172

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

173
static mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
174
175
    // instantiate an instance of a class

176
    mp_obj_type_t *self = self_in;
177
178

    if (self->make_new == NULL) {
179
180
        nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "cannot create '%s' instances", self->name));
    }
181
182

    // make new instance
183
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
184
185
186
187
188

    // return new instance
    return o;
}

189
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
190
static void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
191
192
193
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
    mp_obj_type_t *self = self_in;
    mp_map_elem_t *elem = mp_obj_class_lookup(self, attr, MP_MAP_LOOKUP);
194
    if (elem != NULL) {
195
        dest[0] = elem->value;
196
197
        return;
    }
198
199
200
201
202
203
204
205
206
207
208

    // generic method lookup
    // this is a lookup in the class itself (ie not the classes type or instance)
    const mp_method_t *meth = self->methods;
    if (meth != NULL) {
        for (; meth->name != NULL; meth++) {
            if (strcmp(meth->name, qstr_str(attr)) == 0) {
                // 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(meth->fun, &mp_type_staticmethod)) {
                    // return just the function
209
                    dest[0] = ((mp_obj_staticmethod_t*)meth->fun)->fun;
210
211
                } else if (MP_OBJ_IS_TYPE(meth->fun, &mp_type_classmethod)) {
                    // return a bound method, with self being this class
212
213
                    dest[0] = ((mp_obj_classmethod_t*)meth->fun)->fun;
                    dest[1] = self_in;
214
215
216
                } 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
217
                    dest[0] = (mp_obj_t)meth->fun;
218
219
220
221
222
                }
                return;
            }
        }
    }
223
224
225
}

static bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
226
227
228
    assert(MP_OBJ_IS_TYPE(self_in, &mp_const_type));
    mp_obj_type_t *self = self_in;

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

231
    mp_map_elem_t *elem = mp_obj_class_lookup(self, attr, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
232
233
234
235
236
237
    if (elem != NULL) {
        elem->value = value;
        return true;
    } else {
        return false;
    }
238
239
240
241
}

const mp_obj_type_t mp_const_type = {
    { &mp_const_type },
242
    "type",
243
    .print = type_print,
244
    .make_new = type_make_new,
245
    .call = type_call,
246
247
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
248
};
249

250
251
252
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
    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
253
254
255
256
257
258
259
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
    o->base.type = &mp_const_type;
    o->name = qstr_str(name);
    o->print = class_print;
    o->make_new = class_make_new;
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
260
261
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
262
263
    return o;
}
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316

/******************************************************************************/
// 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);
317
318
319
320
321
322
323
324
325
326
327
328
329

/******************************************************************************/
// 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",
};