objfun.c 17.4 KB
Newer Older
xbe's avatar
xbe committed
1
#include <stdbool.h>
2
3
4
5
6
7
8
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
9
#include "qstr.h"
10
#include "obj.h"
11
#include "objtuple.h"
Paul Sokolovsky's avatar
Paul Sokolovsky committed
12
#include "objfun.h"
Damien George's avatar
Damien George committed
13
#include "runtime0.h"
14
15
16
#include "runtime.h"
#include "bc.h"

17
18
19
#if 0 // print debugging info
#define DEBUG_PRINT (1)
#else // don't print debugging info
20
#define DEBUG_printf(...) (void)0
21
22
#endif

23
24
25
26
27
/******************************************************************************/
/* native functions                                                           */

// mp_obj_fun_native_t defined in obj.h

28
STATIC void check_nargs(mp_obj_fun_native_t *self, int n_args, int n_kw) {
Damien George's avatar
Damien George committed
29
    mp_check_nargs(n_args, self->n_args_min, self->n_args_max, n_kw, self->is_kw);
Dave Hylands's avatar
Dave Hylands committed
30
31
}

Damien George's avatar
Damien George committed
32
void mp_check_nargs(int n_args, machine_uint_t n_args_min, machine_uint_t n_args_max, int n_kw, bool is_kw) {
Dave Hylands's avatar
Dave Hylands committed
33
    if (n_kw && !is_kw) {
34
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,
35
36
37
                                          "function does not take keyword arguments"));
    }

Dave Hylands's avatar
Dave Hylands committed
38
39
    if (n_args_min == n_args_max) {
        if (n_args != n_args_min) {
40
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
41
                                                     "function takes %d positional arguments but %d were given",
Dave Hylands's avatar
Dave Hylands committed
42
                                                     n_args_min, n_args));
43
44
        }
    } else {
Dave Hylands's avatar
Dave Hylands committed
45
        if (n_args < n_args_min) {
46
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
47
                                                    "<fun name>() missing %d required positional arguments: <list of names of params>",
Dave Hylands's avatar
Dave Hylands committed
48
49
                                                    n_args_min - n_args));
        } else if (n_args > n_args_max) {
50
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
51
                                                     "<fun name> expected at most %d arguments, got %d",
Dave Hylands's avatar
Dave Hylands committed
52
                                                     n_args_max, n_args));
53
54
55
56
        }
    }
}

57
58
59
60
61
62
63
64
65
66
STATIC mp_obj_t fun_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
    switch (op) {
        case MP_BINARY_OP_EQUAL:
            // These objects can be equal only if it's the same underlying structure,
            // we don't even need to check for 2nd arg type.
            return MP_BOOL(lhs_in == rhs_in);
    }
    return NULL;
}

67
STATIC mp_obj_t fun_native_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
68
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_fun_native));
69
    mp_obj_fun_native_t *self = self_in;
70

71
    // check number of arguments
72
73
    check_nargs(self, n_args, n_kw);

74
    if (self->is_kw) {
75
76
        // function allows keywords

77
78
79
        // we create a map directly from the given args array
        mp_map_t kw_args;
        mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
80

81
        return ((mp_fun_kw_t)self->fun)(n_args, args, &kw_args);
82

83
    } else if (self->n_args_min <= 3 && self->n_args_min == self->n_args_max) {
84
85
86
87
88
89
90
91
92
93
94
        // function requires a fixed number of arguments

        // dispatch function call
        switch (self->n_args_min) {
            case 0:
                return ((mp_fun_0_t)self->fun)();

            case 1:
                return ((mp_fun_1_t)self->fun)(args[0]);

            case 2:
95
                return ((mp_fun_2_t)self->fun)(args[0], args[1]);
96

97
            case 3:
98
                return ((mp_fun_3_t)self->fun)(args[0], args[1], args[2]);
99

100
101
102
103
104
105
            default:
                assert(0);
                return mp_const_none;
        }

    } else {
106
        // function takes a variable number of arguments, but no keywords
107

108
        return ((mp_fun_var_t)self->fun)(n_args, args);
109
110
111
    }
}

112
const mp_obj_type_t mp_type_fun_native = {
113
    { &mp_type_type },
114
    .name = MP_QSTR_function,
115
    .call = fun_native_call,
116
    .binary_op = fun_binary_op,
117
118
};

119
// fun must have the correct signature for n_args fixed arguments
Damien George's avatar
Damien George committed
120
mp_obj_t mp_make_function_n(int n_args, void *fun) {
121
    mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
122
    o->base.type = &mp_type_fun_native;
123
    o->is_kw = false;
124
125
    o->n_args_min = n_args;
    o->n_args_max = n_args;
126
127
128
129
    o->fun = fun;
    return o;
}

Damien George's avatar
Damien George committed
130
mp_obj_t mp_make_function_var(int n_args_min, mp_fun_var_t fun) {
131
    mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
132
    o->base.type = &mp_type_fun_native;
133
    o->is_kw = false;
134
    o->n_args_min = n_args_min;
135
    o->n_args_max = MP_OBJ_FUN_ARGS_MAX;
136
137
138
139
140
    o->fun = fun;
    return o;
}

// min and max are inclusive
Damien George's avatar
Damien George committed
141
mp_obj_t mp_make_function_var_between(int n_args_min, int n_args_max, mp_fun_var_t fun) {
142
    mp_obj_fun_native_t *o = m_new_obj(mp_obj_fun_native_t);
143
    o->base.type = &mp_type_fun_native;
144
    o->is_kw = false;
145
146
147
148
149
150
151
152
153
    o->n_args_min = n_args_min;
    o->n_args_max = n_args_max;
    o->fun = fun;
    return o;
}

/******************************************************************************/
/* byte code functions                                                        */

154
#if DEBUG_PRINT
155
STATIC void dump_args(const mp_obj_t *a, int sz) {
156
157
158
159
160
161
    DEBUG_printf("%p: ", a);
    for (int i = 0; i < sz; i++) {
        DEBUG_printf("%p ", a[i]);
    }
    DEBUG_printf("\n");
}
162
163
164
#else
#define dump_args(...) (void)0
#endif
165

166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
// If it's possible to call a function without allocating new argument array,
// this function returns true, together with pointers to 2 subarrays to be used
// as arguments. Otherwise, it returns false. It is expected that this fucntion
// will be accompanied by another, mp_obj_fun_prepare_full_args(), which will
// instead take pointer to full-length out-array, and will fill it in. Rationale
// being that a caller can try this function and if it succeeds, the function call
// can be made without allocating extra memory. Otherwise, caller can allocate memory
// and try "full" function. These functions are expected to be refactoring of
// code in fun_bc_call() and evenrually replace it.
bool mp_obj_fun_prepare_simple_args(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args,
                            uint *out_args1_len, const mp_obj_t **out_args1, uint *out_args2_len, const mp_obj_t **out_args2) {
    mp_obj_fun_bc_t *self = self_in;

    assert(n_kw == 0);
    assert(self->takes_var_args == 0);
    assert(self->takes_kw_args == 0);

    mp_obj_t *extra_args = self->extra_args + self->n_def_args;
    uint n_extra_args = 0;

    if (n_args > self->n_args) {
            goto arg_error;
    } else {
        extra_args -= self->n_args - n_args;
        n_extra_args += self->n_args - n_args;
    }
    *out_args1 = args;
    *out_args1_len = n_args;
    *out_args2 = extra_args;
    *out_args2_len = n_extra_args;
    return true;

arg_error:
199
    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes %d positional arguments but %d were given", self->n_args, n_args));
200
201
}

202
STATIC mp_obj_t fun_bc_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
203
204
    DEBUG_printf("Input n_args: %d, n_kw: %d\n", n_args, n_kw);
    DEBUG_printf("Input pos args: ");
205
    dump_args(args, n_args);
206
207
    DEBUG_printf("Input kw args: ");
    dump_args(args + n_args, n_kw * 2);
208
    mp_obj_fun_bc_t *self = self_in;
209
    DEBUG_printf("Func n_def_args: %d\n", self->n_def_args);
210

211
    const mp_obj_t *kwargs = args + n_args;
Damien George's avatar
Damien George committed
212
213
214
    mp_obj_t *extra_args = self->extra_args + self->n_def_args;
    uint n_extra_args = 0;

215

216
217
    // check positional arguments

Damien George's avatar
Damien George committed
218
219
220
    if (n_args > self->n_args) {
        // given more than enough arguments
        if (!self->takes_var_args) {
221
222
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
                "function takes %d positional arguments but %d were given", self->n_args, n_args));
Damien George's avatar
Damien George committed
223
224
225
226
227
        }
        // put extra arguments in varargs tuple
        *extra_args = mp_obj_new_tuple(n_args - self->n_args, args + self->n_args);
        n_extra_args = 1;
        n_args = self->n_args;
228
    } else {
Damien George's avatar
Damien George committed
229
        if (self->takes_var_args) {
230
            DEBUG_printf("passing empty tuple as *args\n");
Damien George's avatar
Damien George committed
231
232
233
            *extra_args = mp_const_empty_tuple;
            n_extra_args = 1;
        }
234
235
236
237
238
239
240
241
        // Apply processing and check below only if we don't have kwargs,
        // otherwise, kw handling code below has own extensive checks.
        if (n_kw == 0) {
            if (n_args >= self->n_args - self->n_def_args) {
                // given enough arguments, but may need to use some default arguments
                extra_args -= self->n_args - n_args;
                n_extra_args += self->n_args - n_args;
            } else {
242
243
244
                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
                    "function takes at least %d positional arguments but %d were given",
                    self->n_args - self->n_def_args, n_args));
245
246
            }
        }
247
    }
Damien George's avatar
Damien George committed
248

249
250
    // check keyword arguments

251
    if (n_kw != 0) {
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
        // We cannot use dynamically-sized array here, because GCC indeed
        // deallocates it on leaving defining scope (unlike most static stack allocs).
        // So, we have 2 choices: allocate it unconditionally at the top of function
        // (wastes stack), or use alloca which is guaranteed to dealloc on func exit.
        //mp_obj_t flat_args[self->n_args];
        mp_obj_t *flat_args = alloca(self->n_args * sizeof(mp_obj_t));
        for (int i = self->n_args - 1; i >= 0; i--) {
            flat_args[i] = MP_OBJ_NULL;
        }
        memcpy(flat_args, args, sizeof(*args) * n_args);
        DEBUG_printf("Initial args: ");
        dump_args(flat_args, self->n_args);

        mp_obj_t dict = MP_OBJ_NULL;
        if (self->takes_kw_args) {
            dict = mp_obj_new_dict(n_kw); // TODO: better go conservative with 0?
268
269
        }
        for (uint i = 0; i < n_kw; i++) {
270
271
272
273
            qstr arg_name = MP_OBJ_QSTR_VALUE(kwargs[2 * i]);
            for (uint j = 0; j < self->n_args; j++) {
                if (arg_name == self->args[j]) {
                    if (flat_args[j] != MP_OBJ_NULL) {
274
                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
275
276
277
278
279
280
281
282
                            "function got multiple values for argument '%s'", qstr_str(arg_name)));
                    }
                    flat_args[j] = kwargs[2 * i + 1];
                    goto continue2;
                }
            }
            // Didn't find name match with positional args
            if (!self->takes_kw_args) {
283
                nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "function does not take keyword arguments"));
284
            }
285
            mp_obj_dict_store(dict, kwargs[2 * i], kwargs[2 * i + 1]);
286
287
288
289
290
291
292
293
continue2:;
        }
        DEBUG_printf("Args with kws flattened: ");
        dump_args(flat_args, self->n_args);

        // Now fill in defaults
        mp_obj_t *d = &flat_args[self->n_args - 1];
        mp_obj_t *s = &self->extra_args[self->n_def_args - 1];
294
        for (int i = self->n_def_args; i > 0; i--, d--, s--) {
295
            if (*d == MP_OBJ_NULL) {
296
                *d = *s;
297
298
299
300
301
302
303
304
            }
        }
        DEBUG_printf("Args after filling defaults: ");
        dump_args(flat_args, self->n_args);

        // Now check that all mandatory args specified
        while (d >= flat_args) {
            if (*d-- == MP_OBJ_NULL) {
305
                nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
306
307
308
309
310
311
312
313
314
315
                    "function missing required positional argument #%d", d - flat_args));
            }
        }

        args = flat_args;
        n_args = self->n_args;

        if (self->takes_kw_args) {
            extra_args[n_extra_args] = dict;
            n_extra_args += 1;
316
317
318
319
320
321
322
        }
    } else {
        // no keyword arguments given
        if (self->takes_kw_args) {
            extra_args[n_extra_args] = mp_obj_new_dict(0);
            n_extra_args += 1;
        }
323
    }
324

325
    mp_obj_dict_t *old_globals = mp_globals_get();
Damien George's avatar
Damien George committed
326
    mp_globals_set(self->globals);
327
    mp_obj_t result;
328
329
330
    DEBUG_printf("Calling: args=%p, n_args=%d, extra_args=%p, n_extra_args=%d\n", args, n_args, extra_args, n_extra_args);
    dump_args(args, n_args);
    dump_args(extra_args, n_extra_args);
331
    mp_vm_return_kind_t vm_return_kind = mp_execute_byte_code(self->bytecode, args, n_args, extra_args, n_extra_args, &result);
Damien George's avatar
Damien George committed
332
    mp_globals_set(old_globals);
333

334
335
336
    if (vm_return_kind == MP_VM_RETURN_NORMAL) {
        return result;
    } else { // MP_VM_RETURN_EXCEPTION
337
        nlr_raise(result);
338
    }
339
340
}

341
const mp_obj_type_t mp_type_fun_bc = {
342
    { &mp_type_type },
343
    .name = MP_QSTR_function,
344
    .call = fun_bc_call,
345
    .binary_op = fun_binary_op,
346
347
};

348
mp_obj_t mp_obj_new_fun_bc(uint scope_flags, qstr *args, uint n_args, mp_obj_t def_args_in, const byte *code) {
Damien George's avatar
Damien George committed
349
350
    uint n_def_args = 0;
    uint n_extra_args = 0;
351
352
    mp_obj_tuple_t *def_args = def_args_in;
    if (def_args != MP_OBJ_NULL) {
353
        assert(MP_OBJ_IS_TYPE(def_args, &mp_type_tuple));
354
        n_def_args = def_args->len;
Damien George's avatar
Damien George committed
355
356
357
358
        n_extra_args = def_args->len;
    }
    if ((scope_flags & MP_SCOPE_FLAG_VARARGS) != 0) {
        n_extra_args += 1;
359
    }
360
361
362
    if ((scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) {
        n_extra_args += 1;
    }
Damien George's avatar
Damien George committed
363
    mp_obj_fun_bc_t *o = m_new_obj_var(mp_obj_fun_bc_t, mp_obj_t, n_extra_args);
364
    o->base.type = &mp_type_fun_bc;
Damien George's avatar
Damien George committed
365
    o->globals = mp_globals_get();
366
    o->args = args;
367
    o->n_args = n_args;
368
    o->n_def_args = n_def_args;
Damien George's avatar
Damien George committed
369
370
    o->takes_var_args = (scope_flags & MP_SCOPE_FLAG_VARARGS) != 0;
    o->takes_kw_args = (scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0;
371
    o->bytecode = code;
372
    if (def_args != MP_OBJ_NULL) {
Damien George's avatar
Damien George committed
373
        memcpy(o->extra_args, def_args->items, n_def_args * sizeof(mp_obj_t));
374
    }
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
    return o;
}

/******************************************************************************/
/* inline assembler functions                                                 */

typedef struct _mp_obj_fun_asm_t {
    mp_obj_base_t base;
    int n_args;
    void *fun;
} mp_obj_fun_asm_t;

typedef machine_uint_t (*inline_asm_fun_0_t)();
typedef machine_uint_t (*inline_asm_fun_1_t)(machine_uint_t);
typedef machine_uint_t (*inline_asm_fun_2_t)(machine_uint_t, machine_uint_t);
typedef machine_uint_t (*inline_asm_fun_3_t)(machine_uint_t, machine_uint_t, machine_uint_t);

// convert a Micro Python object to a sensible value for inline asm
393
STATIC machine_uint_t convert_obj_for_inline_asm(mp_obj_t obj) {
394
395
396
397
398
399
400
401
402
    // TODO for byte_array, pass pointer to the array
    if (MP_OBJ_IS_SMALL_INT(obj)) {
        return MP_OBJ_SMALL_INT_VALUE(obj);
    } else if (obj == mp_const_none) {
        return 0;
    } else if (obj == mp_const_false) {
        return 0;
    } else if (obj == mp_const_true) {
        return 1;
403
    } else if (MP_OBJ_IS_STR(obj)) {
404
        // pointer to the string (it's probably constant though!)
405
406
        uint l;
        return (machine_uint_t)mp_obj_str_get_data(obj, &l);
407
408
409
    } else {
        mp_obj_type_t *type = mp_obj_get_type(obj);
        if (0) {
410
#if MICROPY_ENABLE_FLOAT
411
412
413
        } else if (type == &mp_type_float) {
            // convert float to int (could also pass in float registers)
            return (machine_int_t)mp_obj_float_get(obj);
414
#endif
415
416
417
418
419
420
421
422
423
424
425
426
427
        } else if (type == &mp_type_tuple) {
            // pointer to start of tuple (could pass length, but then could use len(x) for that)
            uint len;
            mp_obj_t *items;
            mp_obj_tuple_get(obj, &len, &items);
            return (machine_uint_t)items;
        } else if (type == &mp_type_list) {
            // pointer to start of list (could pass length, but then could use len(x) for that)
            uint len;
            mp_obj_t *items;
            mp_obj_list_get(obj, &len, &items);
            return (machine_uint_t)items;
        } else {
428
429
430
431
432
433
434
435
            buffer_info_t bufinfo;
            if (mp_get_buffer(obj, &bufinfo)) {
                // supports the buffer protocol, return a pointer to the data
                return (machine_uint_t)bufinfo.buf;
            } else {
                // just pass along a pointer to the object
                return (machine_uint_t)obj;
            }
436
        }
437
438
439
440
    }
}

// convert a return value from inline asm to a sensible Micro Python object
441
STATIC mp_obj_t convert_val_from_inline_asm(machine_uint_t val) {
442
443
444
    return MP_OBJ_NEW_SMALL_INT(val);
}

445
STATIC mp_obj_t fun_asm_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
446
447
448
    mp_obj_fun_asm_t *self = self_in;

    if (n_args != self->n_args) {
449
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes %d positional arguments but %d were given", self->n_args, n_args));
450
    }
451
    if (n_kw != 0) {
452
        nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError, "function does not take keyword arguments"));
453
    }
454
455
456
457
458
459
460

    machine_uint_t ret;
    if (n_args == 0) {
        ret = ((inline_asm_fun_0_t)self->fun)();
    } else if (n_args == 1) {
        ret = ((inline_asm_fun_1_t)self->fun)(convert_obj_for_inline_asm(args[0]));
    } else if (n_args == 2) {
461
        ret = ((inline_asm_fun_2_t)self->fun)(convert_obj_for_inline_asm(args[0]), convert_obj_for_inline_asm(args[1]));
462
    } else if (n_args == 3) {
463
        ret = ((inline_asm_fun_3_t)self->fun)(convert_obj_for_inline_asm(args[0]), convert_obj_for_inline_asm(args[1]), convert_obj_for_inline_asm(args[2]));
464
465
466
467
468
469
470
471
    } else {
        assert(0);
        ret = 0;
    }

    return convert_val_from_inline_asm(ret);
}

472
STATIC const mp_obj_type_t mp_type_fun_asm = {
473
    { &mp_type_type },
474
    .name = MP_QSTR_function,
475
    .call = fun_asm_call,
476
    .binary_op = fun_binary_op,
477
478
479
480
};

mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun) {
    mp_obj_fun_asm_t *o = m_new_obj(mp_obj_fun_asm_t);
481
    o->base.type = &mp_type_fun_asm;
482
483
484
485
    o->n_args = n_args;
    o->fun = fun;
    return o;
}