2014-05-03 23:27:38 +01:00
|
|
|
/*
|
2017-06-30 08:22:17 +01:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 23:27:38 +01:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
2019-01-31 08:55:21 +00:00
|
|
|
* Copyright (c) 2014-2018 Paul Sokolovsky
|
2014-05-03 23:27:38 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2020-02-11 00:48:28 +00:00
|
|
|
#include <stdarg.h>
|
2013-10-04 19:53:11 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
2015-01-01 20:27:54 +00:00
|
|
|
#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"
|
2019-11-13 10:05:34 +00:00
|
|
|
#include "py/objtype.h"
|
2015-01-01 20:27:54 +00:00
|
|
|
#include "py/objmodule.h"
|
|
|
|
#include "py/objgenerator.h"
|
|
|
|
#include "py/smallint.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
|
|
|
|
2017-07-24 17:55:14 +01:00
|
|
|
#if MICROPY_DEBUG_VERBOSE // 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;
|
2017-02-16 07:05:06 +00:00
|
|
|
#if MICROPY_ENABLE_SCHEDULER
|
|
|
|
MP_STATE_VM(sched_state) = MP_SCHED_IDLE;
|
2019-03-21 00:52:10 +00:00
|
|
|
MP_STATE_VM(sched_idx) = 0;
|
|
|
|
MP_STATE_VM(sched_len) = 0;
|
2017-02-16 07:05:06 +00:00
|
|
|
#endif
|
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;
|
2017-04-10 08:07:26 +01:00
|
|
|
MP_STATE_VM(mp_kbd_exception).args = (mp_obj_tuple_t *)&mp_const_empty_tuple_obj;
|
2016-12-15 02:00:19 +00:00
|
|
|
#endif
|
|
|
|
|
2018-04-04 05:24:03 +01:00
|
|
|
#if MICROPY_ENABLE_COMPILER
|
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;
|
2019-08-23 02:20:50 +01:00
|
|
|
#if MICROPY_EMIT_NATIVE
|
|
|
|
MP_STATE_VM(default_emit_opt) = MP_EMIT_OPT_NONE;
|
|
|
|
#endif
|
2018-04-04 05:24:03 +01:00
|
|
|
#endif
|
2014-05-12 23:07:34 +01:00
|
|
|
|
2017-01-26 12:30:38 +00:00
|
|
|
// init global module dict
|
2021-03-22 10:20:22 +00:00
|
|
|
mp_obj_dict_init(&MP_STATE_VM(mp_loaded_modules_dict), MICROPY_LOADED_MODULES_DICT_SIZE);
|
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())
|
2017-03-24 07:41:11 +00:00
|
|
|
mp_locals_set(&MP_STATE_VM(dict_main));
|
|
|
|
mp_globals_set(&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
|
|
|
|
2020-07-27 14:52:38 +01:00
|
|
|
#if MICROPY_PERSISTENT_CODE_TRACK_RELOC_CODE
|
|
|
|
MP_STATE_VM(track_reloc_code_list) = MP_OBJ_NULL;
|
|
|
|
#endif
|
|
|
|
|
2017-10-13 10:01:57 +01:00
|
|
|
#if MICROPY_PY_OS_DUPTERM
|
|
|
|
for (size_t i = 0; i < MICROPY_PY_OS_DUPTERM; ++i) {
|
|
|
|
MP_STATE_VM(dupterm_objs[i]) = MP_OBJ_NULL;
|
|
|
|
}
|
|
|
|
#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
|
|
|
|
|
2019-08-05 14:06:41 +01:00
|
|
|
#if MICROPY_PY_SYS_ATEXIT
|
|
|
|
MP_STATE_VM(sys_exitfunc) = mp_const_none;
|
|
|
|
#endif
|
|
|
|
|
2019-08-14 15:09:36 +01:00
|
|
|
#if MICROPY_PY_SYS_SETTRACE
|
|
|
|
MP_STATE_THREAD(prof_trace_callback) = MP_OBJ_NULL;
|
|
|
|
MP_STATE_THREAD(prof_callback_is_executing) = false;
|
|
|
|
MP_STATE_THREAD(current_code_state) = NULL;
|
|
|
|
#endif
|
|
|
|
|
2019-07-23 15:49:06 +01:00
|
|
|
#if MICROPY_PY_BLUETOOTH
|
|
|
|
MP_STATE_VM(bluetooth) = MP_OBJ_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
|
|
|
|
|
2020-01-09 22:35:13 +00:00
|
|
|
// call port specific initialization if any
|
|
|
|
#ifdef MICROPY_PORT_INIT_FUNC
|
|
|
|
MICROPY_PORT_INIT_FUNC;
|
|
|
|
#endif
|
|
|
|
|
2016-05-26 11:42:53 +01:00
|
|
|
MP_THREAD_GIL_ENTER();
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2014-03-30 13:35:08 +01:00
|
|
|
void mp_deinit(void) {
|
2018-12-27 03:20:31 +00:00
|
|
|
MP_THREAD_GIL_EXIT();
|
|
|
|
|
2014-05-08 09:56:33 +01:00
|
|
|
// call port specific deinitialization if any
|
2020-01-09 22:35:13 +00:00
|
|
|
#ifdef MICROPY_PORT_DEINIT_FUNC
|
2014-05-08 09:56:33 +01:00
|
|
|
MICROPY_PORT_DEINIT_FUNC;
|
2020-01-09 22:35:13 +00:00
|
|
|
#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
|
2017-03-24 07:41:11 +00:00
|
|
|
if (mp_locals_get() != mp_globals_get()) {
|
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&mp_locals_get()->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));
|
2017-03-24 07:41:11 +00:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&mp_globals_get()->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) {
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg(&mp_type_NameError, MP_ERROR_TEXT("name not defined"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg_varg(&mp_type_NameError, MP_ERROR_TEXT("name '%q' isn't defined"), qst);
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
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);
|
2017-03-24 07:41:11 +00:00
|
|
|
mp_obj_dict_store(MP_OBJ_FROM_PTR(mp_locals_get()), 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
|
2017-03-24 07:41:11 +00:00
|
|
|
mp_obj_dict_delete(MP_OBJ_FROM_PTR(mp_locals_get()), 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);
|
2017-03-24 07:41:11 +00:00
|
|
|
mp_obj_dict_store(MP_OBJ_FROM_PTR(mp_globals_get()), 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
|
2017-03-24 07:41:11 +00:00
|
|
|
mp_obj_dict_delete(MP_OBJ_FROM_PTR(mp_globals_get()), MP_OBJ_NEW_QSTR(qst));
|
2014-04-08 21:11:49 +01:00
|
|
|
}
|
|
|
|
|
2017-08-29 04:04:01 +01:00
|
|
|
mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) {
|
2017-12-08 23:26:21 +00:00
|
|
|
DEBUG_OP_printf("unary " UINT_FMT " %q %p\n", op, mp_unary_op_method_name[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);
|
2019-01-30 07:49:52 +00:00
|
|
|
} 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:
|
2018-08-29 15:59:36 +01:00
|
|
|
case MP_UNARY_OP_INT:
|
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);
|
|
|
|
}
|
2017-09-17 22:06:43 +01:00
|
|
|
case MP_UNARY_OP_ABS:
|
|
|
|
if (val >= 0) {
|
|
|
|
return arg;
|
|
|
|
} else if (val == MP_SMALL_INT_MIN) {
|
|
|
|
// check for overflow
|
|
|
|
return mp_obj_new_int(-val);
|
|
|
|
} else {
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(-val);
|
|
|
|
}
|
2014-03-12 15:38:15 +00:00
|
|
|
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
|
|
|
}
|
2019-01-30 07:49:52 +00:00
|
|
|
} else if (op == MP_UNARY_OP_HASH && mp_obj_is_str_or_bytes(arg)) {
|
2015-05-11 13:25:19 +01:00
|
|
|
// 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 {
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(arg);
|
2014-01-23 18:27:51 +00:00
|
|
|
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
|
|
|
}
|
2018-08-29 15:59:36 +01:00
|
|
|
// With MP_UNARY_OP_INT, mp_unary_op() becomes a fallback for mp_obj_get_int().
|
|
|
|
// In this case provide a more focused error message to not confuse, e.g. chr(1.0)
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2019-09-26 13:52:04 +01:00
|
|
|
if (op == MP_UNARY_OP_INT) {
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("can't convert to int"));
|
2014-11-06 17:36:16 +00:00
|
|
|
} else {
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("unsupported type for operator"));
|
2014-11-06 17:36:16 +00:00
|
|
|
}
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
if (op == MP_UNARY_OP_INT) {
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("can't convert %s to int"), mp_obj_get_type_str(arg));
|
2019-09-26 13:52:04 +01:00
|
|
|
} else {
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("unsupported type for %q: '%s'"),
|
2019-09-26 13:52:04 +01:00
|
|
|
mp_unary_op_method_name[op], mp_obj_get_type_str(arg));
|
|
|
|
}
|
|
|
|
#endif
|
2013-11-02 19:47:57 +00:00
|
|
|
}
|
2013-10-04 19:53:11 +01:00
|
|
|
}
|
|
|
|
|
2017-08-29 04:04:01 +01:00
|
|
|
mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) {
|
2017-12-08 23:26:21 +00:00
|
|
|
DEBUG_OP_printf("binary " UINT_FMT " %q %p %p\n", op, mp_binary_op_method_name[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) {
|
2019-12-31 22:19:12 +00:00
|
|
|
// mp_obj_equal_not_equal supports a bunch of shortcuts
|
|
|
|
return mp_obj_equal_not_equal(op, lhs, rhs);
|
2014-01-11 10:47:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
}
|
2019-01-30 07:49:52 +00: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
|
|
|
}
|
|
|
|
|
2019-01-30 07:49:52 +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);
|
2019-01-30 07:49:52 +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
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("negative shift count"));
|
2021-02-04 04:32:59 +00:00
|
|
|
} else if (rhs_val >= (mp_int_t)(sizeof(lhs_val) * MP_BITS_PER_BYTE)
|
2021-02-04 04:27:53 +00:00
|
|
|
|| 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
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("negative shift count"));
|
2014-03-12 15:38:15 +00:00
|
|
|
} else {
|
|
|
|
// standard precision is enough for right-shift
|
2021-02-04 04:32:59 +00:00
|
|
|
if (rhs_val >= (mp_int_t)(sizeof(lhs_val) * MP_BITS_PER_BYTE)) {
|
2014-11-02 00:39:41 +00:00
|
|
|
// Shifting to big amounts is underfined behavior
|
|
|
|
// in C and is CPU-dependent; propagate sign bit.
|
2021-02-04 04:32:59 +00:00
|
|
|
rhs_val = sizeof(lhs_val) * MP_BITS_PER_BYTE - 1;
|
2014-11-02 00:39:41 +00:00
|
|
|
}
|
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
|
|
|
}
|
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
|
2020-04-13 19:56:31 +01:00
|
|
|
return mp_obj_float_binary_op(op, (mp_float_t)lhs_val, rhs);
|
2014-03-12 15:38:15 +00:00
|
|
|
#else
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("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
|
|
|
}
|
|
|
|
|
2017-12-19 02:13:21 +00:00
|
|
|
case MP_BINARY_OP_LESS:
|
|
|
|
return mp_obj_new_bool(lhs_val < rhs_val);
|
|
|
|
case MP_BINARY_OP_MORE:
|
|
|
|
return mp_obj_new_bool(lhs_val > rhs_val);
|
|
|
|
case MP_BINARY_OP_LESS_EQUAL:
|
|
|
|
return mp_obj_new_bool(lhs_val <= rhs_val);
|
|
|
|
case MP_BINARY_OP_MORE_EQUAL:
|
|
|
|
return mp_obj_new_bool(lhs_val >= rhs_val);
|
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
|
|
|
}
|
2018-07-14 14:05:25 +01:00
|
|
|
// This is an inlined version of mp_obj_new_int, for speed
|
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 {
|
2018-07-14 14:05:25 +01:00
|
|
|
return mp_obj_new_int_from_ll(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)) {
|
2020-04-13 19:56:31 +01:00
|
|
|
mp_obj_t res = mp_obj_float_binary_op(op, (mp_float_t)lhs_val, rhs);
|
2014-04-10 20:08:11 +01:00
|
|
|
if (res == MP_OBJ_NULL) {
|
|
|
|
goto unsupported_op;
|
|
|
|
} else {
|
|
|
|
return res;
|
|
|
|
}
|
2020-02-27 01:35:44 +00:00
|
|
|
#endif
|
2014-06-19 23:48:35 +01:00
|
|
|
#if MICROPY_PY_BUILTINS_COMPLEX
|
2019-01-30 07:49:52 +00:00
|
|
|
} else if (mp_obj_is_type(rhs, &mp_type_complex)) {
|
2020-04-13 19:56:31 +01:00
|
|
|
mp_obj_t res = mp_obj_complex_binary_op(op, (mp_float_t)lhs_val, 0, rhs);
|
2014-04-10 20:08:11 +01:00
|
|
|
if (res == MP_OBJ_NULL) {
|
|
|
|
goto unsupported_op;
|
|
|
|
} else {
|
|
|
|
return res;
|
|
|
|
}
|
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
|
|
|
|
2017-11-24 02:04:24 +00:00
|
|
|
// Convert MP_BINARY_OP_IN to MP_BINARY_OP_CONTAINS with swapped args.
|
2014-03-30 13:35:08 +01:00
|
|
|
if (op == MP_BINARY_OP_IN) {
|
2017-11-24 02:04:24 +00:00
|
|
|
op = MP_BINARY_OP_CONTAINS;
|
|
|
|
mp_obj_t temp = lhs;
|
|
|
|
lhs = rhs;
|
|
|
|
rhs = temp;
|
2014-01-11 12:39:33 +00:00
|
|
|
}
|
|
|
|
|
2014-01-22 14:35:10 +00:00
|
|
|
// generic binary_op supplied by type
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type;
|
2014-03-12 15:38:15 +00:00
|
|
|
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
|
|
|
|
2017-09-10 15:05:20 +01:00
|
|
|
#if MICROPY_PY_REVERSE_SPECIAL_METHODS
|
2019-10-29 01:08:07 +00:00
|
|
|
if (op >= MP_BINARY_OP_OR && op <= MP_BINARY_OP_POWER) {
|
2017-09-10 15:05:20 +01:00
|
|
|
mp_obj_t t = rhs;
|
|
|
|
rhs = lhs;
|
|
|
|
lhs = t;
|
2019-10-29 01:08:07 +00:00
|
|
|
op += MP_BINARY_OP_REVERSE_OR - MP_BINARY_OP_OR;
|
|
|
|
goto generic_binary_op;
|
|
|
|
} else if (op >= MP_BINARY_OP_REVERSE_OR) {
|
2017-09-10 15:05:20 +01:00
|
|
|
// Convert __rop__ back to __op__ for error message
|
2019-10-29 01:08:07 +00:00
|
|
|
mp_obj_t t = rhs;
|
|
|
|
rhs = lhs;
|
|
|
|
lhs = t;
|
2017-09-10 15:05:20 +01:00
|
|
|
op -= MP_BINARY_OP_REVERSE_OR - MP_BINARY_OP_OR;
|
|
|
|
}
|
|
|
|
#endif
|
2014-01-22 14:35:10 +00:00
|
|
|
|
2017-11-24 02:04:24 +00:00
|
|
|
if (op == MP_BINARY_OP_CONTAINS) {
|
|
|
|
// If type didn't support containment then explicitly walk the iterator.
|
|
|
|
// mp_getiter will raise the appropriate exception if lhs is not iterable.
|
|
|
|
mp_obj_iter_buf_t iter_buf;
|
|
|
|
mp_obj_t iter = mp_getiter(lhs, &iter_buf);
|
|
|
|
mp_obj_t next;
|
|
|
|
while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
|
|
|
|
if (mp_obj_equal(next, rhs)) {
|
|
|
|
return mp_const_true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return mp_const_false;
|
|
|
|
}
|
|
|
|
|
2014-04-10 20:08:11 +01:00
|
|
|
unsupported_op:
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("unsupported type for operator"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("unsupported types for %q: '%s', '%s'"),
|
2019-09-26 13:52:04 +01:00
|
|
|
mp_binary_op_method_name[op], mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs));
|
|
|
|
#endif
|
2014-04-02 17:06:05 +01:00
|
|
|
|
|
|
|
zero_division:
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide 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
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(fun_in);
|
2014-01-31 23:49:49 +00:00
|
|
|
|
|
|
|
// 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
|
|
|
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("object not callable"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("'%s' object isn't callable"), mp_obj_get_type_str(fun_in));
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
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;
|
2019-01-30 07:49:52 +00:00
|
|
|
if (kw_dict != MP_OBJ_NULL && mp_obj_is_type(kw_dict, &mp_type_dict)) {
|
2014-03-30 21:21:24 +01:00
|
|
|
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);
|
2017-11-26 12:48:23 +00:00
|
|
|
args2 = mp_nonlocal_alloc(args2_alloc * sizeof(mp_obj_t));
|
2014-03-30 21:21:24 +01:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
2019-01-30 07:49:52 +00:00
|
|
|
} else if (mp_obj_is_type(pos_seq, &mp_type_tuple) || mp_obj_is_type(pos_seq, &mp_type_list)) {
|
2014-03-30 21:21:24 +01:00
|
|
|
// optimise the case of a tuple and list
|
|
|
|
|
|
|
|
// get the items
|
2017-03-25 08:35:08 +00:00
|
|
|
size_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);
|
2017-11-26 12:48:23 +00:00
|
|
|
args2 = mp_nonlocal_alloc(args2_alloc * sizeof(mp_obj_t));
|
2014-03-30 21:21:24 +01:00
|
|
|
|
|
|
|
// 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;
|
2017-11-26 12:48:23 +00:00
|
|
|
args2 = mp_nonlocal_alloc(args2_alloc * sizeof(mp_obj_t));
|
2014-03-30 21:21:24 +01:00
|
|
|
|
|
|
|
// 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) {
|
2017-11-26 12:48:23 +00:00
|
|
|
args2 = mp_nonlocal_realloc(args2, args2_alloc * sizeof(mp_obj_t), args2_alloc * 2 * sizeof(mp_obj_t));
|
2014-03-30 21:21:24 +01:00
|
|
|
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
|
2019-01-30 07:49:52 +00:00
|
|
|
} else if (mp_obj_is_type(kw_dict, &mp_type_dict)) {
|
2014-03-30 21:21:24 +01:00
|
|
|
// 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++) {
|
2019-01-30 10:57:29 +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;
|
2019-01-30 07:49:52 +00:00
|
|
|
if (!mp_obj_is_qstr(key)) {
|
2018-03-30 01:09:00 +01:00
|
|
|
key = mp_obj_str_intern_checked(key);
|
2016-04-21 16:51:36 +01:00
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
2017-11-26 12:48:23 +00:00
|
|
|
args2 = mp_nonlocal_realloc(args2, args2_alloc * sizeof(mp_obj_t), new_alloc * sizeof(mp_obj_t));
|
2014-03-30 21:21:24 +01:00
|
|
|
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
|
2019-01-30 07:49:52 +00:00
|
|
|
if (!mp_obj_is_qstr(key)) {
|
2018-03-30 01:09:00 +01:00
|
|
|
key = mp_obj_str_intern_checked(key);
|
2016-04-21 16:51:36 +01:00
|
|
|
}
|
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);
|
2017-11-26 12:48:23 +00:00
|
|
|
mp_nonlocal_free(out_args.args, out_args.n_alloc * sizeof(mp_obj_t));
|
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) {
|
2017-03-25 08:35:08 +00:00
|
|
|
size_t seq_len;
|
2019-01-30 07:49:52 +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:
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("need more than %d values to unpack"), (int)seq_len);
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
2014-02-01 22:54:06 +00:00
|
|
|
too_long:
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("too many values to unpack (expected %d)"), (int)num);
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
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);
|
2017-03-25 08:35:08 +00:00
|
|
|
size_t seq_len;
|
2019-01-30 07:49:52 +00:00
|
|
|
if (mp_obj_is_type(seq_in, &mp_type_tuple) || mp_obj_is_type(seq_in, &mp_type_list)) {
|
2019-04-15 02:30:19 +01:00
|
|
|
// Make the seq variable volatile so the compiler keeps a reference to it,
|
|
|
|
// since if it's a tuple then seq_items points to the interior of the GC cell
|
|
|
|
// and mp_obj_new_list may trigger a GC which doesn't trace this and reclaims seq.
|
|
|
|
volatile mp_obj_t seq = seq_in;
|
2014-04-08 17:51:47 +01:00
|
|
|
mp_obj_t *seq_items;
|
2019-04-15 02:30:19 +01:00
|
|
|
mp_obj_get_array(seq, &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];
|
|
|
|
}
|
2019-04-15 02:30:19 +01:00
|
|
|
seq = MP_OBJ_NULL;
|
2014-04-08 17:51:47 +01:00
|
|
|
} 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:
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("need more than %d values to unpack"), (int)seq_len);
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
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) {
|
2019-09-26 13:52:04 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING != MICROPY_ERROR_REPORTING_DETAILED
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("argument has wrong type"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("argument should be a '%q' not a '%q'"), self->type->name, arg0_type->name);
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
2015-06-19 13:49:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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 },
|
2020-06-28 00:39:20 +01:00
|
|
|
.flags = MP_TYPE_FLAG_BINDS_SELF,
|
2015-06-19 13:49:10 +01:00
|
|
|
.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
|
2020-06-28 00:39:20 +01:00
|
|
|
// and also https://mail.python.org/pipermail/python-dev/2015-March/138950.html
|
2015-03-21 14:21:54 +00:00
|
|
|
void mp_convert_member_lookup(mp_obj_t self, const mp_obj_type_t *type, mp_obj_t member, mp_obj_t *dest) {
|
2020-06-28 00:39:20 +01:00
|
|
|
if (mp_obj_is_obj(member)) {
|
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;
|
2020-06-28 00:39:20 +01:00
|
|
|
if (m_type->flags & MP_TYPE_FLAG_BINDS_SELF) {
|
|
|
|
// `member` is a function that binds self as its first argument.
|
|
|
|
if (m_type->flags & MP_TYPE_FLAG_BUILTIN_FUN) {
|
|
|
|
// `member` is a built-in function, which has special behaviour.
|
|
|
|
if (mp_obj_is_instance_type(type)) {
|
|
|
|
// Built-in functions on user types always behave like a staticmethod.
|
|
|
|
dest[0] = member;
|
|
|
|
}
|
|
|
|
#if MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG
|
|
|
|
else if (self == MP_OBJ_NULL && type != &mp_type_object) {
|
|
|
|
// `member` is a built-in method without a first argument, so wrap
|
|
|
|
// it in a type checker that will check self when it's supplied.
|
|
|
|
// Note that object will do its own checking so shouldn't be wrapped.
|
|
|
|
dest[0] = mp_obj_new_checked_fun(type, member);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
else {
|
|
|
|
// Return a (built-in) bound method, with self being this object.
|
|
|
|
dest[0] = member;
|
|
|
|
dest[1] = self;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Return a bound method, with self being this object.
|
|
|
|
dest[0] = member;
|
|
|
|
dest[1] = self;
|
|
|
|
}
|
|
|
|
} else if (m_type == &mp_type_staticmethod) {
|
|
|
|
// `member` is a staticmethod, return the function that it wraps.
|
|
|
|
dest[0] = ((mp_obj_static_class_method_t *)MP_OBJ_TO_PTR(member))->fun;
|
|
|
|
} else if (m_type == &mp_type_classmethod) {
|
|
|
|
// `member` is a classmethod, return a bound method with self being the type of
|
|
|
|
// this object. 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);
|
|
|
|
}
|
|
|
|
dest[0] = ((mp_obj_static_class_method_t *)MP_OBJ_TO_PTR(member))->fun;
|
|
|
|
dest[1] = MP_OBJ_FROM_PTR(type);
|
|
|
|
} else {
|
|
|
|
// `member` is a value, so just return that value.
|
2015-06-19 13:49:10 +01:00
|
|
|
dest[0] = member;
|
|
|
|
}
|
2015-03-21 14:21:54 +00:00
|
|
|
} else {
|
2020-06-28 00:39:20 +01:00
|
|
|
// `member` is a value, so just return that value.
|
2015-03-21 14:21:54 +00:00
|
|
|
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
|
2020-01-09 00:01:14 +00:00
|
|
|
const 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
|
2020-02-19 13:17:13 +00:00
|
|
|
#if MICROPY_CPYTHON_COMPAT
|
2019-05-05 04:29:43 +01:00
|
|
|
if (attr == MP_QSTR___class__) {
|
2014-03-31 22:57:56 +01:00
|
|
|
// a.__class__ is equivalent to type(a)
|
2015-11-27 17:01:44 +00:00
|
|
|
dest[0] = MP_OBJ_FROM_PTR(type);
|
2020-02-19 13:17:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-05-05 04:29:43 +01:00
|
|
|
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)
|
2017-06-30 08:22:17 +01:00
|
|
|
assert(type->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
|
2015-11-27 17:01:44 +00:00
|
|
|
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
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
// following CPython, we give a more detailed error message for type objects
|
|
|
|
if (mp_obj_is_type(base, &mp_type_type)) {
|
|
|
|
mp_raise_msg_varg(&mp_type_AttributeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("type object '%q' has no attribute '%q'"),
|
2019-09-26 13:52:04 +01:00
|
|
|
((mp_obj_type_t *)MP_OBJ_TO_PTR(base))->name, attr);
|
2014-01-09 20:57:50 +00:00
|
|
|
} else {
|
2019-09-26 13:52:04 +01:00
|
|
|
mp_raise_msg_varg(&mp_type_AttributeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("'%s' object has no attribute '%q'"),
|
2019-09-26 13:52:04 +01:00
|
|
|
mp_obj_get_type_str(base), attr);
|
2014-01-09 20:57:50 +00:00
|
|
|
}
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
2014-01-09 20:57:50 +00:00
|
|
|
}
|
2013-10-09 23:10:10 +01:00
|
|
|
}
|
|
|
|
|
2018-05-10 14:00:04 +01:00
|
|
|
// Acts like mp_load_method_maybe but catches AttributeError, and all other exceptions if requested
|
|
|
|
void mp_load_method_protected(mp_obj_t obj, qstr attr, mp_obj_t *dest, bool catch_all_exc) {
|
|
|
|
nlr_buf_t nlr;
|
|
|
|
if (nlr_push(&nlr) == 0) {
|
|
|
|
mp_load_method_maybe(obj, attr, dest);
|
|
|
|
nlr_pop();
|
|
|
|
} else {
|
|
|
|
if (!catch_all_exc
|
|
|
|
&& !mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t *)nlr.ret_val)->type),
|
|
|
|
MP_OBJ_FROM_PTR(&mp_type_AttributeError))) {
|
|
|
|
// Re-raise the exception
|
|
|
|
nlr_raise(MP_OBJ_FROM_PTR(nlr.ret_val));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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);
|
2020-01-09 00:01:14 +00:00
|
|
|
const 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
|
|
|
}
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_AttributeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("'%s' object has no attribute '%q'"),
|
2019-09-26 13:52:04 +01:00
|
|
|
mp_obj_get_type_str(base), attr);
|
|
|
|
#endif
|
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);
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(o_in);
|
2017-01-17 04:38:32 +00:00
|
|
|
|
|
|
|
// 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
|
|
|
|
|
|
|
// check for native getiter (corresponds to __iter__)
|
2014-01-22 14:35:10 +00:00
|
|
|
if (type->getiter != NULL) {
|
2019-11-13 10:05:34 +00:00
|
|
|
if (iter_buf == NULL && type->getiter != mp_obj_instance_getiter) {
|
|
|
|
// if caller did not provide a buffer then allocate one on the heap
|
|
|
|
// mp_obj_instance_getiter is special, it will allocate only if needed
|
|
|
|
iter_buf = m_new_obj(mp_obj_iter_buf_t);
|
|
|
|
}
|
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
|
2019-11-13 10:05:34 +00:00
|
|
|
if (iter_buf == NULL) {
|
|
|
|
// if caller did not provide a buffer then allocate one on the heap
|
|
|
|
iter_buf = m_new_obj(mp_obj_iter_buf_t);
|
|
|
|
}
|
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
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("object not iterable"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("'%s' object isn't iterable"), mp_obj_get_type_str(o_in));
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
|
|
|
|
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) {
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(o_in);
|
2014-01-22 14:35:10 +00:00
|
|
|
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 {
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("object not an iterator"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("'%s' object isn't an iterator"), mp_obj_get_type_str(o_in));
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
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
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(o_in);
|
2014-03-26 19:27:58 +00:00
|
|
|
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 {
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_TypeError(MP_ERROR_TEXT("object not an iterator"));
|
2019-09-26 13:52:04 +01:00
|
|
|
#else
|
|
|
|
mp_raise_msg_varg(&mp_type_TypeError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("'%s' object isn't an iterator"), mp_obj_get_type_str(o_in));
|
2019-09-26 13:52:04 +01:00
|
|
|
#endif
|
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));
|
2020-01-09 00:01:14 +00:00
|
|
|
const mp_obj_type_t *type = mp_obj_get_type(self_in);
|
2014-03-30 21:14:55 +01:00
|
|
|
|
|
|
|
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);
|
2018-02-27 04:48:09 +00:00
|
|
|
*ret_val = ret;
|
2015-05-09 22:41:34 +01:00
|
|
|
if (ret != MP_OBJ_STOP_ITERATION) {
|
2014-03-30 21:14:55 +01:00
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
} else {
|
|
|
|
// Emulate raise StopIteration()
|
|
|
|
// Special case, handled in vm.c
|
|
|
|
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) {
|
2018-09-28 13:16:56 +01:00
|
|
|
*ret_val = mp_call_method_n_kw(0, 0, dest);
|
|
|
|
return MP_VM_RETURN_YIELD;
|
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;
|
|
|
|
*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()
|
2019-09-30 07:06:20 +01:00
|
|
|
if (mp_obj_exception_match(throw_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
|
|
|
|
// PEP479: if StopIteration is raised inside a generator it is replaced with RuntimeError
|
2020-03-02 11:35:22 +00:00
|
|
|
*ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator raised StopIteration"));
|
2019-09-30 07:06:20 +01:00
|
|
|
} else {
|
|
|
|
*ret_val = mp_make_raise_obj(throw_value);
|
|
|
|
}
|
2014-03-31 02:14:30 +01:00
|
|
|
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)
|
2020-03-02 11:35:22 +00:00
|
|
|
return mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("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;
|
2018-10-01 06:35:10 +01:00
|
|
|
args[4] = level;
|
2013-12-10 17:27:24 +00:00
|
|
|
|
2019-07-18 23:54:12 +01:00
|
|
|
#if MICROPY_CAN_OVERRIDE_BUILTINS
|
|
|
|
// Lookup __import__ and call that if it exists
|
|
|
|
mp_obj_dict_t *bo_dict = MP_STATE_VM(mp_module_builtins_override_dict);
|
|
|
|
if (bo_dict != NULL) {
|
|
|
|
mp_map_elem_t *import = mp_map_lookup(&bo_dict->map, MP_OBJ_NEW_QSTR(MP_QSTR___import__), MP_MAP_LOOKUP);
|
|
|
|
if (import != NULL) {
|
|
|
|
return mp_call_function_n_kw(import->value, 5, 0, args);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
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:
|
2020-04-09 08:22:25 +01:00
|
|
|
mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("can't import name %q"), name);
|
2014-04-11 22:15:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
return dest[0];
|
|
|
|
}
|
|
|
|
|
2018-02-20 07:00:44 +00:00
|
|
|
#if MICROPY_ENABLE_EXTERNAL_IMPORT
|
|
|
|
|
2014-04-11 22:15:19 +01:00
|
|
|
// 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);
|
2017-03-25 08:48:18 +00:00
|
|
|
size_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);
|
2017-11-26 12:37:19 +00:00
|
|
|
char *dot_name = mp_local_alloc(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);
|
2017-11-26 12:37:19 +00:00
|
|
|
mp_local_free(dot_name);
|
2014-04-11 22:15:19 +01:00
|
|
|
|
2018-10-01 06:22:03 +01:00
|
|
|
// For fromlist, pass sentinel "non empty" value to force returning of leaf module
|
|
|
|
return mp_import_name(dot_name_q, mp_const_true, MP_OBJ_NEW_SMALL_INT(0));
|
2018-02-20 07:00:44 +00:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
// Package import not supported with external imports disabled
|
|
|
|
goto import_error;
|
|
|
|
|
|
|
|
#endif
|
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__
|
2018-07-08 12:31:09 +01:00
|
|
|
mp_map_t *map = &mp_obj_module_get_globals(module)->map;
|
2017-02-16 04:32:34 +00:00
|
|
|
for (size_t i = 0; i < map->alloc; i++) {
|
2019-01-30 10:57:29 +00:00
|
|
|
if (mp_map_slot_is_filled(map, i)) {
|
2018-10-25 21:48:03 +01:00
|
|
|
// Entry in module global scope may be generated programmatically
|
|
|
|
// (and thus be not a qstr for longer names). Avoid turning it in
|
|
|
|
// qstr if it has '_' and was used exactly to save memory.
|
|
|
|
const char *name = mp_obj_str_get_str(map->table[i].key);
|
|
|
|
if (*name != '_') {
|
|
|
|
qstr qname = mp_obj_str_get_qstr(map->table[i].key);
|
|
|
|
mp_store_name(qname, map->table[i].value);
|
2014-04-18 02:11:19 +01:00
|
|
|
}
|
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
|
|
|
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);
|
2020-08-21 01:30:09 +01:00
|
|
|
mp_obj_t module_fun = mp_compile(&parse_tree, source_name, parse_input_kind == MP_PARSE_SINGLE_INPUT);
|
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
|
|
|
|
|
2017-08-31 08:00:14 +01:00
|
|
|
NORETURN 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 MICROPY_ENABLE_GC
|
2017-07-01 00:23:29 +01:00
|
|
|
if (gc_is_locked()) {
|
2020-03-02 11:35:22 +00:00
|
|
|
mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("memory allocation failed, heap is locked"));
|
2014-10-07 08:50:20 +01:00
|
|
|
}
|
2017-07-01 00:23:29 +01:00
|
|
|
#endif
|
2020-02-11 00:48:28 +00:00
|
|
|
mp_raise_msg_varg(&mp_type_MemoryError,
|
2020-03-02 11:35:22 +00:00
|
|
|
MP_ERROR_TEXT("memory allocation failed, allocating %u bytes"), (uint)num_bytes);
|
2014-04-04 11:52:59 +01:00
|
|
|
}
|
|
|
|
|
2021-04-22 03:13:58 +01:00
|
|
|
#if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NONE
|
|
|
|
|
|
|
|
NORETURN void mp_raise_type(const mp_obj_type_t *exc_type) {
|
|
|
|
nlr_raise(mp_obj_new_exception(exc_type));
|
|
|
|
}
|
|
|
|
|
|
|
|
NORETURN void mp_raise_ValueError_no_msg(void) {
|
|
|
|
mp_raise_type(&mp_type_ValueError);
|
|
|
|
}
|
|
|
|
|
|
|
|
NORETURN void mp_raise_TypeError_no_msg(void) {
|
|
|
|
mp_raise_type(&mp_type_TypeError);
|
|
|
|
}
|
|
|
|
|
|
|
|
NORETURN void mp_raise_NotImplementedError_no_msg(void) {
|
|
|
|
mp_raise_type(&mp_type_NotImplementedError);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2020-01-29 03:27:33 +00:00
|
|
|
NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, mp_rom_error_text_t 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
|
|
|
}
|
|
|
|
|
2020-01-29 03:27:33 +00:00
|
|
|
NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, mp_rom_error_text_t fmt, ...) {
|
2020-02-11 00:48:28 +00:00
|
|
|
va_list args;
|
|
|
|
va_start(args, fmt);
|
2020-02-18 10:00:42 +00:00
|
|
|
mp_obj_t exc = mp_obj_new_exception_msg_vlist(exc_type, fmt, args);
|
2020-02-11 00:48:28 +00:00
|
|
|
va_end(args);
|
|
|
|
nlr_raise(exc);
|
|
|
|
}
|
|
|
|
|
2020-01-29 03:27:33 +00:00
|
|
|
NORETURN void mp_raise_ValueError(mp_rom_error_text_t msg) {
|
2016-08-12 19:26:12 +01:00
|
|
|
mp_raise_msg(&mp_type_ValueError, msg);
|
|
|
|
}
|
|
|
|
|
2020-01-29 03:27:33 +00:00
|
|
|
NORETURN void mp_raise_TypeError(mp_rom_error_text_t msg) {
|
2016-08-12 19:26:12 +01:00
|
|
|
mp_raise_msg(&mp_type_TypeError, msg);
|
|
|
|
}
|
|
|
|
|
2020-01-29 03:27:33 +00:00
|
|
|
NORETURN void mp_raise_NotImplementedError(mp_rom_error_text_t msg) {
|
2016-08-12 19:26:12 +01:00
|
|
|
mp_raise_msg(&mp_type_NotImplementedError, msg);
|
2014-06-07 21:22:41 +01:00
|
|
|
}
|
2017-11-20 06:29:58 +00:00
|
|
|
|
2021-04-22 03:13:58 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
NORETURN void mp_raise_OSError(int errno_) {
|
|
|
|
nlr_raise(mp_obj_new_exception_arg1(&mp_type_OSError, MP_OBJ_NEW_SMALL_INT(errno_)));
|
|
|
|
}
|
|
|
|
|
py: Introduce a Python stack for scoped allocation.
This patch introduces the MICROPY_ENABLE_PYSTACK option (disabled by
default) which enables a "Python stack" that allows to allocate and free
memory in a scoped, or Last-In-First-Out (LIFO) way, similar to alloca().
A new memory allocation API is introduced along with this Py-stack. It
includes both "local" and "nonlocal" LIFO allocation. Local allocation is
intended to be equivalent to using alloca(), whereby the same function must
free the memory. Nonlocal allocation is where another function may free
the memory, so long as it's still LIFO.
Follow-up patches will convert all uses of alloca() and VLA to the new
scoped allocation API. The old behaviour (using alloca()) will still be
available, but when MICROPY_ENABLE_PYSTACK is enabled then alloca() is no
longer required or used.
The benefits of enabling this option are (or will be once subsequent
patches are made to convert alloca()/VLA):
- Toolchains without alloca() can use this feature to obtain correct and
efficient scoped memory allocation (compared to using the heap instead
of alloca(), which is slower).
- Even if alloca() is available, enabling the Py-stack gives slightly more
efficient use of stack space when calling nested Python functions, due to
the way that compilers implement alloca().
- Enabling the Py-stack with the stackless mode allows for even more
efficient stack usage, as well as retaining high performance (because the
heap is no longer used to build and destroy stackless code states).
- With Py-stack and stackless enabled, Python-calling-Python is no longer
recursive in the C mp_execute_bytecode function.
The micropython.pystack_use() function is included to measure usage of the
Python stack.
2017-11-26 12:28:40 +00:00
|
|
|
#if MICROPY_STACK_CHECK || MICROPY_ENABLE_PYSTACK
|
2017-11-20 06:29:58 +00:00
|
|
|
NORETURN void mp_raise_recursion_depth(void) {
|
|
|
|
nlr_raise(mp_obj_new_exception_arg1(&mp_type_RuntimeError,
|
|
|
|
MP_OBJ_NEW_QSTR(MP_QSTR_maximum_space_recursion_space_depth_space_exceeded)));
|
|
|
|
}
|
|
|
|
#endif
|