2014-05-03 23:27:38 +01:00
|
|
|
/*
|
|
|
|
* This file is part of the Micro Python project, http://micropython.org/
|
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2013-10-04 19:53:11 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
#include "py/mpstate.h"
|
2015-01-01 20:27:54 +00:00
|
|
|
#include "py/nlr.h"
|
|
|
|
#include "py/parsenum.h"
|
|
|
|
#include "py/compile.h"
|
2015-05-11 13:25:19 +01:00
|
|
|
#include "py/objstr.h"
|
2015-01-01 20:27:54 +00:00
|
|
|
#include "py/objtuple.h"
|
|
|
|
#include "py/objlist.h"
|
|
|
|
#include "py/objmodule.h"
|
|
|
|
#include "py/objgenerator.h"
|
|
|
|
#include "py/smallint.h"
|
|
|
|
#include "py/runtime0.h"
|
|
|
|
#include "py/runtime.h"
|
|
|
|
#include "py/builtin.h"
|
|
|
|
#include "py/stackctrl.h"
|
|
|
|
#include "py/gc.h"
|
2013-12-17 18:27:24 +00:00
|
|
|
|
2013-10-10 11:24:39 +01:00
|
|
|
#if 0 // print debugging info
|
2013-10-10 23:25:50 +01:00
|
|
|
#define DEBUG_PRINT (1)
|
2014-02-16 16:11:42 +00:00
|
|
|
#define DEBUG_printf DEBUG_printf
|
2014-02-26 22:40:35 +00:00
|
|
|
#define DEBUG_OP_printf(...) DEBUG_printf(__VA_ARGS__)
|
2013-10-10 11:24:39 +01:00
|
|
|
#else // don't print debugging info
|
2014-02-26 22:40:35 +00:00
|
|
|
#define DEBUG_printf(...) (void)0
|
|
|
|
#define DEBUG_OP_printf(...) (void)0
|
2013-10-10 11:24:39 +01:00
|
|
|
#endif
|
2013-10-04 19:53:11 +01:00
|
|
|
|
2014-04-04 18:08:21 +01:00
|
|
|
const mp_obj_module_t mp_module___main__ = {
|
|
|
|
.base = { &mp_type_module },
|
2015-01-01 23:30:53 +00:00
|
|
|
.globals = (mp_obj_dict_t*)&MP_STATE_VM(dict_main),
|
2014-04-04 18:08:21 +01:00
|
|
|
};
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
void mp_init(void) {
|
2014-08-04 10:05:16 +01:00
|
|
|
qstr_init();
|
2014-06-27 18:54:22 +01:00
|
|
|
|
2014-10-25 18:19:55 +01:00
|
|
|
// no pending exceptions to start with
|
2015-01-01 23:30:53 +00:00
|
|
|
MP_STATE_VM(mp_pending_exception) = MP_OBJ_NULL;
|
2014-10-25 18:19:55 +01:00
|
|
|
|
2014-08-04 10:05:16 +01:00
|
|
|
#if MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF
|
|
|
|
mp_init_emergency_exception_buf();
|
|
|
|
#endif
|
|
|
|
|
2016-12-15 02:00:19 +00:00
|
|
|
#if MICROPY_KBD_EXCEPTION
|
|
|
|
// initialise the exception object for raising KeyboardInterrupt
|
|
|
|
MP_STATE_VM(mp_kbd_exception).base.type = &mp_type_KeyboardInterrupt;
|
|
|
|
MP_STATE_VM(mp_kbd_exception).traceback_alloc = 0;
|
|
|
|
MP_STATE_VM(mp_kbd_exception).traceback_len = 0;
|
|
|
|
MP_STATE_VM(mp_kbd_exception).traceback_data = NULL;
|
|
|
|
MP_STATE_VM(mp_kbd_exception).args = mp_const_empty_tuple;
|
|
|
|
#endif
|
|
|
|
|
2014-05-12 23:07:34 +01:00
|
|
|
// call port specific initialization if any
|
2014-05-03 10:28:29 +01:00
|
|
|
#ifdef MICROPY_PORT_INIT_FUNC
|
|
|
|
MICROPY_PORT_INIT_FUNC;
|
|
|
|
#endif
|
|
|
|
|
2014-06-02 17:37:55 +01:00
|
|
|
// optimization disabled by default
|
2015-01-01 23:30:53 +00:00
|
|
|
MP_STATE_VM(mp_optimise_value) = 0;
|
2014-05-12 23:07:34 +01:00
|
|
|
|
2017-01-26 12:30:38 +00:00
|
|
|
// init global module dict
|
|
|
|
mp_obj_dict_init(&MP_STATE_VM(mp_loaded_modules_dict), 3);
|
2014-01-22 23:59:20 +00:00
|
|
|
|
2014-04-05 22:36:42 +01:00
|
|
|
// initialise the __main__ module
|
2015-01-01 23:30:53 +00:00
|
|
|
mp_obj_dict_init(&MP_STATE_VM(dict_main), 1);
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_dict_store(MP_OBJ_FROM_PTR(&MP_STATE_VM(dict_main)), MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR___main__));
|
2014-04-04 18:08:21 +01:00
|
|
|
|
|
|
|
// locals = globals for outer module (see Objects/frameobject.c/PyFrame_New())
|
2015-01-01 23:30:53 +00:00
|
|
|
MP_STATE_CTX(dict_locals) = MP_STATE_CTX(dict_globals) = &MP_STATE_VM(dict_main);
|
2014-12-09 16:19:48 +00:00
|
|
|
|
|
|
|
#if MICROPY_CAN_OVERRIDE_BUILTINS
|
|
|
|
// start with no extensions to builtins
|
2015-01-01 23:30:53 +00:00
|
|
|
MP_STATE_VM(mp_module_builtins_override_dict) = NULL;
|
2014-12-09 16:19:48 +00:00
|
|
|
#endif
|
2016-05-26 11:42:53 +01:00
|
|
|
|
2016-12-14 00:40:11 +00:00
|
|
|
#if MICROPY_FSUSERMOUNT
|
|
|
|
// zero out the pointers to the user-mounted devices
|
|
|
|
memset(MP_STATE_VM(fs_user_mount), 0, sizeof(MP_STATE_VM(fs_user_mount)));
|
|
|
|
#endif
|
|
|
|
|
2017-01-27 04:10:09 +00:00
|
|
|
#if MICROPY_VFS
|
|
|
|
// initialise the VFS sub-system
|
|
|
|
MP_STATE_VM(vfs_cur) = NULL;
|
|
|
|
MP_STATE_VM(vfs_mount_table) = NULL;
|
|
|
|
#endif
|
|
|
|
|
2016-05-26 11:42:53 +01:00
|
|
|
#if MICROPY_PY_THREAD_GIL
|
|
|
|
mp_thread_mutex_init(&MP_STATE_VM(gil_mutex));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
MP_THREAD_GIL_ENTER();
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
void mp_deinit(void) {
|
2014-04-05 22:36:42 +01:00
|
|
|
//mp_obj_dict_free(&dict_main);
|
2017-01-26 12:30:38 +00:00
|
|
|
//mp_map_deinit(&MP_STATE_VM(mp_loaded_modules_map));
|
2014-05-08 09:56:33 +01:00
|
|
|
|
|
|
|
// call port specific deinitialization if any
|
|
|
|
#ifdef MICROPY_PORT_INIT_FUNC
|
|
|
|
MICROPY_PORT_DEINIT_FUNC;
|
|
|
|
#endif
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2015-01-20 11:55:10 +00:00
|
|
|
mp_obj_t mp_load_name(qstr qst) {
|
2013-10-04 19:53:11 +01:00
|
|
|
// logic: search locals, globals, builtins
|
2015-01-20 11:55:10 +00:00
|
|
|
DEBUG_OP_printf("load name %s\n", qstr_str(qst));
|
2014-04-05 02:51:26 +01:00
|
|
|
// If we're at the outer scope (locals == globals), dispatch to load_global right away
|
2015-01-01 23:30:53 +00:00
|
|
|
if (MP_STATE_CTX(dict_locals) != MP_STATE_CTX(dict_globals)) {
|
2015-01-20 11:55:10 +00:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&MP_STATE_CTX(dict_locals)->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
|
2014-04-05 02:51:26 +01:00
|
|
|
if (elem != NULL) {
|
|
|
|
return elem->value;
|
|
|
|
}
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
2015-01-20 11:55:10 +00:00
|
|
|
return mp_load_global(qst);
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2015-01-20 11:55:10 +00:00
|
|
|
mp_obj_t mp_load_global(qstr qst) {
|
2013-10-09 23:10:10 +01:00
|
|
|
// logic: search globals, builtins
|
2015-01-20 11:55:10 +00:00
|
|
|
DEBUG_OP_printf("load global %s\n", qstr_str(qst));
|
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&MP_STATE_CTX(dict_globals)->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
|
2013-10-09 23:10:10 +01:00
|
|
|
if (elem == NULL) {
|
2014-12-09 16:19:48 +00:00
|
|
|
#if MICROPY_CAN_OVERRIDE_BUILTINS
|
2015-01-01 23:30:53 +00:00
|
|
|
if (MP_STATE_VM(mp_module_builtins_override_dict) != NULL) {
|
2014-12-09 16:19:48 +00:00
|
|
|
// lookup in additional dynamic table of builtins first
|
2015-01-20 11:55:10 +00:00
|
|
|
elem = mp_map_lookup(&MP_STATE_VM(mp_module_builtins_override_dict)->map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
|
2014-12-09 16:19:48 +00:00
|
|
|
if (elem != NULL) {
|
|
|
|
return elem->value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2015-01-20 11:55:10 +00:00
|
|
|
elem = mp_map_lookup((mp_map_t*)&mp_module_builtins_globals.map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP);
|
2013-10-09 23:10:10 +01:00
|
|
|
if (elem == NULL) {
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_NameError, "name not defined");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_NameError,
|
2015-04-11 13:03:37 +01:00
|
|
|
"name '%q' is not defined", qst));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return elem->value;
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_load_build_class(void) {
|
2013-10-04 19:53:11 +01:00
|
|
|
DEBUG_OP_printf("load_build_class\n");
|
2014-12-09 16:19:48 +00:00
|
|
|
#if MICROPY_CAN_OVERRIDE_BUILTINS
|
2015-01-01 23:30:53 +00:00
|
|
|
if (MP_STATE_VM(mp_module_builtins_override_dict) != NULL) {
|
2014-12-09 16:19:48 +00:00
|
|
|
// lookup in additional dynamic table of builtins first
|
2015-01-01 23:30:53 +00:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&MP_STATE_VM(mp_module_builtins_override_dict)->map, MP_OBJ_NEW_QSTR(MP_QSTR___build_class__), MP_MAP_LOOKUP);
|
2014-12-09 16:19:48 +00:00
|
|
|
if (elem != NULL) {
|
|
|
|
return elem->value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2015-11-27 17:01:44 +00:00
|
|
|
return MP_OBJ_FROM_PTR(&mp_builtin___build_class___obj);
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2015-01-20 11:55:10 +00:00
|
|
|
void mp_store_name(qstr qst, mp_obj_t obj) {
|
|
|
|
DEBUG_OP_printf("store name %s <- %p\n", qstr_str(qst), obj);
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_dict_store(MP_OBJ_FROM_PTR(MP_STATE_CTX(dict_locals)), MP_OBJ_NEW_QSTR(qst), obj);
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
|
|
|
|
2015-01-20 11:55:10 +00:00
|
|
|
void mp_delete_name(qstr qst) {
|
|
|
|
DEBUG_OP_printf("delete name %s\n", qstr_str(qst));
|
|
|
|
// TODO convert KeyError to NameError if qst not found
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_dict_delete(MP_OBJ_FROM_PTR(MP_STATE_CTX(dict_locals)), MP_OBJ_NEW_QSTR(qst));
|
2014-03-23 19:19:02 +00:00
|
|
|
}
|
|
|
|
|
2015-01-20 11:55:10 +00:00
|
|
|
void mp_store_global(qstr qst, mp_obj_t obj) {
|
|
|
|
DEBUG_OP_printf("store global %s <- %p\n", qstr_str(qst), obj);
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_dict_store(MP_OBJ_FROM_PTR(MP_STATE_CTX(dict_globals)), MP_OBJ_NEW_QSTR(qst), obj);
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2015-01-20 11:55:10 +00:00
|
|
|
void mp_delete_global(qstr qst) {
|
|
|
|
DEBUG_OP_printf("delete global %s\n", qstr_str(qst));
|
|
|
|
// TODO convert KeyError to NameError if qst not found
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_dict_delete(MP_OBJ_FROM_PTR(MP_STATE_CTX(dict_globals)), MP_OBJ_NEW_QSTR(qst));
|
2014-04-08 21:11:49 +01:00
|
|
|
}
|
|
|
|
|
2014-08-30 14:59:21 +01:00
|
|
|
mp_obj_t mp_unary_op(mp_uint_t op, mp_obj_t arg) {
|
2014-09-23 10:59:05 +01:00
|
|
|
DEBUG_OP_printf("unary " UINT_FMT " %p\n", op, arg);
|
2014-02-01 23:04:09 +00:00
|
|
|
|
2015-12-08 12:28:11 +00:00
|
|
|
if (op == MP_UNARY_OP_NOT) {
|
|
|
|
// "not x" is the negative of whether "x" is true per Python semantics
|
|
|
|
return mp_obj_new_bool(mp_obj_is_true(arg) == 0);
|
|
|
|
} else if (MP_OBJ_IS_SMALL_INT(arg)) {
|
2014-07-03 13:25:24 +01:00
|
|
|
mp_int_t val = MP_OBJ_SMALL_INT_VALUE(arg);
|
2013-11-02 19:47:57 +00:00
|
|
|
switch (op) {
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_UNARY_OP_BOOL:
|
2015-10-11 10:09:43 +01:00
|
|
|
return mp_obj_new_bool(val != 0);
|
2015-05-11 13:25:19 +01:00
|
|
|
case MP_UNARY_OP_HASH:
|
|
|
|
return arg;
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_UNARY_OP_POSITIVE:
|
2014-03-12 15:38:15 +00:00
|
|
|
return arg;
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_UNARY_OP_NEGATIVE:
|
2014-03-12 15:38:15 +00:00
|
|
|
// check for overflow
|
|
|
|
if (val == MP_SMALL_INT_MIN) {
|
|
|
|
return mp_obj_new_int(-val);
|
|
|
|
} else {
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(-val);
|
|
|
|
}
|
|
|
|
default:
|
2017-01-17 06:03:56 +00:00
|
|
|
assert(op == MP_UNARY_OP_INVERT);
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(~val);
|
2013-12-21 18:17:45 +00:00
|
|
|
}
|
2015-05-11 13:25:19 +01:00
|
|
|
} else if (op == MP_UNARY_OP_HASH && MP_OBJ_IS_STR_OR_BYTES(arg)) {
|
|
|
|
// fast path for hashing str/bytes
|
|
|
|
GET_STR_HASH(arg, h);
|
2016-09-02 05:42:53 +01:00
|
|
|
if (h == 0) {
|
|
|
|
GET_STR_DATA_LEN(arg, data, len);
|
|
|
|
h = qstr_compute_hash(data, len);
|
|
|
|
}
|
2015-05-11 13:25:19 +01:00
|
|
|
return MP_OBJ_NEW_SMALL_INT(h);
|
2014-01-23 18:27:51 +00:00
|
|
|
} else {
|
|
|
|
mp_obj_type_t *type = mp_obj_get_type(arg);
|
|
|
|
if (type->unary_op != NULL) {
|
|
|
|
mp_obj_t result = type->unary_op(op, arg);
|
2014-05-21 19:42:43 +01:00
|
|
|
if (result != MP_OBJ_NULL) {
|
2013-12-21 18:17:45 +00:00
|
|
|
return result;
|
|
|
|
}
|
2013-11-02 19:47:57 +00:00
|
|
|
}
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "unsupported type for operator");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
2015-04-11 13:03:37 +01:00
|
|
|
"unsupported type for %q: '%s'",
|
|
|
|
mp_unary_op_method_name[op], mp_obj_get_type_str(arg)));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2013-11-02 19:47:57 +00:00
|
|
|
}
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2014-08-30 14:59:21 +01:00
|
|
|
mp_obj_t mp_binary_op(mp_uint_t op, mp_obj_t lhs, mp_obj_t rhs) {
|
2014-09-23 10:59:05 +01:00
|
|
|
DEBUG_OP_printf("binary " UINT_FMT " %p %p\n", op, lhs, rhs);
|
2014-01-03 14:09:31 +00:00
|
|
|
|
|
|
|
// TODO correctly distinguish inplace operators for mutable objects
|
|
|
|
// lookup logic that CPython uses for +=:
|
|
|
|
// check for implemented +=
|
|
|
|
// then check for implemented +
|
|
|
|
// then check for implemented seq.inplace_concat
|
|
|
|
// then check for implemented seq.concat
|
|
|
|
// then fail
|
|
|
|
// note that list does not implement + or +=, so that inplace_concat is reached first for +=
|
|
|
|
|
2014-02-01 23:04:09 +00:00
|
|
|
// deal with is
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_IS) {
|
2015-10-11 10:09:43 +01:00
|
|
|
return mp_obj_new_bool(lhs == rhs);
|
2014-01-14 22:31:28 +00:00
|
|
|
}
|
|
|
|
|
2014-01-11 10:47:22 +00:00
|
|
|
// deal with == and != for all types
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_EQUAL || op == MP_BINARY_OP_NOT_EQUAL) {
|
2014-01-11 10:47:22 +00:00
|
|
|
if (mp_obj_equal(lhs, rhs)) {
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_EQUAL) {
|
2014-01-11 10:47:22 +00:00
|
|
|
return mp_const_true;
|
|
|
|
} else {
|
|
|
|
return mp_const_false;
|
|
|
|
}
|
|
|
|
} else {
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_EQUAL) {
|
2014-01-11 10:47:22 +00:00
|
|
|
return mp_const_false;
|
|
|
|
} else {
|
|
|
|
return mp_const_true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// deal with exception_match for all types
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_EXCEPTION_MATCH) {
|
2014-02-15 16:10:44 +00:00
|
|
|
// rhs must be issubclass(rhs, BaseException)
|
|
|
|
if (mp_obj_is_exception_type(rhs)) {
|
2014-09-24 14:05:40 +01:00
|
|
|
if (mp_obj_exception_match(lhs, rhs)) {
|
2014-01-11 10:47:22 +00:00
|
|
|
return mp_const_true;
|
|
|
|
} else {
|
|
|
|
return mp_const_false;
|
|
|
|
}
|
2014-09-24 14:05:40 +01:00
|
|
|
} else if (MP_OBJ_IS_TYPE(rhs, &mp_type_tuple)) {
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(rhs);
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < tuple->len; i++) {
|
2014-09-24 14:05:40 +01:00
|
|
|
rhs = tuple->items[i];
|
|
|
|
if (!mp_obj_is_exception_type(rhs)) {
|
|
|
|
goto unsupported_op;
|
|
|
|
}
|
|
|
|
if (mp_obj_exception_match(lhs, rhs)) {
|
|
|
|
return mp_const_true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return mp_const_false;
|
2014-01-11 10:47:22 +00:00
|
|
|
}
|
2014-09-24 14:05:40 +01:00
|
|
|
goto unsupported_op;
|
2014-01-11 10:47:22 +00:00
|
|
|
}
|
|
|
|
|
2014-01-06 22:13:00 +00:00
|
|
|
if (MP_OBJ_IS_SMALL_INT(lhs)) {
|
2014-07-03 13:25:24 +01:00
|
|
|
mp_int_t lhs_val = MP_OBJ_SMALL_INT_VALUE(lhs);
|
2014-01-06 22:13:00 +00:00
|
|
|
if (MP_OBJ_IS_SMALL_INT(rhs)) {
|
2014-07-03 13:25:24 +01:00
|
|
|
mp_int_t rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs);
|
2014-03-12 15:38:15 +00:00
|
|
|
// This is a binary operation: lhs_val op rhs_val
|
|
|
|
// We need to be careful to handle overflow; see CERT INT32-C
|
|
|
|
// Operations that can overflow:
|
2014-07-03 13:25:24 +01:00
|
|
|
// + result always fits in mp_int_t, then handled by SMALL_INT check
|
|
|
|
// - result always fits in mp_int_t, then handled by SMALL_INT check
|
2014-03-12 15:38:15 +00:00
|
|
|
// * checked explicitly
|
2014-07-03 13:25:24 +01:00
|
|
|
// / if lhs=MIN and rhs=-1; result always fits in mp_int_t, then handled by SMALL_INT check
|
|
|
|
// % if lhs=MIN and rhs=-1; result always fits in mp_int_t, then handled by SMALL_INT check
|
2014-03-12 15:38:15 +00:00
|
|
|
// << checked explicitly
|
2014-01-06 22:13:00 +00:00
|
|
|
switch (op) {
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_OR:
|
|
|
|
case MP_BINARY_OP_INPLACE_OR: lhs_val |= rhs_val; break;
|
|
|
|
case MP_BINARY_OP_XOR:
|
|
|
|
case MP_BINARY_OP_INPLACE_XOR: lhs_val ^= rhs_val; break;
|
|
|
|
case MP_BINARY_OP_AND:
|
|
|
|
case MP_BINARY_OP_INPLACE_AND: lhs_val &= rhs_val; break;
|
|
|
|
case MP_BINARY_OP_LSHIFT:
|
|
|
|
case MP_BINARY_OP_INPLACE_LSHIFT: {
|
2014-03-12 15:38:15 +00:00
|
|
|
if (rhs_val < 0) {
|
|
|
|
// negative shift not allowed
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, "negative shift count");
|
2015-01-16 17:47:07 +00:00
|
|
|
} else if (rhs_val >= (mp_int_t)BITS_PER_WORD || lhs_val > (MP_SMALL_INT_MAX >> rhs_val) || lhs_val < (MP_SMALL_INT_MIN >> rhs_val)) {
|
2014-03-12 15:38:15 +00:00
|
|
|
// left-shift will overflow, so use higher precision integer
|
|
|
|
lhs = mp_obj_new_int_from_ll(lhs_val);
|
|
|
|
goto generic_binary_op;
|
|
|
|
} else {
|
|
|
|
// use standard precision
|
|
|
|
lhs_val <<= rhs_val;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_RSHIFT:
|
|
|
|
case MP_BINARY_OP_INPLACE_RSHIFT:
|
2014-03-12 15:38:15 +00:00
|
|
|
if (rhs_val < 0) {
|
|
|
|
// negative shift not allowed
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, "negative shift count");
|
2014-03-12 15:38:15 +00:00
|
|
|
} else {
|
|
|
|
// standard precision is enough for right-shift
|
2015-01-16 17:47:07 +00:00
|
|
|
if (rhs_val >= (mp_int_t)BITS_PER_WORD) {
|
2014-11-02 00:39:41 +00:00
|
|
|
// Shifting to big amounts is underfined behavior
|
|
|
|
// in C and is CPU-dependent; propagate sign bit.
|
|
|
|
rhs_val = BITS_PER_WORD - 1;
|
|
|
|
}
|
2014-03-12 15:38:15 +00:00
|
|
|
lhs_val >>= rhs_val;
|
|
|
|
}
|
|
|
|
break;
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_ADD:
|
|
|
|
case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break;
|
|
|
|
case MP_BINARY_OP_SUBTRACT:
|
|
|
|
case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break;
|
|
|
|
case MP_BINARY_OP_MULTIPLY:
|
|
|
|
case MP_BINARY_OP_INPLACE_MULTIPLY: {
|
2014-03-12 15:38:15 +00:00
|
|
|
|
2014-07-03 13:25:24 +01:00
|
|
|
// If long long type exists and is larger than mp_int_t, then
|
2014-03-12 15:38:15 +00:00
|
|
|
// we can use the following code to perform overflow-checked multiplication.
|
2014-04-04 12:13:51 +01:00
|
|
|
// Otherwise (eg in x64 case) we must use mp_small_int_mul_overflow.
|
2014-03-12 15:38:15 +00:00
|
|
|
#if 0
|
|
|
|
// compute result using long long precision
|
|
|
|
long long res = (long long)lhs_val * (long long)rhs_val;
|
|
|
|
if (res > MP_SMALL_INT_MAX || res < MP_SMALL_INT_MIN) {
|
|
|
|
// result overflowed SMALL_INT, so return higher precision integer
|
|
|
|
return mp_obj_new_int_from_ll(res);
|
|
|
|
} else {
|
|
|
|
// use standard precision
|
2014-07-03 13:25:24 +01:00
|
|
|
lhs_val = (mp_int_t)res;
|
2014-03-12 15:38:15 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-04-04 12:13:51 +01:00
|
|
|
if (mp_small_int_mul_overflow(lhs_val, rhs_val)) {
|
|
|
|
// use higher precision
|
|
|
|
lhs = mp_obj_new_int_from_ll(lhs_val);
|
|
|
|
goto generic_binary_op;
|
|
|
|
} else {
|
|
|
|
// use standard precision
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(lhs_val * rhs_val);
|
|
|
|
}
|
2014-03-12 15:38:15 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_FLOOR_DIVIDE:
|
|
|
|
case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
|
2014-03-31 00:20:00 +01:00
|
|
|
if (rhs_val == 0) {
|
|
|
|
goto zero_division;
|
|
|
|
}
|
2014-04-04 12:13:51 +01:00
|
|
|
lhs_val = mp_small_int_floor_divide(lhs_val, rhs_val);
|
2014-03-22 20:19:24 +00:00
|
|
|
break;
|
2014-03-31 00:20:00 +01:00
|
|
|
|
2014-06-01 13:32:54 +01:00
|
|
|
#if MICROPY_PY_BUILTINS_FLOAT
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_TRUE_DIVIDE:
|
2014-03-31 00:20:00 +01:00
|
|
|
case MP_BINARY_OP_INPLACE_TRUE_DIVIDE:
|
|
|
|
if (rhs_val == 0) {
|
2014-04-02 17:06:05 +01:00
|
|
|
goto zero_division;
|
2014-03-31 00:20:00 +01:00
|
|
|
}
|
|
|
|
return mp_obj_new_float((mp_float_t)lhs_val / (mp_float_t)rhs_val);
|
2014-03-12 15:38:15 +00:00
|
|
|
#endif
|
2014-01-06 22:13:00 +00:00
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_MODULO:
|
2014-04-04 12:13:51 +01:00
|
|
|
case MP_BINARY_OP_INPLACE_MODULO: {
|
2015-10-01 22:48:48 +01:00
|
|
|
if (rhs_val == 0) {
|
|
|
|
goto zero_division;
|
|
|
|
}
|
2014-04-04 12:13:51 +01:00
|
|
|
lhs_val = mp_small_int_modulo(lhs_val, rhs_val);
|
2014-03-22 17:29:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-04-04 12:13:51 +01:00
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
case MP_BINARY_OP_POWER:
|
|
|
|
case MP_BINARY_OP_INPLACE_POWER:
|
2014-03-12 15:38:15 +00:00
|
|
|
if (rhs_val < 0) {
|
2014-06-01 13:32:54 +01:00
|
|
|
#if MICROPY_PY_BUILTINS_FLOAT
|
2014-03-12 15:38:15 +00:00
|
|
|
lhs = mp_obj_new_float(lhs_val);
|
|
|
|
goto generic_binary_op;
|
|
|
|
#else
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, "negative power with no float support");
|
2014-03-12 15:38:15 +00:00
|
|
|
#endif
|
|
|
|
} else {
|
2014-07-03 13:25:24 +01:00
|
|
|
mp_int_t ans = 1;
|
2014-03-12 15:38:15 +00:00
|
|
|
while (rhs_val > 0) {
|
|
|
|
if (rhs_val & 1) {
|
2014-04-04 12:13:51 +01:00
|
|
|
if (mp_small_int_mul_overflow(ans, lhs_val)) {
|
2014-04-04 00:16:32 +01:00
|
|
|
goto power_overflow;
|
|
|
|
}
|
2014-04-04 12:13:51 +01:00
|
|
|
ans *= lhs_val;
|
2014-04-04 00:16:32 +01:00
|
|
|
}
|
|
|
|
if (rhs_val == 1) {
|
|
|
|
break;
|
2014-03-12 15:38:15 +00:00
|
|
|
}
|
|
|
|
rhs_val /= 2;
|
2014-04-04 12:13:51 +01:00
|
|
|
if (mp_small_int_mul_overflow(lhs_val, lhs_val)) {
|
2014-04-04 00:16:32 +01:00
|
|
|
goto power_overflow;
|
|
|
|
}
|
2014-04-04 12:13:51 +01:00
|
|
|
lhs_val *= lhs_val;
|
2014-01-06 22:13:00 +00:00
|
|
|
}
|
2014-03-12 15:38:15 +00:00
|
|
|
lhs_val = ans;
|
2013-12-17 21:35:38 +00:00
|
|
|
}
|
2014-01-06 22:13:00 +00:00
|
|
|
break;
|
2014-04-04 00:16:32 +01:00
|
|
|
|
|
|
|
power_overflow:
|
|
|
|
// use higher precision
|
|
|
|
lhs = mp_obj_new_int_from_ll(MP_OBJ_SMALL_INT_VALUE(lhs));
|
|
|
|
goto generic_binary_op;
|
|
|
|
|
2015-06-13 22:00:10 +01:00
|
|
|
case MP_BINARY_OP_DIVMOD: {
|
|
|
|
if (rhs_val == 0) {
|
|
|
|
goto zero_division;
|
|
|
|
}
|
|
|
|
// to reduce stack usage we don't pass a temp array of the 2 items
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_tuple_t *tuple = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL));
|
2015-06-13 22:00:10 +01:00
|
|
|
tuple->items[0] = MP_OBJ_NEW_SMALL_INT(mp_small_int_floor_divide(lhs_val, rhs_val));
|
|
|
|
tuple->items[1] = MP_OBJ_NEW_SMALL_INT(mp_small_int_modulo(lhs_val, rhs_val));
|
2015-11-27 17:01:44 +00:00
|
|
|
return MP_OBJ_FROM_PTR(tuple);
|
2015-06-13 22:00:10 +01:00
|
|
|
}
|
|
|
|
|
2015-10-11 10:09:43 +01:00
|
|
|
case MP_BINARY_OP_LESS: return mp_obj_new_bool(lhs_val < rhs_val); break;
|
|
|
|
case MP_BINARY_OP_MORE: return mp_obj_new_bool(lhs_val > rhs_val); break;
|
|
|
|
case MP_BINARY_OP_LESS_EQUAL: return mp_obj_new_bool(lhs_val <= rhs_val); break;
|
|
|
|
case MP_BINARY_OP_MORE_EQUAL: return mp_obj_new_bool(lhs_val >= rhs_val); break;
|
2013-12-17 21:35:38 +00:00
|
|
|
|
2014-04-17 16:26:50 +01:00
|
|
|
default:
|
|
|
|
goto unsupported_op;
|
2014-01-06 22:13:00 +00:00
|
|
|
}
|
2014-01-12 15:06:25 +00:00
|
|
|
// TODO: We just should make mp_obj_new_int() inline and use that
|
2014-05-28 14:51:12 +01:00
|
|
|
if (MP_SMALL_INT_FITS(lhs_val)) {
|
2014-01-06 22:13:00 +00:00
|
|
|
return MP_OBJ_NEW_SMALL_INT(lhs_val);
|
2014-03-12 15:38:15 +00:00
|
|
|
} else {
|
|
|
|
return mp_obj_new_int(lhs_val);
|
2014-01-06 22:13:00 +00:00
|
|
|
}
|
2014-06-01 13:32:54 +01:00
|
|
|
#if MICROPY_PY_BUILTINS_FLOAT
|
2015-08-20 23:30:12 +01:00
|
|
|
} else if (mp_obj_is_float(rhs)) {
|
2014-04-10 20:08:11 +01:00
|
|
|
mp_obj_t res = mp_obj_float_binary_op(op, lhs_val, rhs);
|
|
|
|
if (res == MP_OBJ_NULL) {
|
|
|
|
goto unsupported_op;
|
|
|
|
} else {
|
|
|
|
return res;
|
|
|
|
}
|
2014-06-19 23:48:35 +01:00
|
|
|
#if MICROPY_PY_BUILTINS_COMPLEX
|
2014-03-08 15:24:39 +00:00
|
|
|
} else if (MP_OBJ_IS_TYPE(rhs, &mp_type_complex)) {
|
2014-04-10 20:08:11 +01:00
|
|
|
mp_obj_t res = mp_obj_complex_binary_op(op, lhs_val, 0, rhs);
|
|
|
|
if (res == MP_OBJ_NULL) {
|
|
|
|
goto unsupported_op;
|
|
|
|
} else {
|
|
|
|
return res;
|
|
|
|
}
|
2014-06-19 23:48:35 +01:00
|
|
|
#endif
|
2014-01-31 00:42:12 +00:00
|
|
|
#endif
|
2013-12-21 18:17:45 +00:00
|
|
|
}
|
2014-01-11 12:39:33 +00:00
|
|
|
}
|
2013-11-02 14:33:10 +00:00
|
|
|
|
2014-02-01 23:04:09 +00:00
|
|
|
/* deal with `in`
|
2014-01-11 12:39:33 +00:00
|
|
|
*
|
|
|
|
* NOTE `a in b` is `b.__contains__(a)`, hence why the generic dispatch
|
2014-02-01 23:32:29 +00:00
|
|
|
* needs to go below with swapped arguments
|
2014-01-11 12:39:33 +00:00
|
|
|
*/
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_IN) {
|
2014-01-22 14:35:10 +00:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(rhs);
|
|
|
|
if (type->binary_op != NULL) {
|
|
|
|
mp_obj_t res = type->binary_op(op, rhs, lhs);
|
2014-05-21 19:42:43 +01:00
|
|
|
if (res != MP_OBJ_NULL) {
|
2014-01-22 14:35:10 +00:00
|
|
|
return res;
|
2014-01-11 00:58:59 +00:00
|
|
|
}
|
2014-01-22 14:35:10 +00:00
|
|
|
}
|
|
|
|
if (type->getiter != NULL) {
|
|
|
|
/* second attempt, walk the iterator */
|
2016-01-09 23:14:54 +00:00
|
|
|
mp_obj_iter_buf_t iter_buf;
|
|
|
|
mp_obj_t iter = mp_getiter(rhs, &iter_buf);
|
2014-10-23 12:06:53 +01:00
|
|
|
mp_obj_t next;
|
2014-04-17 23:19:36 +01:00
|
|
|
while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
|
2014-01-22 14:35:10 +00:00
|
|
|
if (mp_obj_equal(next, lhs)) {
|
2014-02-01 23:04:09 +00:00
|
|
|
return mp_const_true;
|
2014-01-11 00:58:59 +00:00
|
|
|
}
|
2014-01-11 12:39:33 +00:00
|
|
|
}
|
2014-02-01 23:04:09 +00:00
|
|
|
return mp_const_false;
|
2014-01-11 12:39:33 +00:00
|
|
|
}
|
|
|
|
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "object not iterable");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"'%s' object is not iterable", mp_obj_get_type_str(rhs)));
|
|
|
|
}
|
2014-01-11 12:39:33 +00:00
|
|
|
}
|
|
|
|
|
2014-01-22 14:35:10 +00:00
|
|
|
// generic binary_op supplied by type
|
2014-03-12 15:38:15 +00:00
|
|
|
mp_obj_type_t *type;
|
|
|
|
generic_binary_op:
|
|
|
|
type = mp_obj_get_type(lhs);
|
2014-01-22 14:35:10 +00:00
|
|
|
if (type->binary_op != NULL) {
|
|
|
|
mp_obj_t result = type->binary_op(op, lhs, rhs);
|
2014-05-21 19:42:43 +01:00
|
|
|
if (result != MP_OBJ_NULL) {
|
2014-01-22 14:35:10 +00:00
|
|
|
return result;
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
}
|
2013-10-22 16:53:02 +01:00
|
|
|
|
2014-01-22 14:35:10 +00:00
|
|
|
// TODO implement dispatch for reverse binary ops
|
|
|
|
|
2014-04-10 20:08:11 +01:00
|
|
|
unsupported_op:
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "unsupported type for operator");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
2015-04-11 13:03:37 +01:00
|
|
|
"unsupported types for %q: '%s', '%s'",
|
|
|
|
mp_binary_op_method_name[op], mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs)));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2014-04-02 17:06:05 +01:00
|
|
|
|
|
|
|
zero_division:
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ZeroDivisionError, "division by zero");
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_call_function_0(mp_obj_t fun) {
|
|
|
|
return mp_call_function_n_kw(fun, 0, 0, NULL);
|
2013-10-10 22:06:54 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_call_function_1(mp_obj_t fun, mp_obj_t arg) {
|
|
|
|
return mp_call_function_n_kw(fun, 1, 0, &arg);
|
2013-10-10 22:06:54 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2) {
|
2013-12-21 18:17:45 +00:00
|
|
|
mp_obj_t args[2];
|
2014-01-18 14:10:48 +00:00
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
2014-03-30 13:35:08 +01:00
|
|
|
return mp_call_function_n_kw(fun, 2, 0, args);
|
2013-10-10 22:06:54 +01:00
|
|
|
}
|
|
|
|
|
2014-01-18 14:10:48 +00:00
|
|
|
// args contains, eg: arg0 arg1 key0 value0 key1 value1
|
2017-02-16 04:32:34 +00:00
|
|
|
mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2013-12-21 18:17:45 +00:00
|
|
|
// TODO improve this: fun object can specify its type and we parse here the arguments,
|
|
|
|
// passing to the function arrays of fixed and keyword arguments
|
2013-10-10 22:06:54 +01:00
|
|
|
|
2014-09-23 10:59:05 +01:00
|
|
|
DEBUG_OP_printf("calling function %p(n_args=" UINT_FMT ", n_kw=" UINT_FMT ", args=%p)\n", fun_in, n_args, n_kw, args);
|
2014-01-07 23:06:46 +00:00
|
|
|
|
2014-01-31 23:49:49 +00:00
|
|
|
// get the type
|
|
|
|
mp_obj_type_t *type = mp_obj_get_type(fun_in);
|
|
|
|
|
|
|
|
// do the call
|
|
|
|
if (type->call != NULL) {
|
2014-06-03 13:40:16 +01:00
|
|
|
return type->call(fun_in, n_args, n_kw, args);
|
2014-01-07 23:06:46 +00:00
|
|
|
}
|
2014-04-25 19:15:16 +01:00
|
|
|
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "object not callable");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"'%s' object is not callable", mp_obj_get_type_str(fun_in)));
|
|
|
|
}
|
2013-11-26 15:16:41 +00:00
|
|
|
}
|
|
|
|
|
2014-01-18 14:10:48 +00:00
|
|
|
// args contains: fun self/NULL arg(0) ... arg(n_args-2) arg(n_args-1) kw_key(0) kw_val(0) ... kw_key(n_kw-1) kw_val(n_kw-1)
|
|
|
|
// if n_args==0 and n_kw==0 then there are only fun and self/NULL
|
2017-02-16 04:32:34 +00:00
|
|
|
mp_obj_t mp_call_method_n_kw(size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2014-09-23 10:59:05 +01:00
|
|
|
DEBUG_OP_printf("call method (fun=%p, self=%p, n_args=" UINT_FMT ", n_kw=" UINT_FMT ", args=%p)\n", args[0], args[1], n_args, n_kw, args);
|
2015-11-27 17:01:44 +00:00
|
|
|
int adjust = (args[1] == MP_OBJ_NULL) ? 0 : 1;
|
2014-03-30 13:35:08 +01:00
|
|
|
return mp_call_function_n_kw(args[0], n_args + adjust, n_kw, args + 2 - adjust);
|
2013-11-26 15:16:41 +00:00
|
|
|
}
|
|
|
|
|
2015-04-01 23:31:30 +01:00
|
|
|
// This function only needs to be exposed externally when in stackless mode.
|
|
|
|
#if !MICROPY_STACKLESS
|
|
|
|
STATIC
|
|
|
|
#endif
|
2017-02-16 04:32:34 +00:00
|
|
|
void mp_call_prepare_args_n_kw_var(bool have_self, size_t n_args_n_kw, const mp_obj_t *args, mp_call_args_t *out_args) {
|
2014-03-30 21:21:24 +01:00
|
|
|
mp_obj_t fun = *args++;
|
|
|
|
mp_obj_t self = MP_OBJ_NULL;
|
|
|
|
if (have_self) {
|
|
|
|
self = *args++; // may be MP_OBJ_NULL
|
|
|
|
}
|
|
|
|
uint n_args = n_args_n_kw & 0xff;
|
|
|
|
uint n_kw = (n_args_n_kw >> 8) & 0xff;
|
2015-03-03 19:37:37 +00:00
|
|
|
mp_obj_t pos_seq = args[n_args + 2 * n_kw]; // may be MP_OBJ_NULL
|
|
|
|
mp_obj_t kw_dict = args[n_args + 2 * n_kw + 1]; // may be MP_OBJ_NULL
|
2014-03-30 21:21:24 +01:00
|
|
|
|
|
|
|
DEBUG_OP_printf("call method var (fun=%p, self=%p, n_args=%u, n_kw=%u, args=%p, seq=%p, dict=%p)\n", fun, self, n_args, n_kw, args, pos_seq, kw_dict);
|
|
|
|
|
|
|
|
// We need to create the following array of objects:
|
|
|
|
// args[0 .. n_args] unpacked(pos_seq) args[n_args .. n_args + 2 * n_kw] unpacked(kw_dict)
|
|
|
|
// TODO: optimize one day to avoid constructing new arg array? Will be hard.
|
|
|
|
|
|
|
|
// The new args array
|
|
|
|
mp_obj_t *args2;
|
|
|
|
uint args2_alloc;
|
|
|
|
uint args2_len = 0;
|
|
|
|
|
|
|
|
// Try to get a hint for the size of the kw_dict
|
|
|
|
uint kw_dict_len = 0;
|
|
|
|
if (kw_dict != MP_OBJ_NULL && MP_OBJ_IS_TYPE(kw_dict, &mp_type_dict)) {
|
|
|
|
kw_dict_len = mp_obj_dict_len(kw_dict);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Extract the pos_seq sequence to the new args array.
|
|
|
|
// Note that it can be arbitrary iterator.
|
|
|
|
if (pos_seq == MP_OBJ_NULL) {
|
|
|
|
// no sequence
|
|
|
|
|
|
|
|
// allocate memory for the new array of args
|
|
|
|
args2_alloc = 1 + n_args + 2 * (n_kw + kw_dict_len);
|
|
|
|
args2 = m_new(mp_obj_t, args2_alloc);
|
|
|
|
|
|
|
|
// copy the self
|
|
|
|
if (self != MP_OBJ_NULL) {
|
|
|
|
args2[args2_len++] = self;
|
|
|
|
}
|
|
|
|
|
|
|
|
// copy the fixed pos args
|
2014-05-10 19:36:33 +01:00
|
|
|
mp_seq_copy(args2 + args2_len, args, n_args, mp_obj_t);
|
2014-03-30 21:21:24 +01:00
|
|
|
args2_len += n_args;
|
|
|
|
|
|
|
|
} else if (MP_OBJ_IS_TYPE(pos_seq, &mp_type_tuple) || MP_OBJ_IS_TYPE(pos_seq, &mp_type_list)) {
|
|
|
|
// optimise the case of a tuple and list
|
|
|
|
|
|
|
|
// get the items
|
2014-08-30 14:04:14 +01:00
|
|
|
mp_uint_t len;
|
2014-03-30 21:21:24 +01:00
|
|
|
mp_obj_t *items;
|
|
|
|
mp_obj_get_array(pos_seq, &len, &items);
|
|
|
|
|
|
|
|
// allocate memory for the new array of args
|
|
|
|
args2_alloc = 1 + n_args + len + 2 * (n_kw + kw_dict_len);
|
|
|
|
args2 = m_new(mp_obj_t, args2_alloc);
|
|
|
|
|
|
|
|
// copy the self
|
|
|
|
if (self != MP_OBJ_NULL) {
|
|
|
|
args2[args2_len++] = self;
|
|
|
|
}
|
|
|
|
|
|
|
|
// copy the fixed and variable position args
|
2014-05-10 19:36:33 +01:00
|
|
|
mp_seq_cat(args2 + args2_len, args, n_args, items, len, mp_obj_t);
|
2014-03-30 21:21:24 +01:00
|
|
|
args2_len += n_args + len;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// generic iterator
|
|
|
|
|
|
|
|
// allocate memory for the new array of args
|
|
|
|
args2_alloc = 1 + n_args + 2 * (n_kw + kw_dict_len) + 3;
|
|
|
|
args2 = m_new(mp_obj_t, args2_alloc);
|
|
|
|
|
|
|
|
// copy the self
|
|
|
|
if (self != MP_OBJ_NULL) {
|
|
|
|
args2[args2_len++] = self;
|
|
|
|
}
|
|
|
|
|
|
|
|
// copy the fixed position args
|
2014-05-10 19:36:33 +01:00
|
|
|
mp_seq_copy(args2 + args2_len, args, n_args, mp_obj_t);
|
2015-12-03 17:59:49 +00:00
|
|
|
args2_len += n_args;
|
2014-03-30 21:21:24 +01:00
|
|
|
|
|
|
|
// extract the variable position args from the iterator
|
2016-01-09 23:14:54 +00:00
|
|
|
mp_obj_iter_buf_t iter_buf;
|
|
|
|
mp_obj_t iterable = mp_getiter(pos_seq, &iter_buf);
|
2014-03-30 21:21:24 +01:00
|
|
|
mp_obj_t item;
|
2014-04-17 23:19:36 +01:00
|
|
|
while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
|
2014-03-30 21:21:24 +01:00
|
|
|
if (args2_len >= args2_alloc) {
|
|
|
|
args2 = m_renew(mp_obj_t, args2, args2_alloc, args2_alloc * 2);
|
|
|
|
args2_alloc *= 2;
|
|
|
|
}
|
|
|
|
args2[args2_len++] = item;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// The size of the args2 array now is the number of positional args.
|
|
|
|
uint pos_args_len = args2_len;
|
|
|
|
|
|
|
|
// Copy the fixed kw args.
|
2014-05-10 19:36:33 +01:00
|
|
|
mp_seq_copy(args2 + args2_len, args + n_args, 2 * n_kw, mp_obj_t);
|
2014-03-30 21:21:24 +01:00
|
|
|
args2_len += 2 * n_kw;
|
|
|
|
|
|
|
|
// Extract (key,value) pairs from kw_dict dictionary and append to args2.
|
|
|
|
// Note that it can be arbitrary iterator.
|
|
|
|
if (kw_dict == MP_OBJ_NULL) {
|
|
|
|
// pass
|
|
|
|
} else if (MP_OBJ_IS_TYPE(kw_dict, &mp_type_dict)) {
|
|
|
|
// dictionary
|
|
|
|
mp_map_t *map = mp_obj_dict_get_map(kw_dict);
|
|
|
|
assert(args2_len + 2 * map->used <= args2_alloc); // should have enough, since kw_dict_len is in this case hinted correctly above
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < map->alloc; i++) {
|
2014-12-21 16:24:09 +00:00
|
|
|
if (MP_MAP_SLOT_IS_FILLED(map, i)) {
|
2016-04-21 16:51:36 +01:00
|
|
|
// the key must be a qstr, so intern it if it's a string
|
|
|
|
mp_obj_t key = map->table[i].key;
|
|
|
|
if (MP_OBJ_IS_TYPE(key, &mp_type_str)) {
|
|
|
|
key = mp_obj_str_intern(key);
|
|
|
|
}
|
|
|
|
args2[args2_len++] = key;
|
2014-03-30 21:21:24 +01:00
|
|
|
args2[args2_len++] = map->table[i].value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2016-05-07 22:02:46 +01:00
|
|
|
// generic mapping:
|
|
|
|
// - call keys() to get an iterable of all keys in the mapping
|
|
|
|
// - call __getitem__ for each key to get the corresponding value
|
|
|
|
|
|
|
|
// get the keys iterable
|
|
|
|
mp_obj_t dest[3];
|
|
|
|
mp_load_method(kw_dict, MP_QSTR_keys, dest);
|
2017-02-13 04:44:31 +00:00
|
|
|
mp_obj_t iterable = mp_getiter(mp_call_method_n_kw(0, 0, dest), NULL);
|
2016-05-07 22:02:46 +01:00
|
|
|
|
|
|
|
mp_obj_t key;
|
|
|
|
while ((key = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
|
|
|
|
// expand size of args array if needed
|
2014-03-30 21:21:24 +01:00
|
|
|
if (args2_len + 1 >= args2_alloc) {
|
|
|
|
uint new_alloc = args2_alloc * 2;
|
|
|
|
if (new_alloc < 4) {
|
|
|
|
new_alloc = 4;
|
|
|
|
}
|
|
|
|
args2 = m_renew(mp_obj_t, args2, args2_alloc, new_alloc);
|
|
|
|
args2_alloc = new_alloc;
|
|
|
|
}
|
2016-05-07 22:02:46 +01:00
|
|
|
|
2016-04-21 16:51:36 +01:00
|
|
|
// the key must be a qstr, so intern it if it's a string
|
|
|
|
if (MP_OBJ_IS_TYPE(key, &mp_type_str)) {
|
|
|
|
key = mp_obj_str_intern(key);
|
|
|
|
}
|
2016-05-07 22:02:46 +01:00
|
|
|
|
|
|
|
// get the value corresponding to the key
|
|
|
|
mp_load_method(kw_dict, MP_QSTR___getitem__, dest);
|
|
|
|
dest[2] = key;
|
|
|
|
mp_obj_t value = mp_call_method_n_kw(1, 0, dest);
|
|
|
|
|
|
|
|
// store the key/value pair in the argument array
|
2016-04-21 16:51:36 +01:00
|
|
|
args2[args2_len++] = key;
|
2016-05-07 22:02:46 +01:00
|
|
|
args2[args2_len++] = value;
|
2014-03-30 21:21:24 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-27 23:14:45 +00:00
|
|
|
out_args->fun = fun;
|
|
|
|
out_args->args = args2;
|
|
|
|
out_args->n_args = pos_args_len;
|
|
|
|
out_args->n_kw = (args2_len - pos_args_len) / 2;
|
|
|
|
out_args->n_alloc = args2_alloc;
|
|
|
|
}
|
|
|
|
|
2017-02-16 04:32:34 +00:00
|
|
|
mp_obj_t mp_call_method_n_kw_var(bool have_self, size_t n_args_n_kw, const mp_obj_t *args) {
|
2015-04-01 23:31:30 +01:00
|
|
|
mp_call_args_t out_args;
|
2015-03-27 23:14:45 +00:00
|
|
|
mp_call_prepare_args_n_kw_var(have_self, n_args_n_kw, args, &out_args);
|
|
|
|
|
|
|
|
mp_obj_t res = mp_call_function_n_kw(out_args.fun, out_args.n_args, out_args.n_kw, out_args.args);
|
|
|
|
m_del(mp_obj_t, out_args.args, out_args.n_alloc);
|
2014-03-30 21:21:24 +01:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2014-01-18 23:42:49 +00:00
|
|
|
// unpacked items are stored in reverse order into the array pointed to by items
|
2017-02-16 04:32:34 +00:00
|
|
|
void mp_unpack_sequence(mp_obj_t seq_in, size_t num, mp_obj_t *items) {
|
2014-08-30 14:04:14 +01:00
|
|
|
mp_uint_t seq_len;
|
2014-03-29 13:43:38 +00:00
|
|
|
if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &mp_type_list)) {
|
2013-12-21 18:17:45 +00:00
|
|
|
mp_obj_t *seq_items;
|
2017-03-04 11:29:20 +00:00
|
|
|
mp_obj_get_array(seq_in, &seq_len, &seq_items);
|
2013-12-21 18:17:45 +00:00
|
|
|
if (seq_len < num) {
|
2014-02-01 22:54:06 +00:00
|
|
|
goto too_short;
|
2013-12-21 18:17:45 +00:00
|
|
|
} else if (seq_len > num) {
|
2014-02-01 22:54:06 +00:00
|
|
|
goto too_long;
|
2013-12-21 18:17:45 +00:00
|
|
|
}
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < num; i++) {
|
2014-01-18 23:42:49 +00:00
|
|
|
items[i] = seq_items[num - 1 - i];
|
|
|
|
}
|
2013-11-26 15:16:41 +00:00
|
|
|
} else {
|
2016-01-09 23:14:54 +00:00
|
|
|
mp_obj_iter_buf_t iter_buf;
|
|
|
|
mp_obj_t iterable = mp_getiter(seq_in, &iter_buf);
|
2014-02-01 22:54:06 +00:00
|
|
|
|
|
|
|
for (seq_len = 0; seq_len < num; seq_len++) {
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t el = mp_iternext(iterable);
|
2014-04-17 23:19:36 +01:00
|
|
|
if (el == MP_OBJ_STOP_ITERATION) {
|
2014-02-01 22:54:06 +00:00
|
|
|
goto too_short;
|
|
|
|
}
|
|
|
|
items[num - 1 - seq_len] = el;
|
|
|
|
}
|
2014-04-17 23:19:36 +01:00
|
|
|
if (mp_iternext(iterable) != MP_OBJ_STOP_ITERATION) {
|
2014-02-01 22:54:06 +00:00
|
|
|
goto too_long;
|
|
|
|
}
|
2013-11-26 15:16:41 +00:00
|
|
|
}
|
2014-02-01 22:54:06 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
too_short:
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, "wrong number of values to unpack");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
|
2016-03-14 22:40:39 +00:00
|
|
|
"need more than %d values to unpack", (int)seq_len));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2014-02-01 22:54:06 +00:00
|
|
|
too_long:
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, "wrong number of values to unpack");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
|
2016-03-14 22:40:39 +00:00
|
|
|
"too many values to unpack (expected %d)", (int)num));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2013-11-26 15:16:41 +00:00
|
|
|
}
|
|
|
|
|
2014-04-08 17:51:47 +01:00
|
|
|
// unpacked items are stored in reverse order into the array pointed to by items
|
2017-02-16 04:32:34 +00:00
|
|
|
void mp_unpack_ex(mp_obj_t seq_in, size_t num_in, mp_obj_t *items) {
|
|
|
|
size_t num_left = num_in & 0xff;
|
|
|
|
size_t num_right = (num_in >> 8) & 0xff;
|
2014-09-23 10:59:05 +01:00
|
|
|
DEBUG_OP_printf("unpack ex " UINT_FMT " " UINT_FMT "\n", num_left, num_right);
|
2014-08-30 14:04:14 +01:00
|
|
|
mp_uint_t seq_len;
|
2014-04-08 17:51:47 +01:00
|
|
|
if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &mp_type_list)) {
|
|
|
|
mp_obj_t *seq_items;
|
2017-03-04 11:29:20 +00:00
|
|
|
mp_obj_get_array(seq_in, &seq_len, &seq_items);
|
2014-04-08 17:51:47 +01:00
|
|
|
if (seq_len < num_left + num_right) {
|
|
|
|
goto too_short;
|
|
|
|
}
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < num_right; i++) {
|
2014-04-08 17:51:47 +01:00
|
|
|
items[i] = seq_items[seq_len - 1 - i];
|
|
|
|
}
|
|
|
|
items[num_right] = mp_obj_new_list(seq_len - num_left - num_right, seq_items + num_left);
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < num_left; i++) {
|
2014-04-08 17:51:47 +01:00
|
|
|
items[num_right + 1 + i] = seq_items[num_left - 1 - i];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Generic iterable; this gets a bit messy: we unpack known left length to the
|
|
|
|
// items destination array, then the rest to a dynamically created list. Once the
|
|
|
|
// iterable is exhausted, we take from this list for the right part of the items.
|
|
|
|
// TODO Improve to waste less memory in the dynamically created list.
|
2017-02-13 04:44:31 +00:00
|
|
|
mp_obj_t iterable = mp_getiter(seq_in, NULL);
|
2014-04-08 17:51:47 +01:00
|
|
|
mp_obj_t item;
|
|
|
|
for (seq_len = 0; seq_len < num_left; seq_len++) {
|
|
|
|
item = mp_iternext(iterable);
|
2014-04-17 23:19:36 +01:00
|
|
|
if (item == MP_OBJ_STOP_ITERATION) {
|
2014-04-08 17:51:47 +01:00
|
|
|
goto too_short;
|
|
|
|
}
|
|
|
|
items[num_left + num_right + 1 - 1 - seq_len] = item;
|
|
|
|
}
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_list_t *rest = MP_OBJ_TO_PTR(mp_obj_new_list(0, NULL));
|
2014-04-17 23:19:36 +01:00
|
|
|
while ((item = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_list_append(MP_OBJ_FROM_PTR(rest), item);
|
2014-04-08 17:51:47 +01:00
|
|
|
}
|
2014-08-30 15:17:47 +01:00
|
|
|
if (rest->len < num_right) {
|
2014-04-08 17:51:47 +01:00
|
|
|
goto too_short;
|
|
|
|
}
|
2015-11-27 17:01:44 +00:00
|
|
|
items[num_right] = MP_OBJ_FROM_PTR(rest);
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < num_right; i++) {
|
2014-08-30 15:17:47 +01:00
|
|
|
items[num_right - 1 - i] = rest->items[rest->len - num_right + i];
|
2014-04-08 17:51:47 +01:00
|
|
|
}
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_list_set_len(MP_OBJ_FROM_PTR(rest), rest->len - num_right);
|
2014-04-08 17:51:47 +01:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
too_short:
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, "wrong number of values to unpack");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
|
2016-03-14 22:40:39 +00:00
|
|
|
"need more than %d values to unpack", (int)seq_len));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2014-04-08 17:51:47 +01:00
|
|
|
}
|
|
|
|
|
2014-04-06 00:12:03 +01:00
|
|
|
mp_obj_t mp_load_attr(mp_obj_t base, qstr attr) {
|
2014-01-09 20:57:50 +00:00
|
|
|
DEBUG_OP_printf("load attr %p.%s\n", base, qstr_str(attr));
|
2014-04-06 00:12:03 +01:00
|
|
|
// use load_method
|
2014-01-09 20:57:50 +00:00
|
|
|
mp_obj_t dest[2];
|
2014-04-06 00:12:03 +01:00
|
|
|
mp_load_method(base, attr, dest);
|
|
|
|
if (dest[1] == MP_OBJ_NULL) {
|
2014-01-09 20:57:50 +00:00
|
|
|
// load_method returned just a normal attribute
|
2014-01-18 14:10:48 +00:00
|
|
|
return dest[0];
|
2014-01-09 20:57:50 +00:00
|
|
|
} else {
|
|
|
|
// load_method returned a method, so build a bound method object
|
|
|
|
return mp_obj_new_bound_meth(dest[0], dest[1]);
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-19 13:49:10 +01:00
|
|
|
#if MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG
|
|
|
|
|
|
|
|
// The following "checked fun" type is local to the mp_convert_member_lookup
|
|
|
|
// function, and serves to check that the first argument to a builtin function
|
|
|
|
// has the correct type.
|
|
|
|
|
|
|
|
typedef struct _mp_obj_checked_fun_t {
|
|
|
|
mp_obj_base_t base;
|
|
|
|
const mp_obj_type_t *type;
|
|
|
|
mp_obj_t fun;
|
|
|
|
} mp_obj_checked_fun_t;
|
|
|
|
|
2016-01-03 09:59:18 +00:00
|
|
|
STATIC mp_obj_t checked_fun_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_obj_checked_fun_t *self = MP_OBJ_TO_PTR(self_in);
|
2015-06-19 13:49:10 +01:00
|
|
|
if (n_args > 0) {
|
|
|
|
const mp_obj_type_t *arg0_type = mp_obj_get_type(args[0]);
|
|
|
|
if (arg0_type != self->type) {
|
|
|
|
if (MICROPY_ERROR_REPORTING != MICROPY_ERROR_REPORTING_DETAILED) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "argument has wrong type");
|
2015-06-19 13:49:10 +01:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"argument should be a '%q' not a '%q'", self->type->name, arg0_type->name));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return mp_call_function_n_kw(self->fun, n_args, n_kw, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
STATIC const mp_obj_type_t mp_type_checked_fun = {
|
|
|
|
{ &mp_type_type },
|
|
|
|
.name = MP_QSTR_function,
|
|
|
|
.call = checked_fun_call,
|
|
|
|
};
|
|
|
|
|
|
|
|
STATIC mp_obj_t mp_obj_new_checked_fun(const mp_obj_type_t *type, mp_obj_t fun) {
|
|
|
|
mp_obj_checked_fun_t *o = m_new_obj(mp_obj_checked_fun_t);
|
|
|
|
o->base.type = &mp_type_checked_fun;
|
|
|
|
o->type = type;
|
|
|
|
o->fun = fun;
|
2015-11-27 17:01:44 +00:00
|
|
|
return MP_OBJ_FROM_PTR(o);
|
2015-06-19 13:49:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG
|
|
|
|
|
2015-03-21 14:21:54 +00:00
|
|
|
// Given a member that was extracted from an instance, convert it correctly
|
|
|
|
// and put the result in the dest[] array for a possible method call.
|
|
|
|
// Conversion means dealing with static/class methods, callables, and values.
|
|
|
|
// see http://docs.python.org/3/howto/descriptor.html
|
|
|
|
void mp_convert_member_lookup(mp_obj_t self, const mp_obj_type_t *type, mp_obj_t member, mp_obj_t *dest) {
|
|
|
|
if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) {
|
|
|
|
// return just the function
|
2015-11-27 17:01:44 +00:00
|
|
|
dest[0] = ((mp_obj_static_class_method_t*)MP_OBJ_TO_PTR(member))->fun;
|
2015-03-21 14:21:54 +00:00
|
|
|
} else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
|
|
|
|
// return a bound method, with self being the type of this object
|
2015-12-09 17:30:01 +00:00
|
|
|
// this type should be the type of the original instance, not the base
|
|
|
|
// type (which is what is passed in the 'type' argument to this function)
|
|
|
|
if (self != MP_OBJ_NULL) {
|
|
|
|
type = mp_obj_get_type(self);
|
|
|
|
}
|
2015-11-27 17:01:44 +00:00
|
|
|
dest[0] = ((mp_obj_static_class_method_t*)MP_OBJ_TO_PTR(member))->fun;
|
|
|
|
dest[1] = MP_OBJ_FROM_PTR(type);
|
2015-03-21 14:21:54 +00:00
|
|
|
} else if (MP_OBJ_IS_TYPE(member, &mp_type_type)) {
|
|
|
|
// Don't try to bind types (even though they're callable)
|
|
|
|
dest[0] = member;
|
2015-12-26 12:41:31 +00:00
|
|
|
} else if (MP_OBJ_IS_FUN(member)
|
|
|
|
|| (MP_OBJ_IS_OBJ(member)
|
|
|
|
&& (((mp_obj_base_t*)MP_OBJ_TO_PTR(member))->type->name == MP_QSTR_closure
|
|
|
|
|| ((mp_obj_base_t*)MP_OBJ_TO_PTR(member))->type->name == MP_QSTR_generator))) {
|
|
|
|
// only functions, closures and generators objects can be bound to self
|
2015-06-19 13:49:10 +01:00
|
|
|
#if MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG
|
2016-10-18 01:49:27 +01:00
|
|
|
const mp_obj_type_t *m_type = ((mp_obj_base_t*)MP_OBJ_TO_PTR(member))->type;
|
|
|
|
if (self == MP_OBJ_NULL
|
|
|
|
&& (m_type == &mp_type_fun_builtin_0
|
|
|
|
|| m_type == &mp_type_fun_builtin_1
|
|
|
|
|| m_type == &mp_type_fun_builtin_2
|
|
|
|
|| m_type == &mp_type_fun_builtin_3
|
|
|
|
|| m_type == &mp_type_fun_builtin_var)) {
|
2015-06-19 13:49:10 +01:00
|
|
|
// we extracted a builtin method without a first argument, so we must
|
|
|
|
// wrap this function in a type checker
|
|
|
|
dest[0] = mp_obj_new_checked_fun(type, member);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
// return a bound method, with self being this object
|
|
|
|
dest[0] = member;
|
|
|
|
dest[1] = self;
|
|
|
|
}
|
2015-03-21 14:21:54 +00:00
|
|
|
} else {
|
|
|
|
// class member is a value, so just return that value
|
|
|
|
dest[0] = member;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-25 00:17:36 +00:00
|
|
|
// no attribute found, returns: dest[0] == MP_OBJ_NULL, dest[1] == MP_OBJ_NULL
|
|
|
|
// normal attribute found, returns: dest[0] == <attribute>, dest[1] == MP_OBJ_NULL
|
|
|
|
// method attribute found, returns: dest[0] == <method>, dest[1] == <self>
|
2015-03-20 22:58:07 +00:00
|
|
|
void mp_load_method_maybe(mp_obj_t obj, qstr attr, mp_obj_t *dest) {
|
2014-01-09 20:57:50 +00:00
|
|
|
// clear output to indicate no attribute/method found yet
|
|
|
|
dest[0] = MP_OBJ_NULL;
|
|
|
|
dest[1] = MP_OBJ_NULL;
|
|
|
|
|
|
|
|
// get the type
|
2015-03-20 22:58:07 +00:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(obj);
|
2014-01-09 20:57:50 +00:00
|
|
|
|
2014-03-31 22:57:56 +01:00
|
|
|
// look for built-in names
|
|
|
|
if (0) {
|
2014-03-31 18:30:08 +01:00
|
|
|
#if MICROPY_CPYTHON_COMPAT
|
2014-03-31 22:57:56 +01:00
|
|
|
} else if (attr == MP_QSTR___class__) {
|
|
|
|
// a.__class__ is equivalent to type(a)
|
2015-11-27 17:01:44 +00:00
|
|
|
dest[0] = MP_OBJ_FROM_PTR(type);
|
2014-03-31 18:30:08 +01:00
|
|
|
#endif
|
2014-03-31 22:57:56 +01:00
|
|
|
|
|
|
|
} else if (attr == MP_QSTR___next__ && type->iternext != NULL) {
|
2015-11-27 17:01:44 +00:00
|
|
|
dest[0] = MP_OBJ_FROM_PTR(&mp_builtin_next_obj);
|
2015-03-20 22:58:07 +00:00
|
|
|
dest[1] = obj;
|
2014-03-31 22:57:56 +01:00
|
|
|
|
2015-04-01 15:10:50 +01:00
|
|
|
} else if (type->attr != NULL) {
|
2014-03-31 22:57:56 +01:00
|
|
|
// this type can do its own load, so call it
|
2015-04-01 15:10:50 +01:00
|
|
|
type->attr(obj, attr, dest);
|
2014-03-31 22:57:56 +01:00
|
|
|
|
|
|
|
} else if (type->locals_dict != NULL) {
|
|
|
|
// generic method lookup
|
|
|
|
// this is a lookup in the object (ie not class or type)
|
2015-11-27 17:01:44 +00:00
|
|
|
assert(type->locals_dict->base.type == &mp_type_dict); // Micro Python restriction, for now
|
|
|
|
mp_map_t *locals_map = &type->locals_dict->map;
|
2014-03-31 22:57:56 +01:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
|
|
|
|
if (elem != NULL) {
|
2015-03-21 14:21:54 +00:00
|
|
|
mp_convert_member_lookup(obj, type, elem->value, dest);
|
2013-11-02 23:58:14 +00:00
|
|
|
}
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
2014-01-25 00:17:36 +00:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
|
2014-01-25 00:17:36 +00:00
|
|
|
DEBUG_OP_printf("load method %p.%s\n", base, qstr_str(attr));
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_load_method_maybe(base, attr, dest);
|
2013-10-09 23:10:10 +01:00
|
|
|
|
2014-01-25 00:17:36 +00:00
|
|
|
if (dest[0] == MP_OBJ_NULL) {
|
2014-01-09 20:57:50 +00:00
|
|
|
// no attribute/method called attr
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_AttributeError, "no such attribute");
|
2014-01-09 20:57:50 +00:00
|
|
|
} else {
|
2014-11-06 17:36:16 +00:00
|
|
|
// following CPython, we give a more detailed error message for type objects
|
|
|
|
if (MP_OBJ_IS_TYPE(base, &mp_type_type)) {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
|
2015-04-11 13:03:37 +01:00
|
|
|
"type object '%q' has no attribute '%q'",
|
2015-11-27 17:01:44 +00:00
|
|
|
((mp_obj_type_t*)MP_OBJ_TO_PTR(base))->name, attr));
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
|
2015-04-11 13:03:37 +01:00
|
|
|
"'%s' object has no attribute '%q'",
|
|
|
|
mp_obj_get_type_str(base), attr));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2014-01-09 20:57:50 +00:00
|
|
|
}
|
|
|
|
}
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
|
2013-10-18 19:58:12 +01:00
|
|
|
DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
|
2014-01-09 20:57:50 +00:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(base);
|
2015-04-01 15:10:50 +01:00
|
|
|
if (type->attr != NULL) {
|
|
|
|
mp_obj_t dest[2] = {MP_OBJ_SENTINEL, value};
|
|
|
|
type->attr(base, attr, dest);
|
|
|
|
if (dest[0] == MP_OBJ_NULL) {
|
|
|
|
// success
|
2014-01-09 20:57:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_AttributeError, "no such attribute");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
|
2015-04-11 13:03:37 +01:00
|
|
|
"'%s' object has no attribute '%q'",
|
|
|
|
mp_obj_get_type_str(base), attr));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
|
|
|
|
2016-01-09 23:14:54 +00:00
|
|
|
mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
|
2014-05-11 18:32:39 +01:00
|
|
|
assert(o_in);
|
2017-01-17 04:38:32 +00:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(o_in);
|
|
|
|
|
|
|
|
// Check for native getiter which is the identity. We handle this case explicitly
|
|
|
|
// so we don't unnecessarily allocate any RAM for the iter_buf, which won't be used.
|
|
|
|
if (type->getiter == mp_identity_getiter) {
|
|
|
|
return o_in;
|
|
|
|
}
|
2015-02-15 01:10:13 +00:00
|
|
|
|
2016-01-09 23:14:54 +00:00
|
|
|
// if caller did not provide a buffer then allocate one on the heap
|
|
|
|
if (iter_buf == NULL) {
|
|
|
|
iter_buf = m_new_obj(mp_obj_iter_buf_t);
|
|
|
|
}
|
|
|
|
|
2015-02-15 01:10:13 +00:00
|
|
|
// check for native getiter (corresponds to __iter__)
|
2014-01-22 14:35:10 +00:00
|
|
|
if (type->getiter != NULL) {
|
2016-01-09 23:14:54 +00:00
|
|
|
mp_obj_t iter = type->getiter(o_in, iter_buf);
|
2015-02-15 01:10:13 +00:00
|
|
|
if (iter != MP_OBJ_NULL) {
|
|
|
|
return iter;
|
2014-05-11 18:32:39 +01:00
|
|
|
}
|
2015-02-15 01:10:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// check for __getitem__
|
|
|
|
mp_obj_t dest[2];
|
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___getitem__, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// __getitem__ exists, create and return an iterator
|
2016-01-09 23:14:54 +00:00
|
|
|
return mp_obj_new_getitem_iter(dest, iter_buf);
|
2015-02-15 01:10:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// object not iterable
|
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "object not iterable");
|
2013-10-15 22:25:17 +01:00
|
|
|
} else {
|
2015-02-15 01:10:13 +00:00
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"'%s' object is not iterable", mp_obj_get_type_str(o_in)));
|
2013-12-21 18:17:45 +00:00
|
|
|
}
|
|
|
|
}
|
2013-10-16 20:39:12 +01:00
|
|
|
|
2014-04-17 23:19:36 +01:00
|
|
|
// may return MP_OBJ_STOP_ITERATION as an optimisation instead of raise StopIteration()
|
2014-03-26 19:27:58 +00:00
|
|
|
// may also raise StopIteration()
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
|
2014-01-22 14:35:10 +00:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(o_in);
|
|
|
|
if (type->iternext != NULL) {
|
|
|
|
return type->iternext(o_in);
|
2013-12-21 18:17:45 +00:00
|
|
|
} else {
|
2014-03-26 18:37:06 +00:00
|
|
|
// check for __next__ method
|
|
|
|
mp_obj_t dest[2];
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___next__, dest);
|
2014-03-26 18:37:06 +00:00
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// __next__ exists, call it and return its result
|
2014-03-30 13:35:08 +01:00
|
|
|
return mp_call_method_n_kw(0, 0, dest);
|
2014-03-26 18:37:06 +00:00
|
|
|
} else {
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "object not an iterator");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"'%s' object is not an iterator", mp_obj_get_type_str(o_in)));
|
|
|
|
}
|
2014-03-26 18:37:06 +00:00
|
|
|
}
|
2014-02-15 16:10:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-17 23:19:36 +01:00
|
|
|
// will always return MP_OBJ_STOP_ITERATION instead of raising StopIteration() (or any subclass thereof)
|
2014-03-26 19:27:58 +00:00
|
|
|
// may raise other exceptions
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_iternext(mp_obj_t o_in) {
|
2015-06-03 22:19:41 +01:00
|
|
|
MP_STACK_CHECK(); // enumerate, filter, map and zip can recursively call mp_iternext
|
2014-03-26 19:27:58 +00:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(o_in);
|
|
|
|
if (type->iternext != NULL) {
|
|
|
|
return type->iternext(o_in);
|
|
|
|
} else {
|
|
|
|
// check for __next__ method
|
|
|
|
mp_obj_t dest[2];
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___next__, dest);
|
2014-03-26 19:27:58 +00:00
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// __next__ exists, call it and return its result
|
|
|
|
nlr_buf_t nlr;
|
|
|
|
if (nlr_push(&nlr) == 0) {
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t ret = mp_call_method_n_kw(0, 0, dest);
|
2014-03-26 19:27:58 +00:00
|
|
|
nlr_pop();
|
|
|
|
return ret;
|
|
|
|
} else {
|
2015-11-27 17:01:44 +00:00
|
|
|
if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type), MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
|
2014-04-17 23:19:36 +01:00
|
|
|
return MP_OBJ_STOP_ITERATION;
|
2014-03-26 19:27:58 +00:00
|
|
|
} else {
|
2015-11-27 17:01:44 +00:00
|
|
|
nlr_jump(nlr.ret_val);
|
2014-03-26 19:27:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2014-11-06 17:36:16 +00:00
|
|
|
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, "object not an iterator");
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
|
|
|
"'%s' object is not an iterator", mp_obj_get_type_str(o_in)));
|
|
|
|
}
|
2014-03-26 19:27:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 21:14:55 +01:00
|
|
|
// TODO: Unclear what to do with StopIterarion exception here.
|
|
|
|
mp_vm_return_kind_t mp_resume(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t throw_value, mp_obj_t *ret_val) {
|
2014-03-31 02:19:12 +01:00
|
|
|
assert((send_value != MP_OBJ_NULL) ^ (throw_value != MP_OBJ_NULL));
|
2014-03-30 21:14:55 +01:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(self_in);
|
|
|
|
|
|
|
|
if (type == &mp_type_gen_instance) {
|
|
|
|
return mp_obj_gen_resume(self_in, send_value, throw_value, ret_val);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type->iternext != NULL && send_value == mp_const_none) {
|
|
|
|
mp_obj_t ret = type->iternext(self_in);
|
2015-05-09 22:41:34 +01:00
|
|
|
if (ret != MP_OBJ_STOP_ITERATION) {
|
2014-03-30 21:14:55 +01:00
|
|
|
*ret_val = ret;
|
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
} else {
|
|
|
|
// Emulate raise StopIteration()
|
|
|
|
// Special case, handled in vm.c
|
|
|
|
*ret_val = MP_OBJ_NULL;
|
|
|
|
return MP_VM_RETURN_NORMAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mp_obj_t dest[3]; // Reserve slot for send() arg
|
|
|
|
|
2016-11-14 22:10:34 +00:00
|
|
|
// Python instance iterator protocol
|
2014-03-30 21:14:55 +01:00
|
|
|
if (send_value == mp_const_none) {
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR___next__, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
2016-11-14 22:10:34 +00:00
|
|
|
nlr_buf_t nlr;
|
|
|
|
if (nlr_push(&nlr) == 0) {
|
|
|
|
*ret_val = mp_call_method_n_kw(0, 0, dest);
|
|
|
|
nlr_pop();
|
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
} else {
|
2016-11-14 22:40:23 +00:00
|
|
|
*ret_val = MP_OBJ_FROM_PTR(nlr.ret_val);
|
2016-11-14 22:10:34 +00:00
|
|
|
return MP_VM_RETURN_EXCEPTION;
|
|
|
|
}
|
2014-03-30 21:14:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-14 22:10:34 +00:00
|
|
|
// Either python instance generator protocol, or native object
|
|
|
|
// generator protocol.
|
2014-03-30 21:14:55 +01:00
|
|
|
if (send_value != MP_OBJ_NULL) {
|
|
|
|
mp_load_method(self_in, MP_QSTR_send, dest);
|
|
|
|
dest[2] = send_value;
|
2016-11-14 22:10:34 +00:00
|
|
|
// TODO: This should have exception wrapping like __next__ case
|
|
|
|
// above. Not done right away to think how to optimize native
|
|
|
|
// generators better, see:
|
|
|
|
// https://github.com/micropython/micropython/issues/2628
|
2014-03-30 21:14:55 +01:00
|
|
|
*ret_val = mp_call_method_n_kw(1, 0, dest);
|
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
}
|
|
|
|
|
2017-01-16 13:09:56 +00:00
|
|
|
assert(throw_value != MP_OBJ_NULL);
|
|
|
|
{
|
2015-11-27 17:01:44 +00:00
|
|
|
if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(mp_obj_get_type(throw_value)), MP_OBJ_FROM_PTR(&mp_type_GeneratorExit))) {
|
2014-03-30 21:14:55 +01:00
|
|
|
mp_load_method_maybe(self_in, MP_QSTR_close, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
runtime: Add TODO for mp_resume() on handling .close().
Exceptions in .close() should be ignored (dumped to sys.stderr, not
propagated), but in uPy, they are propagated. Fix would require
nlr-wrapping .close() call, which is expensive. Bu on the other hand,
.close() is not called often, so maybe that's not too bad (depends,
if it's finally called and that causes stack overflow, there's nothing
good in that). And yet on another hand, .close() can be implemented to
catch exceptions on its side, and that should be the right choice.
2015-05-10 00:39:45 +01:00
|
|
|
// TODO: Exceptions raised in close() are not propagated,
|
|
|
|
// printed to sys.stderr
|
2014-03-30 21:14:55 +01:00
|
|
|
*ret_val = mp_call_method_n_kw(0, 0, dest);
|
|
|
|
// We assume one can't "yield" from close()
|
|
|
|
return MP_VM_RETURN_NORMAL;
|
|
|
|
}
|
2017-01-16 13:10:49 +00:00
|
|
|
} else {
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR_throw, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
dest[2] = throw_value;
|
|
|
|
*ret_val = mp_call_method_n_kw(1, 0, dest);
|
|
|
|
// If .throw() method returned, we assume it's value to yield
|
|
|
|
// - any exception would be thrown with nlr_raise().
|
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
}
|
2014-03-31 02:14:30 +01:00
|
|
|
}
|
|
|
|
// If there's nowhere to throw exception into, then we assume that object
|
|
|
|
// is just incapable to handle it, so any exception thrown into it
|
|
|
|
// will be propagated up. This behavior is approved by test_pep380.py
|
|
|
|
// test_delegation_of_close_to_non_generator(),
|
|
|
|
// test_delegating_throw_to_non_generator()
|
|
|
|
*ret_val = throw_value;
|
|
|
|
return MP_VM_RETURN_EXCEPTION;
|
2014-03-30 21:14:55 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_make_raise_obj(mp_obj_t o) {
|
2014-02-15 16:10:44 +00:00
|
|
|
DEBUG_printf("raise %p\n", o);
|
|
|
|
if (mp_obj_is_exception_type(o)) {
|
|
|
|
// o is an exception type (it is derived from BaseException (or is BaseException))
|
|
|
|
// create and return a new exception instance by calling o
|
2014-02-15 21:05:25 +00:00
|
|
|
// TODO could have an option to disable traceback, then builtin exceptions (eg TypeError)
|
|
|
|
// could have const instances in ROM which we return here instead
|
2014-03-30 13:35:08 +01:00
|
|
|
return mp_call_function_n_kw(o, 0, 0, NULL);
|
2014-02-15 16:10:44 +00:00
|
|
|
} else if (mp_obj_is_exception_instance(o)) {
|
|
|
|
// o is an instance of an exception, so use it as the exception
|
|
|
|
return o;
|
|
|
|
} else {
|
|
|
|
// o cannot be used as an exception, so return a type error (which will be raised by the caller)
|
|
|
|
return mp_obj_new_exception_msg(&mp_type_TypeError, "exceptions must derive from BaseException");
|
2013-10-15 22:25:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
|
2015-06-26 22:32:35 +01:00
|
|
|
DEBUG_printf("import name '%s' level=%d\n", qstr_str(name), MP_OBJ_SMALL_INT_VALUE(level));
|
2014-02-06 20:31:44 +00:00
|
|
|
|
2013-12-10 17:27:24 +00:00
|
|
|
// build args array
|
2013-12-21 18:17:45 +00:00
|
|
|
mp_obj_t args[5];
|
2014-01-22 14:35:10 +00:00
|
|
|
args[0] = MP_OBJ_NEW_QSTR(name);
|
2013-12-21 18:17:45 +00:00
|
|
|
args[1] = mp_const_none; // TODO should be globals
|
|
|
|
args[2] = mp_const_none; // TODO should be locals
|
2013-12-10 17:27:24 +00:00
|
|
|
args[3] = fromlist;
|
|
|
|
args[4] = level; // must be 0; we don't yet support other values
|
|
|
|
|
|
|
|
// TODO lookup __import__ and call that instead of going straight to builtin implementation
|
2013-12-21 18:17:45 +00:00
|
|
|
return mp_builtin___import__(5, args);
|
2013-12-10 17:27:24 +00:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
|
2014-02-06 20:31:44 +00:00
|
|
|
DEBUG_printf("import from %p %s\n", module, qstr_str(name));
|
|
|
|
|
2014-04-11 22:15:19 +01:00
|
|
|
mp_obj_t dest[2];
|
|
|
|
|
|
|
|
mp_load_method_maybe(module, name, dest);
|
|
|
|
|
|
|
|
if (dest[1] != MP_OBJ_NULL) {
|
|
|
|
// Hopefully we can't import bound method from an object
|
|
|
|
import_error:
|
2015-04-11 13:03:37 +01:00
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError, "cannot import name %q", name));
|
2014-04-11 22:15:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
return dest[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
// See if it's a package, then can try FS import
|
2014-10-25 19:04:13 +01:00
|
|
|
if (!mp_obj_is_package(module)) {
|
2014-04-11 22:15:19 +01:00
|
|
|
goto import_error;
|
2013-12-10 17:27:24 +00:00
|
|
|
}
|
2014-04-11 22:15:19 +01:00
|
|
|
|
|
|
|
mp_load_method_maybe(module, MP_QSTR___name__, dest);
|
2014-08-30 14:19:41 +01:00
|
|
|
mp_uint_t pkg_name_len;
|
2014-04-11 22:15:19 +01:00
|
|
|
const char *pkg_name = mp_obj_str_get_data(dest[0], &pkg_name_len);
|
|
|
|
|
2014-05-05 11:18:27 +01:00
|
|
|
const uint dot_name_len = pkg_name_len + 1 + qstr_len(name);
|
|
|
|
char *dot_name = alloca(dot_name_len);
|
2014-04-11 22:15:19 +01:00
|
|
|
memcpy(dot_name, pkg_name, pkg_name_len);
|
|
|
|
dot_name[pkg_name_len] = '.';
|
|
|
|
memcpy(dot_name + pkg_name_len + 1, qstr_str(name), qstr_len(name));
|
2014-05-05 11:18:27 +01:00
|
|
|
qstr dot_name_q = qstr_from_strn(dot_name, dot_name_len);
|
2014-04-11 22:15:19 +01:00
|
|
|
|
|
|
|
mp_obj_t args[5];
|
|
|
|
args[0] = MP_OBJ_NEW_QSTR(dot_name_q);
|
|
|
|
args[1] = mp_const_none; // TODO should be globals
|
|
|
|
args[2] = mp_const_none; // TODO should be locals
|
|
|
|
args[3] = mp_const_true; // Pass sentinel "non empty" value to force returning of leaf module
|
2014-04-12 00:47:46 +01:00
|
|
|
args[4] = MP_OBJ_NEW_SMALL_INT(0);
|
2014-04-11 22:15:19 +01:00
|
|
|
|
|
|
|
// TODO lookup __import__ and call that instead of going straight to builtin implementation
|
|
|
|
return mp_builtin___import__(5, args);
|
2013-12-10 17:27:24 +00:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
void mp_import_all(mp_obj_t module) {
|
2014-02-13 22:22:06 +00:00
|
|
|
DEBUG_printf("import all %p\n", module);
|
|
|
|
|
2014-04-18 02:11:19 +01:00
|
|
|
// TODO: Support __all__
|
2015-11-27 17:01:44 +00:00
|
|
|
mp_map_t *map = mp_obj_dict_get_map(MP_OBJ_FROM_PTR(mp_obj_module_get_globals(module)));
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < map->alloc; i++) {
|
2014-04-05 21:53:54 +01:00
|
|
|
if (MP_MAP_SLOT_IS_FILLED(map, i)) {
|
2014-04-18 02:11:19 +01:00
|
|
|
qstr name = MP_OBJ_QSTR_VALUE(map->table[i].key);
|
|
|
|
if (*qstr_str(name) != '_') {
|
|
|
|
mp_store_name(name, map->table[i].value);
|
|
|
|
}
|
2014-02-13 22:22:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-18 12:35:44 +00:00
|
|
|
#if MICROPY_ENABLE_COMPILER
|
|
|
|
|
2014-10-05 20:13:34 +01:00
|
|
|
// this is implemented in this file so it can optimise access to locals/globals
|
|
|
|
mp_obj_t mp_parse_compile_execute(mp_lexer_t *lex, mp_parse_input_kind_t parse_input_kind, mp_obj_dict_t *globals, mp_obj_dict_t *locals) {
|
2015-02-07 18:33:58 +00:00
|
|
|
// save context
|
|
|
|
mp_obj_dict_t *volatile old_globals = mp_globals_get();
|
|
|
|
mp_obj_dict_t *volatile old_locals = mp_locals_get();
|
2014-10-05 20:13:34 +01:00
|
|
|
|
2015-02-07 18:33:58 +00:00
|
|
|
// set new context
|
2014-10-05 20:13:34 +01:00
|
|
|
mp_globals_set(globals);
|
|
|
|
mp_locals_set(locals);
|
|
|
|
|
|
|
|
nlr_buf_t nlr;
|
|
|
|
if (nlr_push(&nlr) == 0) {
|
2015-02-07 18:33:58 +00:00
|
|
|
qstr source_name = lex->source_name;
|
2015-09-23 10:50:43 +01:00
|
|
|
mp_parse_tree_t parse_tree = mp_parse(lex, parse_input_kind);
|
|
|
|
mp_obj_t module_fun = mp_compile(&parse_tree, source_name, MP_EMIT_OPT_NONE, false);
|
2015-02-07 18:33:58 +00:00
|
|
|
|
|
|
|
mp_obj_t ret;
|
|
|
|
if (MICROPY_PY_BUILTINS_COMPILE && globals == NULL) {
|
|
|
|
// for compile only, return value is the module function
|
|
|
|
ret = module_fun;
|
|
|
|
} else {
|
|
|
|
// execute module function and get return value
|
|
|
|
ret = mp_call_function_0(module_fun);
|
|
|
|
}
|
|
|
|
|
|
|
|
// finish nlr block, restore context and return value
|
2014-10-05 20:13:34 +01:00
|
|
|
nlr_pop();
|
|
|
|
mp_globals_set(old_globals);
|
|
|
|
mp_locals_set(old_locals);
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
// exception; restore context and re-raise same exception
|
|
|
|
mp_globals_set(old_globals);
|
|
|
|
mp_locals_set(old_locals);
|
2015-11-27 17:01:44 +00:00
|
|
|
nlr_jump(nlr.ret_val);
|
2014-10-05 20:13:34 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-18 12:35:44 +00:00
|
|
|
#endif // MICROPY_ENABLE_COMPILER
|
|
|
|
|
2014-09-23 18:10:17 +01:00
|
|
|
void *m_malloc_fail(size_t num_bytes) {
|
2016-01-08 13:49:58 +00:00
|
|
|
DEBUG_printf("memory allocation failed, allocating %u bytes\n", (uint)num_bytes);
|
2014-10-09 16:44:43 +01:00
|
|
|
if (0) {
|
|
|
|
// dummy
|
|
|
|
#if MICROPY_ENABLE_GC
|
|
|
|
} else if (gc_is_locked()) {
|
2016-10-17 02:17:37 +01:00
|
|
|
mp_raise_msg(&mp_type_MemoryError, "memory allocation failed, heap is locked");
|
2014-10-09 16:44:43 +01:00
|
|
|
#endif
|
2014-10-07 08:50:20 +01:00
|
|
|
} else {
|
2014-10-09 16:44:43 +01:00
|
|
|
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError,
|
2016-01-08 13:49:58 +00:00
|
|
|
"memory allocation failed, allocating %u bytes", (uint)num_bytes));
|
2014-10-07 08:50:20 +01:00
|
|
|
}
|
2014-04-04 11:52:59 +01:00
|
|
|
}
|
|
|
|
|
2016-08-12 19:26:12 +01:00
|
|
|
NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg) {
|
2017-02-24 14:57:25 +00:00
|
|
|
if (msg == NULL) {
|
|
|
|
nlr_raise(mp_obj_new_exception(exc_type));
|
|
|
|
} else {
|
|
|
|
nlr_raise(mp_obj_new_exception_msg(exc_type, msg));
|
|
|
|
}
|
2016-08-12 19:26:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
NORETURN void mp_raise_ValueError(const char *msg) {
|
|
|
|
mp_raise_msg(&mp_type_ValueError, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
NORETURN void mp_raise_TypeError(const char *msg) {
|
|
|
|
mp_raise_msg(&mp_type_TypeError, msg);
|
|
|
|
}
|
|
|
|
|
2016-10-07 03:31:59 +01:00
|
|
|
NORETURN void mp_raise_OSError(int errno_) {
|
|
|
|
nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(errno_)));
|
|
|
|
}
|
|
|
|
|
2014-06-07 21:22:41 +01:00
|
|
|
NORETURN void mp_not_implemented(const char *msg) {
|
2016-08-12 19:26:12 +01:00
|
|
|
mp_raise_msg(&mp_type_NotImplementedError, msg);
|
2014-06-07 21:22:41 +01:00
|
|
|
}
|