2013-10-04 12:53:11 -06:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
2013-10-15 15:25:17 -06:00
|
|
|
#include "nlr.h"
|
2013-10-04 12:53:11 -06:00
|
|
|
#include "misc.h"
|
2013-12-21 11:17:45 -07:00
|
|
|
#include "mpconfig.h"
|
2014-01-21 14:40:13 -07:00
|
|
|
#include "qstr.h"
|
2013-12-21 11:17:45 -07:00
|
|
|
#include "obj.h"
|
2014-03-30 14:21:24 -06:00
|
|
|
#include "objtuple.h"
|
2014-03-25 08:18:18 -06:00
|
|
|
#include "objmodule.h"
|
2014-02-22 11:12:43 -07:00
|
|
|
#include "parsenum.h"
|
2013-12-21 11:17:45 -07:00
|
|
|
#include "runtime0.h"
|
2013-10-04 12:53:11 -06:00
|
|
|
#include "runtime.h"
|
2014-03-27 17:26:35 -06:00
|
|
|
#include "emitglue.h"
|
2013-12-17 11:27:24 -07:00
|
|
|
#include "builtin.h"
|
2014-03-25 08:18:18 -06:00
|
|
|
#include "builtintables.h"
|
2014-01-22 07:35:10 -07:00
|
|
|
#include "bc.h"
|
2014-04-04 05:13:51 -06:00
|
|
|
#include "smallint.h"
|
2014-03-30 14:14:55 -06:00
|
|
|
#include "objgenerator.h"
|
2013-12-17 11:27:24 -07:00
|
|
|
|
2013-10-10 04:24:39 -06:00
|
|
|
#if 0 // print debugging info
|
2013-10-10 16:25:50 -06:00
|
|
|
#define DEBUG_PRINT (1)
|
2014-02-16 09:11:42 -07:00
|
|
|
#define DEBUG_printf DEBUG_printf
|
2014-02-26 15:40:35 -07:00
|
|
|
#define DEBUG_OP_printf(...) DEBUG_printf(__VA_ARGS__)
|
2013-10-10 04:24:39 -06:00
|
|
|
#else // don't print debugging info
|
2014-02-26 15:40:35 -07:00
|
|
|
#define DEBUG_printf(...) (void)0
|
|
|
|
#define DEBUG_OP_printf(...) (void)0
|
2013-10-10 04:24:39 -06:00
|
|
|
#endif
|
2013-10-04 12:53:11 -06:00
|
|
|
|
2013-10-10 15:06:54 -06:00
|
|
|
// locals and globals need to be pointers because they can be the same in outer module scope
|
2014-02-12 09:31:30 -07:00
|
|
|
STATIC mp_map_t *map_locals;
|
|
|
|
STATIC mp_map_t *map_globals;
|
|
|
|
STATIC mp_map_t map_builtins;
|
2013-10-16 13:39:12 -06:00
|
|
|
|
2014-01-08 10:33:12 -07:00
|
|
|
// a good optimising compiler will inline this if necessary
|
2014-02-12 09:31:30 -07:00
|
|
|
STATIC void mp_map_add_qstr(mp_map_t *map, qstr qstr, mp_obj_t value) {
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_lookup(map, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_init(void) {
|
2014-03-27 17:26:35 -06:00
|
|
|
mp_emit_glue_init();
|
|
|
|
|
2013-10-10 15:06:54 -06:00
|
|
|
// locals = globals for outer module (see Objects/frameobject.c/PyFrame_New())
|
2014-01-08 10:33:12 -07:00
|
|
|
map_locals = map_globals = mp_map_new(1);
|
2013-12-21 11:17:45 -07:00
|
|
|
|
2013-12-29 10:17:43 -07:00
|
|
|
// init built-in hash table
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_init(&map_builtins, 3);
|
2013-12-29 10:17:43 -07:00
|
|
|
|
2014-03-25 08:18:18 -06:00
|
|
|
// init global module stuff
|
|
|
|
mp_module_init();
|
2014-01-22 16:59:20 -07:00
|
|
|
|
2014-03-25 08:18:18 -06:00
|
|
|
// add some builtins that can't be done in ROM
|
|
|
|
mp_map_add_qstr(map_globals, MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR___main__));
|
2014-01-04 11:44:46 -07:00
|
|
|
|
2014-01-16 10:19:50 -07:00
|
|
|
#if MICROPY_CPYTHON_COMPAT
|
2014-01-19 16:57:20 -07:00
|
|
|
// Precreate sys module, so "import sys" didn't throw exceptions.
|
2014-02-04 15:47:06 -07:00
|
|
|
mp_obj_t m_sys = mp_obj_new_module(MP_QSTR_sys);
|
|
|
|
// Avoid warning of unused var
|
|
|
|
(void)m_sys;
|
2014-01-16 10:19:50 -07:00
|
|
|
#endif
|
2014-02-04 15:47:06 -07:00
|
|
|
// init sys.path
|
|
|
|
// for efficiency, left to platform-specific startup code
|
2014-03-30 06:35:08 -06:00
|
|
|
//mp_sys_path = mp_obj_new_list(0, NULL);
|
|
|
|
//mp_store_attr(m_sys, MP_QSTR_path, mp_sys_path);
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_deinit(void) {
|
2014-03-27 17:26:35 -06:00
|
|
|
mp_map_free(map_globals);
|
|
|
|
mp_map_deinit(&map_builtins);
|
|
|
|
mp_module_deinit();
|
|
|
|
mp_emit_glue_deinit();
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_const_dec(qstr qstr) {
|
2013-11-02 13:47:57 -06:00
|
|
|
DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
|
2014-02-22 11:12:43 -07:00
|
|
|
uint len;
|
|
|
|
const byte* data = qstr_data(qstr, &len);
|
2014-03-21 05:45:46 -06:00
|
|
|
return mp_parse_num_decimal((const char*)data, len, true, false);
|
2013-11-02 13:47:57 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_const_str(qstr qstr) {
|
2013-10-04 12:53:11 -06:00
|
|
|
DEBUG_OP_printf("load '%s'\n", qstr_str(qstr));
|
2014-01-22 07:35:10 -07:00
|
|
|
return MP_OBJ_NEW_QSTR(qstr);
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_const_bytes(qstr qstr) {
|
2014-01-24 13:50:40 -07:00
|
|
|
DEBUG_OP_printf("load b'%s'\n", qstr_str(qstr));
|
|
|
|
uint len;
|
|
|
|
const byte *data = qstr_data(qstr, &len);
|
|
|
|
return mp_obj_new_bytes(data, len);
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_name(qstr qstr) {
|
2013-10-04 12:53:11 -06:00
|
|
|
// logic: search locals, globals, builtins
|
2013-10-09 16:10:10 -06:00
|
|
|
DEBUG_OP_printf("load name %s\n", qstr_str(qstr));
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP);
|
2014-02-06 15:57:51 -07:00
|
|
|
if (elem != NULL) {
|
|
|
|
return elem->value;
|
|
|
|
} else {
|
2014-03-30 06:35:08 -06:00
|
|
|
return mp_load_global(qstr);
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_global(qstr qstr) {
|
2013-10-09 16:10:10 -06:00
|
|
|
// logic: search globals, builtins
|
|
|
|
DEBUG_OP_printf("load global %s\n", qstr_str(qstr));
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(map_globals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP);
|
2013-10-09 16:10:10 -06:00
|
|
|
if (elem == NULL) {
|
2014-01-08 10:33:12 -07:00
|
|
|
elem = mp_map_lookup(&map_builtins, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP);
|
2013-10-09 16:10:10 -06:00
|
|
|
if (elem == NULL) {
|
2014-03-25 08:18:18 -06:00
|
|
|
mp_obj_t o = mp_builtin_tables_lookup_object(qstr);
|
|
|
|
if (o != MP_OBJ_NULL) {
|
|
|
|
return o;
|
2014-02-06 15:57:51 -07:00
|
|
|
}
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_NameError, "name '%s' is not defined", qstr_str(qstr)));
|
2013-10-09 16:10:10 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return elem->value;
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_build_class(void) {
|
2013-10-04 12:53:11 -06:00
|
|
|
DEBUG_OP_printf("load_build_class\n");
|
2014-03-25 08:18:18 -06:00
|
|
|
// lookup __build_class__ in dynamic table of builtins first
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_elem_t *elem = mp_map_lookup(&map_builtins, MP_OBJ_NEW_QSTR(MP_QSTR___build_class__), MP_MAP_LOOKUP);
|
2014-02-06 15:57:51 -07:00
|
|
|
if (elem != NULL) {
|
2014-03-25 08:18:18 -06:00
|
|
|
// found user-defined __build_class__, return it
|
2014-02-06 15:57:51 -07:00
|
|
|
return elem->value;
|
|
|
|
} else {
|
2014-03-25 08:18:18 -06:00
|
|
|
// no user-defined __build_class__, return builtin one
|
2014-02-06 15:57:51 -07:00
|
|
|
return (mp_obj_t)&mp_builtin___build_class___obj;
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_store_name(qstr qstr, mp_obj_t obj) {
|
2013-10-09 16:10:10 -06:00
|
|
|
DEBUG_OP_printf("store name %s <- %p\n", qstr_str(qstr), obj);
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = obj;
|
2013-10-09 16:10:10 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_delete_name(qstr qstr) {
|
2014-03-23 13:19:02 -06:00
|
|
|
DEBUG_OP_printf("delete name %s\n", qstr_str(qstr));
|
|
|
|
mp_map_lookup(map_locals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_store_global(qstr qstr, mp_obj_t obj) {
|
2013-10-09 16:10:10 -06:00
|
|
|
DEBUG_OP_printf("store global %s <- %p\n", qstr_str(qstr), obj);
|
2014-01-08 10:33:12 -07:00
|
|
|
mp_map_lookup(map_globals, MP_OBJ_NEW_QSTR(qstr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = obj;
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_unary_op(int op, mp_obj_t arg) {
|
2013-11-02 13:47:57 -06:00
|
|
|
DEBUG_OP_printf("unary %d %p\n", op, arg);
|
2014-02-01 16:04:09 -07:00
|
|
|
|
2013-12-21 11:17:45 -07:00
|
|
|
if (MP_OBJ_IS_SMALL_INT(arg)) {
|
|
|
|
mp_small_int_t val = MP_OBJ_SMALL_INT_VALUE(arg);
|
2013-11-02 13:47:57 -06:00
|
|
|
switch (op) {
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_UNARY_OP_BOOL:
|
2014-03-12 09:38:15 -06:00
|
|
|
return MP_BOOL(val != 0);
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_UNARY_OP_POSITIVE:
|
2014-03-12 09:38:15 -06:00
|
|
|
return arg;
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_UNARY_OP_NEGATIVE:
|
2014-03-12 09:38:15 -06:00
|
|
|
// check for overflow
|
|
|
|
if (val == MP_SMALL_INT_MIN) {
|
|
|
|
return mp_obj_new_int(-val);
|
|
|
|
} else {
|
|
|
|
return MP_OBJ_NEW_SMALL_INT(-val);
|
|
|
|
}
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_UNARY_OP_INVERT:
|
2014-03-12 09:38:15 -06:00
|
|
|
return MP_OBJ_NEW_SMALL_INT(~val);
|
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
return arg;
|
2013-12-21 11:17:45 -07:00
|
|
|
}
|
2014-01-23 11:27:51 -07: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);
|
2013-12-21 11:17:45 -07:00
|
|
|
if (result != NULL) {
|
|
|
|
return result;
|
|
|
|
}
|
2013-11-02 13:47:57 -06:00
|
|
|
}
|
2013-12-21 11:17:45 -07:00
|
|
|
// TODO specify in error message what the operator is
|
2014-03-09 10:29:36 -06:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "bad operand type for unary operator: '%s'", mp_obj_get_type_str(arg)));
|
2013-11-02 13:47:57 -06:00
|
|
|
}
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
|
2013-10-04 12:53:11 -06:00
|
|
|
DEBUG_OP_printf("binary %d %p %p\n", op, lhs, rhs);
|
2014-01-03 07:09:31 -07: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 16:04:09 -07:00
|
|
|
// deal with is
|
2014-03-30 06:35:08 -06:00
|
|
|
if (op == MP_BINARY_OP_IS) {
|
2014-01-14 15:31:28 -07:00
|
|
|
return MP_BOOL(lhs == rhs);
|
|
|
|
}
|
|
|
|
|
2014-01-11 03:47:22 -07:00
|
|
|
// deal with == and != for all types
|
2014-03-30 06:35:08 -06:00
|
|
|
if (op == MP_BINARY_OP_EQUAL || op == MP_BINARY_OP_NOT_EQUAL) {
|
2014-01-11 03:47:22 -07:00
|
|
|
if (mp_obj_equal(lhs, rhs)) {
|
2014-03-30 06:35:08 -06:00
|
|
|
if (op == MP_BINARY_OP_EQUAL) {
|
2014-01-11 03:47:22 -07:00
|
|
|
return mp_const_true;
|
|
|
|
} else {
|
|
|
|
return mp_const_false;
|
|
|
|
}
|
|
|
|
} else {
|
2014-03-30 06:35:08 -06:00
|
|
|
if (op == MP_BINARY_OP_EQUAL) {
|
2014-01-11 03:47:22 -07:00
|
|
|
return mp_const_false;
|
|
|
|
} else {
|
|
|
|
return mp_const_true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// deal with exception_match for all types
|
2014-03-30 06:35:08 -06:00
|
|
|
if (op == MP_BINARY_OP_EXCEPTION_MATCH) {
|
2014-02-15 09:10:44 -07:00
|
|
|
// rhs must be issubclass(rhs, BaseException)
|
|
|
|
if (mp_obj_is_exception_type(rhs)) {
|
|
|
|
// if lhs is an instance of an exception, then extract and use its type
|
|
|
|
if (mp_obj_is_exception_instance(lhs)) {
|
|
|
|
lhs = mp_obj_get_type(lhs);
|
|
|
|
}
|
2014-03-03 15:38:13 -07:00
|
|
|
if (mp_obj_is_subclass_fast(lhs, rhs)) {
|
2014-01-11 03:47:22 -07:00
|
|
|
return mp_const_true;
|
|
|
|
} else {
|
|
|
|
return mp_const_false;
|
|
|
|
}
|
|
|
|
}
|
2014-03-23 12:49:39 -06:00
|
|
|
assert(0);
|
|
|
|
return mp_const_false;
|
2014-01-11 03:47:22 -07:00
|
|
|
}
|
|
|
|
|
2014-01-06 15:13:00 -07:00
|
|
|
if (MP_OBJ_IS_SMALL_INT(lhs)) {
|
2013-12-21 11:17:45 -07:00
|
|
|
mp_small_int_t lhs_val = MP_OBJ_SMALL_INT_VALUE(lhs);
|
2014-01-06 15:13:00 -07:00
|
|
|
if (MP_OBJ_IS_SMALL_INT(rhs)) {
|
|
|
|
mp_small_int_t rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs);
|
2014-03-12 09:38:15 -06: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:
|
|
|
|
// + result always fits in machine_int_t, then handled by SMALL_INT check
|
|
|
|
// - result always fits in machine_int_t, then handled by SMALL_INT check
|
|
|
|
// * checked explicitly
|
|
|
|
// / if lhs=MIN and rhs=-1; result always fits in machine_int_t, then handled by SMALL_INT check
|
|
|
|
// % if lhs=MIN and rhs=-1; result always fits in machine_int_t, then handled by SMALL_INT check
|
|
|
|
// << checked explicitly
|
2014-01-06 15:13:00 -07:00
|
|
|
switch (op) {
|
2014-03-30 06:35:08 -06: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 09:38:15 -06:00
|
|
|
if (rhs_val < 0) {
|
|
|
|
// negative shift not allowed
|
|
|
|
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count"));
|
|
|
|
} else if (rhs_val >= BITS_PER_WORD || lhs_val > (MP_SMALL_INT_MAX >> rhs_val) || lhs_val < (MP_SMALL_INT_MIN >> rhs_val)) {
|
|
|
|
// 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 06:35:08 -06:00
|
|
|
case MP_BINARY_OP_RSHIFT:
|
|
|
|
case MP_BINARY_OP_INPLACE_RSHIFT:
|
2014-03-12 09:38:15 -06:00
|
|
|
if (rhs_val < 0) {
|
|
|
|
// negative shift not allowed
|
|
|
|
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative shift count"));
|
|
|
|
} else {
|
|
|
|
// standard precision is enough for right-shift
|
|
|
|
lhs_val >>= rhs_val;
|
|
|
|
}
|
|
|
|
break;
|
2014-03-30 06:35:08 -06: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 09:38:15 -06:00
|
|
|
|
|
|
|
// If long long type exists and is larger than machine_int_t, then
|
|
|
|
// we can use the following code to perform overflow-checked multiplication.
|
2014-04-04 05:13:51 -06:00
|
|
|
// Otherwise (eg in x64 case) we must use mp_small_int_mul_overflow.
|
2014-03-12 09:38:15 -06: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
|
|
|
|
lhs_val = (mp_small_int_t)res;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-04-04 05:13:51 -06: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 09:38:15 -06:00
|
|
|
break;
|
|
|
|
}
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_BINARY_OP_FLOOR_DIVIDE:
|
|
|
|
case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE:
|
2014-03-30 17:20:00 -06:00
|
|
|
if (rhs_val == 0) {
|
|
|
|
goto zero_division;
|
|
|
|
}
|
2014-04-04 05:13:51 -06:00
|
|
|
lhs_val = mp_small_int_floor_divide(lhs_val, rhs_val);
|
2014-03-22 14:19:24 -06:00
|
|
|
break;
|
2014-03-30 17:20:00 -06:00
|
|
|
|
2014-03-12 09:38:15 -06:00
|
|
|
#if MICROPY_ENABLE_FLOAT
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_BINARY_OP_TRUE_DIVIDE:
|
2014-03-30 17:20:00 -06:00
|
|
|
case MP_BINARY_OP_INPLACE_TRUE_DIVIDE:
|
|
|
|
if (rhs_val == 0) {
|
2014-04-02 10:06:05 -06:00
|
|
|
goto zero_division;
|
2014-03-30 17:20:00 -06:00
|
|
|
}
|
|
|
|
return mp_obj_new_float((mp_float_t)lhs_val / (mp_float_t)rhs_val);
|
2014-03-12 09:38:15 -06:00
|
|
|
#endif
|
2014-01-06 15:13:00 -07:00
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_BINARY_OP_MODULO:
|
2014-04-04 05:13:51 -06:00
|
|
|
case MP_BINARY_OP_INPLACE_MODULO: {
|
|
|
|
lhs_val = mp_small_int_modulo(lhs_val, rhs_val);
|
2014-03-22 11:29:27 -06:00
|
|
|
break;
|
|
|
|
}
|
2014-04-04 05:13:51 -06:00
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_BINARY_OP_POWER:
|
|
|
|
case MP_BINARY_OP_INPLACE_POWER:
|
2014-03-12 09:38:15 -06:00
|
|
|
if (rhs_val < 0) {
|
|
|
|
#if MICROPY_ENABLE_FLOAT
|
|
|
|
lhs = mp_obj_new_float(lhs_val);
|
|
|
|
goto generic_binary_op;
|
|
|
|
#else
|
|
|
|
nlr_jump(mp_obj_new_exception_msg(&mp_type_ValueError, "negative power with no float support"));
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
machine_int_t ans = 1;
|
|
|
|
while (rhs_val > 0) {
|
|
|
|
if (rhs_val & 1) {
|
2014-04-04 05:13:51 -06:00
|
|
|
if (mp_small_int_mul_overflow(ans, lhs_val)) {
|
2014-04-03 17:16:32 -06:00
|
|
|
goto power_overflow;
|
|
|
|
}
|
2014-04-04 05:13:51 -06:00
|
|
|
ans *= lhs_val;
|
2014-04-03 17:16:32 -06:00
|
|
|
}
|
|
|
|
if (rhs_val == 1) {
|
|
|
|
break;
|
2014-03-12 09:38:15 -06:00
|
|
|
}
|
|
|
|
rhs_val /= 2;
|
2014-04-04 05:13:51 -06:00
|
|
|
if (mp_small_int_mul_overflow(lhs_val, lhs_val)) {
|
2014-04-03 17:16:32 -06:00
|
|
|
goto power_overflow;
|
|
|
|
}
|
2014-04-04 05:13:51 -06:00
|
|
|
lhs_val *= lhs_val;
|
2014-01-06 15:13:00 -07:00
|
|
|
}
|
2014-03-12 09:38:15 -06:00
|
|
|
lhs_val = ans;
|
2013-12-17 14:35:38 -07:00
|
|
|
}
|
2014-01-06 15:13:00 -07:00
|
|
|
break;
|
2014-04-03 17:16:32 -06:00
|
|
|
|
|
|
|
power_overflow:
|
|
|
|
// use higher precision
|
|
|
|
lhs = mp_obj_new_int_from_ll(MP_OBJ_SMALL_INT_VALUE(lhs));
|
|
|
|
goto generic_binary_op;
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
case MP_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val); break;
|
|
|
|
case MP_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val); break;
|
|
|
|
case MP_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val); break;
|
|
|
|
case MP_BINARY_OP_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val); break;
|
2013-12-17 14:35:38 -07:00
|
|
|
|
2014-01-06 15:13:00 -07:00
|
|
|
default: assert(0);
|
|
|
|
}
|
2014-01-12 08:06:25 -07:00
|
|
|
// TODO: We just should make mp_obj_new_int() inline and use that
|
|
|
|
if (MP_OBJ_FITS_SMALL_INT(lhs_val)) {
|
2014-01-06 15:13:00 -07:00
|
|
|
return MP_OBJ_NEW_SMALL_INT(lhs_val);
|
2014-03-12 09:38:15 -06:00
|
|
|
} else {
|
|
|
|
return mp_obj_new_int(lhs_val);
|
2014-01-06 15:13:00 -07:00
|
|
|
}
|
2014-01-30 17:42:12 -07:00
|
|
|
#if MICROPY_ENABLE_FLOAT
|
2014-03-08 08:24:39 -07:00
|
|
|
} else if (MP_OBJ_IS_TYPE(rhs, &mp_type_float)) {
|
2014-01-06 15:13:00 -07:00
|
|
|
return mp_obj_float_binary_op(op, lhs_val, rhs);
|
2014-03-08 08:24:39 -07:00
|
|
|
} else if (MP_OBJ_IS_TYPE(rhs, &mp_type_complex)) {
|
2014-01-06 15:13:00 -07:00
|
|
|
return mp_obj_complex_binary_op(op, lhs_val, 0, rhs);
|
2014-01-30 17:42:12 -07:00
|
|
|
#endif
|
2013-12-21 11:17:45 -07:00
|
|
|
}
|
2014-01-11 05:39:33 -07:00
|
|
|
}
|
2013-11-02 08:33:10 -06:00
|
|
|
|
2014-02-01 16:04:09 -07:00
|
|
|
/* deal with `in`
|
2014-01-11 05:39:33 -07:00
|
|
|
*
|
|
|
|
* NOTE `a in b` is `b.__contains__(a)`, hence why the generic dispatch
|
2014-02-01 16:32:29 -07:00
|
|
|
* needs to go below with swapped arguments
|
2014-01-11 05:39:33 -07:00
|
|
|
*/
|
2014-03-30 06:35:08 -06:00
|
|
|
if (op == MP_BINARY_OP_IN) {
|
2014-01-22 07:35:10 -07: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-02-01 16:32:29 -07:00
|
|
|
if (res != MP_OBJ_NULL) {
|
2014-01-22 07:35:10 -07:00
|
|
|
return res;
|
2014-01-10 17:58:59 -07:00
|
|
|
}
|
2014-01-22 07:35:10 -07:00
|
|
|
}
|
|
|
|
if (type->getiter != NULL) {
|
|
|
|
/* second attempt, walk the iterator */
|
|
|
|
mp_obj_t next = NULL;
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t iter = mp_getiter(rhs);
|
|
|
|
while ((next = mp_iternext(iter)) != MP_OBJ_NULL) {
|
2014-01-22 07:35:10 -07:00
|
|
|
if (mp_obj_equal(next, lhs)) {
|
2014-02-01 16:04:09 -07:00
|
|
|
return mp_const_true;
|
2014-01-10 17:58:59 -07:00
|
|
|
}
|
2014-01-11 05:39:33 -07:00
|
|
|
}
|
2014-02-01 16:04:09 -07:00
|
|
|
return mp_const_false;
|
2014-01-11 05:39:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(
|
2014-02-15 09:10:44 -07:00
|
|
|
&mp_type_TypeError, "'%s' object is not iterable",
|
2014-01-11 05:39:33 -07:00
|
|
|
mp_obj_get_type_str(rhs)));
|
|
|
|
return mp_const_none;
|
|
|
|
}
|
|
|
|
|
2014-01-22 07:35:10 -07:00
|
|
|
// generic binary_op supplied by type
|
2014-03-12 09:38:15 -06:00
|
|
|
mp_obj_type_t *type;
|
|
|
|
generic_binary_op:
|
|
|
|
type = mp_obj_get_type(lhs);
|
2014-01-22 07:35:10 -07:00
|
|
|
if (type->binary_op != NULL) {
|
|
|
|
mp_obj_t result = type->binary_op(op, lhs, rhs);
|
|
|
|
if (result != MP_OBJ_NULL) {
|
|
|
|
return result;
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
}
|
2013-10-22 09:53:02 -06:00
|
|
|
|
2014-01-22 07:35:10 -07:00
|
|
|
// TODO implement dispatch for reverse binary ops
|
|
|
|
|
2014-01-10 17:58:59 -07:00
|
|
|
// TODO specify in error message what the operator is
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
|
2014-01-10 17:58:59 -07:00
|
|
|
"unsupported operand types for binary operator: '%s', '%s'",
|
|
|
|
mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs)));
|
2014-01-11 05:39:33 -07:00
|
|
|
return mp_const_none;
|
2014-04-02 10:06:05 -06:00
|
|
|
|
|
|
|
zero_division:
|
|
|
|
nlr_jump(mp_obj_new_exception_msg(&mp_type_ZeroDivisionError, "division by zero"));
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06: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 15:06:54 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06: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 15:06:54 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_call_function_2(mp_obj_t fun, mp_obj_t arg1, mp_obj_t arg2) {
|
2013-12-21 11:17:45 -07:00
|
|
|
mp_obj_t args[2];
|
2014-01-18 07:10:48 -07:00
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
2014-03-30 06:35:08 -06:00
|
|
|
return mp_call_function_n_kw(fun, 2, 0, args);
|
2013-10-10 15:06:54 -06:00
|
|
|
}
|
|
|
|
|
2014-02-02 06:11:48 -07:00
|
|
|
// wrapper that accepts n_args and n_kw in one argument
|
|
|
|
// native emitter can only pass at most 3 arguments to a function
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_call_function_n_kw_for_native(mp_obj_t fun_in, uint n_args_kw, const mp_obj_t *args) {
|
|
|
|
return mp_call_function_n_kw(fun_in, n_args_kw & 0xff, (n_args_kw >> 8) & 0xff, args);
|
2014-02-02 06:11:48 -07:00
|
|
|
}
|
|
|
|
|
2014-01-18 07:10:48 -07:00
|
|
|
// args contains, eg: arg0 arg1 key0 value0 key1 value1
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, uint n_args, uint n_kw, const mp_obj_t *args) {
|
2013-12-21 11:17:45 -07: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 15:06:54 -06:00
|
|
|
|
2014-01-07 16:06:46 -07:00
|
|
|
DEBUG_OP_printf("calling function %p(n_args=%d, n_kw=%d, args=%p)\n", fun_in, n_args, n_kw, args);
|
|
|
|
|
2014-01-31 16:49:49 -07:00
|
|
|
// get the type
|
|
|
|
mp_obj_type_t *type = mp_obj_get_type(fun_in);
|
|
|
|
|
|
|
|
// do the call
|
|
|
|
if (type->call != NULL) {
|
|
|
|
return type->call(fun_in, n_args, n_kw, args);
|
2014-01-07 16:06:46 -07:00
|
|
|
} else {
|
2014-03-09 10:29:36 -06:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object is not callable", mp_obj_get_type_str(fun_in)));
|
2014-01-07 16:06:46 -07:00
|
|
|
}
|
2013-11-26 08:16:41 -07:00
|
|
|
}
|
|
|
|
|
2014-01-18 07:10:48 -07: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
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_call_method_n_kw(uint n_args, uint n_kw, const mp_obj_t *args) {
|
2014-01-18 07:10:48 -07:00
|
|
|
DEBUG_OP_printf("call method (fun=%p, self=%p, n_args=%u, n_kw=%u, args=%p)\n", args[0], args[1], n_args, n_kw, args);
|
|
|
|
int adjust = (args[1] == NULL) ? 0 : 1;
|
2014-03-30 06:35:08 -06:00
|
|
|
return mp_call_function_n_kw(args[0], n_args + adjust, n_kw, args + 2 - adjust);
|
2013-11-26 08:16:41 -07:00
|
|
|
}
|
|
|
|
|
2014-03-31 04:59:23 -06:00
|
|
|
mp_obj_t mp_call_method_n_kw_var(bool have_self, uint n_args_n_kw, const mp_obj_t *args) {
|
2014-03-30 14:21:24 -06: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;
|
2014-03-31 04:59:23 -06:00
|
|
|
mp_obj_t pos_seq = args[n_args + 2 * n_kw]; // map be MP_OBJ_NULL
|
|
|
|
mp_obj_t kw_dict = args[n_args + 2 * n_kw + 1]; // map be MP_OBJ_NULL
|
2014-03-30 14:21:24 -06: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
|
|
|
|
m_seq_copy(args2 + args2_len, args, n_args, mp_obj_t);
|
|
|
|
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
|
|
|
|
uint len;
|
|
|
|
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
|
|
|
|
m_seq_cat(args2 + args2_len, args, n_args, items, len, mp_obj_t);
|
|
|
|
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
|
|
|
|
m_seq_copy(args2 + args2_len, args, n_args, mp_obj_t);
|
|
|
|
|
|
|
|
// extract the variable position args from the iterator
|
|
|
|
mp_obj_t iterable = mp_getiter(pos_seq);
|
|
|
|
mp_obj_t item;
|
|
|
|
while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
|
|
|
|
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.
|
|
|
|
m_seq_copy(args2 + args2_len, args + n_args, 2 * n_kw, mp_obj_t);
|
|
|
|
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
|
|
|
|
for (uint i = 0; i < map->alloc; i++) {
|
|
|
|
if (map->table[i].key != MP_OBJ_NULL) {
|
|
|
|
args2[args2_len++] = map->table[i].key;
|
|
|
|
args2[args2_len++] = map->table[i].value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// generic mapping
|
|
|
|
// TODO is calling 'items' on the mapping the correct thing to do here?
|
|
|
|
mp_obj_t dest[2];
|
|
|
|
mp_load_method(kw_dict, MP_QSTR_items, dest);
|
|
|
|
mp_obj_t iterable = mp_getiter(mp_call_method_n_kw(0, 0, dest));
|
|
|
|
mp_obj_t item;
|
|
|
|
while ((item = mp_iternext(iterable)) != MP_OBJ_NULL) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
mp_obj_t *items;
|
|
|
|
mp_obj_get_array_fixed_n(item, 2, &items);
|
|
|
|
args2[args2_len++] = items[0];
|
|
|
|
args2[args2_len++] = items[1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mp_obj_t res = mp_call_function_n_kw(fun, pos_args_len, (args2_len - pos_args_len) / 2, args2);
|
|
|
|
m_del(mp_obj_t, args2, args2_alloc);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2014-01-18 16:42:49 -07:00
|
|
|
// unpacked items are stored in reverse order into the array pointed to by items
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_unpack_sequence(mp_obj_t seq_in, uint num, mp_obj_t *items) {
|
2014-02-01 15:54:06 -07:00
|
|
|
uint seq_len;
|
2014-03-29 07:43:38 -06:00
|
|
|
if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple) || MP_OBJ_IS_TYPE(seq_in, &mp_type_list)) {
|
2013-12-21 11:17:45 -07:00
|
|
|
mp_obj_t *seq_items;
|
2014-03-29 07:15:08 -06:00
|
|
|
if (MP_OBJ_IS_TYPE(seq_in, &mp_type_tuple)) {
|
2013-12-21 11:17:45 -07:00
|
|
|
mp_obj_tuple_get(seq_in, &seq_len, &seq_items);
|
|
|
|
} else {
|
|
|
|
mp_obj_list_get(seq_in, &seq_len, &seq_items);
|
2013-11-26 08:16:41 -07:00
|
|
|
}
|
2013-12-21 11:17:45 -07:00
|
|
|
if (seq_len < num) {
|
2014-02-01 15:54:06 -07:00
|
|
|
goto too_short;
|
2013-12-21 11:17:45 -07:00
|
|
|
} else if (seq_len > num) {
|
2014-02-01 15:54:06 -07:00
|
|
|
goto too_long;
|
2013-12-21 11:17:45 -07:00
|
|
|
}
|
2014-01-18 16:42:49 -07:00
|
|
|
for (uint i = 0; i < num; i++) {
|
|
|
|
items[i] = seq_items[num - 1 - i];
|
|
|
|
}
|
2013-11-26 08:16:41 -07:00
|
|
|
} else {
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t iterable = mp_getiter(seq_in);
|
2014-02-01 15:54:06 -07:00
|
|
|
|
|
|
|
for (seq_len = 0; seq_len < num; seq_len++) {
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t el = mp_iternext(iterable);
|
2014-03-26 13:27:58 -06:00
|
|
|
if (el == MP_OBJ_NULL) {
|
2014-02-01 15:54:06 -07:00
|
|
|
goto too_short;
|
|
|
|
}
|
|
|
|
items[num - 1 - seq_len] = el;
|
|
|
|
}
|
2014-03-30 06:35:08 -06:00
|
|
|
if (mp_iternext(iterable) != MP_OBJ_NULL) {
|
2014-02-01 15:54:06 -07:00
|
|
|
goto too_long;
|
|
|
|
}
|
2013-11-26 08:16:41 -07:00
|
|
|
}
|
2014-02-01 15:54:06 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
too_short:
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "need more than %d values to unpack", seq_len));
|
2014-02-01 15:54:06 -07:00
|
|
|
too_long:
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "too many values to unpack (expected %d)", num));
|
2013-11-26 08:16:41 -07:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_load_attr(mp_obj_t base, qstr attr) {
|
2014-01-09 13:57:50 -07:00
|
|
|
DEBUG_OP_printf("load attr %p.%s\n", base, qstr_str(attr));
|
|
|
|
// use load_method
|
|
|
|
mp_obj_t dest[2];
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_load_method(base, attr, dest);
|
2014-01-24 17:17:36 -07:00
|
|
|
if (dest[1] == MP_OBJ_NULL) {
|
2014-01-09 13:57:50 -07:00
|
|
|
// load_method returned just a normal attribute
|
2014-01-18 07:10:48 -07:00
|
|
|
return dest[0];
|
2014-01-09 13:57:50 -07: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 12:53:11 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-24 17:17:36 -07: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>
|
2014-03-31 15:57:56 -06:00
|
|
|
void mp_load_method_maybe(mp_obj_t base, qstr attr, mp_obj_t *dest) {
|
2014-01-09 13:57:50 -07:00
|
|
|
// clear output to indicate no attribute/method found yet
|
|
|
|
dest[0] = MP_OBJ_NULL;
|
|
|
|
dest[1] = MP_OBJ_NULL;
|
|
|
|
|
|
|
|
// get the type
|
|
|
|
mp_obj_type_t *type = mp_obj_get_type(base);
|
|
|
|
|
2014-03-31 15:57:56 -06:00
|
|
|
// look for built-in names
|
|
|
|
if (0) {
|
2014-03-31 11:30:08 -06:00
|
|
|
#if MICROPY_CPYTHON_COMPAT
|
2014-03-31 15:57:56 -06:00
|
|
|
} else if (attr == MP_QSTR___class__) {
|
|
|
|
// a.__class__ is equivalent to type(a)
|
|
|
|
dest[0] = type;
|
2014-03-31 11:30:08 -06:00
|
|
|
#endif
|
2014-03-31 15:57:56 -06:00
|
|
|
|
|
|
|
} else if (attr == MP_QSTR___next__ && type->iternext != NULL) {
|
|
|
|
dest[0] = (mp_obj_t)&mp_builtin_next_obj;
|
|
|
|
dest[1] = base;
|
|
|
|
|
|
|
|
} else if (type->load_attr != NULL) {
|
|
|
|
// this type can do its own load, so call it
|
|
|
|
type->load_attr(base, attr, dest);
|
|
|
|
|
|
|
|
} else if (type->locals_dict != NULL) {
|
|
|
|
// generic method lookup
|
|
|
|
// this is a lookup in the object (ie not class or type)
|
|
|
|
assert(MP_OBJ_IS_TYPE(type->locals_dict, &mp_type_dict)); // Micro Python restriction, for now
|
|
|
|
mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict);
|
|
|
|
mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
|
|
|
|
if (elem != NULL) {
|
|
|
|
// check if the methods are functions, static or class methods
|
|
|
|
// see http://docs.python.org/3.3/howto/descriptor.html
|
|
|
|
if (MP_OBJ_IS_TYPE(elem->value, &mp_type_staticmethod)) {
|
|
|
|
// return just the function
|
|
|
|
dest[0] = ((mp_obj_static_class_method_t*)elem->value)->fun;
|
|
|
|
} else if (MP_OBJ_IS_TYPE(elem->value, &mp_type_classmethod)) {
|
|
|
|
// return a bound method, with self being the type of this object
|
|
|
|
dest[0] = ((mp_obj_static_class_method_t*)elem->value)->fun;
|
|
|
|
dest[1] = mp_obj_get_type(base);
|
|
|
|
} else if (mp_obj_is_callable(elem->value)) {
|
|
|
|
// return a bound method, with self being this object
|
|
|
|
dest[0] = elem->value;
|
|
|
|
dest[1] = base;
|
|
|
|
} else {
|
|
|
|
// class member is a value, so just return that value
|
|
|
|
dest[0] = elem->value;
|
2013-11-02 17:58:14 -06:00
|
|
|
}
|
|
|
|
}
|
2013-10-09 16:10:10 -06:00
|
|
|
}
|
2014-01-24 17:17:36 -07:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
|
2014-01-24 17:17:36 -07:00
|
|
|
DEBUG_OP_printf("load method %p.%s\n", base, qstr_str(attr));
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_load_method_maybe(base, attr, dest);
|
2013-10-09 16:10:10 -06:00
|
|
|
|
2014-01-24 17:17:36 -07:00
|
|
|
if (dest[0] == MP_OBJ_NULL) {
|
2014-01-09 13:57:50 -07:00
|
|
|
// no attribute/method called attr
|
|
|
|
// following CPython, we give a more detailed error message for type objects
|
2014-02-15 09:10:44 -07:00
|
|
|
if (MP_OBJ_IS_TYPE(base, &mp_type_type)) {
|
2014-03-24 16:55:39 -06:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
|
|
|
|
"type object '%s' has no attribute '%s'", qstr_str(((mp_obj_type_t*)base)->name), qstr_str(attr)));
|
2014-01-09 13:57:50 -07:00
|
|
|
} else {
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_AttributeError, "'%s' object has no attribute '%s'", mp_obj_get_type_str(base), qstr_str(attr)));
|
2014-01-09 13:57:50 -07:00
|
|
|
}
|
|
|
|
}
|
2013-10-09 16:10:10 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
|
2013-10-18 12:58:12 -06:00
|
|
|
DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
|
2014-01-09 13:57:50 -07:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(base);
|
|
|
|
if (type->store_attr != NULL) {
|
|
|
|
if (type->store_attr(base, attr, value)) {
|
|
|
|
return;
|
|
|
|
}
|
2013-10-09 16:10:10 -06:00
|
|
|
}
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_AttributeError, "'%s' object has no attribute '%s'", mp_obj_get_type_str(base), qstr_str(attr)));
|
2013-10-09 16:10:10 -06:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_store_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
|
2013-10-18 12:58:12 -06:00
|
|
|
DEBUG_OP_printf("store subscr %p[%p] <- %p\n", base, index, value);
|
2014-03-29 07:43:38 -06:00
|
|
|
if (MP_OBJ_IS_TYPE(base, &mp_type_list)) {
|
2013-10-09 16:10:10 -06:00
|
|
|
// list store
|
2013-12-21 11:17:45 -07:00
|
|
|
mp_obj_list_store(base, index, value);
|
2014-03-29 07:43:38 -06:00
|
|
|
} else if (MP_OBJ_IS_TYPE(base, &mp_type_dict)) {
|
2013-12-21 11:17:45 -07:00
|
|
|
// dict store
|
|
|
|
mp_obj_dict_store(base, index, value);
|
2013-10-04 12:53:11 -06:00
|
|
|
} else {
|
2014-01-18 04:10:51 -07:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(base);
|
|
|
|
if (type->store_item != NULL) {
|
|
|
|
bool r = type->store_item(base, index, value);
|
|
|
|
if (r) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// TODO: call base classes here?
|
|
|
|
}
|
2014-02-15 09:10:44 -07:00
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object does not support item assignment", mp_obj_get_type_str(base)));
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_getiter(mp_obj_t o_in) {
|
2014-01-22 07:35:10 -07:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(o_in);
|
|
|
|
if (type->getiter != NULL) {
|
|
|
|
return type->getiter(o_in);
|
2013-10-15 15:25:17 -06:00
|
|
|
} else {
|
2014-03-26 12:37:06 -06:00
|
|
|
// check for __iter__ method
|
2014-01-24 17:17:36 -07:00
|
|
|
mp_obj_t dest[2];
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___iter__, dest);
|
2014-01-24 17:17:36 -07:00
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
2014-03-26 12:37:06 -06:00
|
|
|
// __iter__ exists, call it and return its result
|
2014-03-30 06:35:08 -06:00
|
|
|
return mp_call_method_n_kw(0, 0, dest);
|
2014-01-24 17:17:36 -07:00
|
|
|
} else {
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___getitem__, dest);
|
2014-03-26 12:37:06 -06:00
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// __getitem__ exists, create an iterator
|
|
|
|
return mp_obj_new_getitem_iter(dest);
|
|
|
|
} else {
|
|
|
|
// object not iterable
|
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object is not iterable", mp_obj_get_type_str(o_in)));
|
|
|
|
}
|
2014-01-24 17:17:36 -07:00
|
|
|
}
|
2013-12-21 11:17:45 -07:00
|
|
|
}
|
|
|
|
}
|
2013-10-16 13:39:12 -06:00
|
|
|
|
2014-03-26 13:27:58 -06:00
|
|
|
// may return MP_OBJ_NULL as an optimisation instead of raise StopIteration()
|
|
|
|
// may also raise StopIteration()
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
|
2014-01-22 07:35:10 -07:00
|
|
|
mp_obj_type_t *type = mp_obj_get_type(o_in);
|
|
|
|
if (type->iternext != NULL) {
|
|
|
|
return type->iternext(o_in);
|
2013-12-21 11:17:45 -07:00
|
|
|
} else {
|
2014-03-26 12:37:06 -06:00
|
|
|
// check for __next__ method
|
|
|
|
mp_obj_t dest[2];
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___next__, dest);
|
2014-03-26 12:37:06 -06:00
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
// __next__ exists, call it and return its result
|
2014-03-30 06:35:08 -06:00
|
|
|
return mp_call_method_n_kw(0, 0, dest);
|
2014-03-26 12:37:06 -06:00
|
|
|
} else {
|
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object is not an iterator", mp_obj_get_type_str(o_in)));
|
|
|
|
}
|
2014-02-15 09:10:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-26 13:27:58 -06:00
|
|
|
// will always return MP_OBJ_NULL instead of raising StopIteration() (or any subclass thereof)
|
|
|
|
// may raise other exceptions
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_iternext(mp_obj_t o_in) {
|
2014-03-26 13:27:58 -06: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 06:35:08 -06:00
|
|
|
mp_load_method_maybe(o_in, MP_QSTR___next__, dest);
|
2014-03-26 13:27:58 -06: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 06:35:08 -06:00
|
|
|
mp_obj_t ret = mp_call_method_n_kw(0, 0, dest);
|
2014-03-26 13:27:58 -06:00
|
|
|
nlr_pop();
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
if (mp_obj_is_subclass_fast(mp_obj_get_type(nlr.ret_val), &mp_type_StopIteration)) {
|
|
|
|
return MP_OBJ_NULL;
|
|
|
|
} else {
|
|
|
|
nlr_jump(nlr.ret_val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "'%s' object is not an iterator", mp_obj_get_type_str(o_in)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 14:14:55 -06: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-30 19:19:12 -06:00
|
|
|
assert((send_value != MP_OBJ_NULL) ^ (throw_value != MP_OBJ_NULL));
|
2014-03-30 14:14:55 -06: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);
|
|
|
|
if (ret != MP_OBJ_NULL) {
|
|
|
|
*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
|
|
|
|
|
|
|
|
if (send_value == mp_const_none) {
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR___next__, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
*ret_val = mp_call_method_n_kw(0, 0, dest);
|
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (throw_value != MP_OBJ_NULL) {
|
|
|
|
if (mp_obj_is_subclass_fast(mp_obj_get_type(throw_value), &mp_type_GeneratorExit)) {
|
|
|
|
mp_load_method_maybe(self_in, MP_QSTR_close, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
*ret_val = mp_call_method_n_kw(0, 0, dest);
|
|
|
|
// We assume one can't "yield" from close()
|
|
|
|
return MP_VM_RETURN_NORMAL;
|
|
|
|
}
|
|
|
|
}
|
2014-03-30 19:14:30 -06:00
|
|
|
mp_load_method_maybe(self_in, MP_QSTR_throw, dest);
|
|
|
|
if (dest[0] != MP_OBJ_NULL) {
|
|
|
|
*ret_val = mp_call_method_n_kw(1, 0, &throw_value);
|
|
|
|
// If .throw() method returned, we assume it's value to yield
|
|
|
|
// - any exception would be thrown with nlr_jump().
|
|
|
|
return MP_VM_RETURN_YIELD;
|
|
|
|
}
|
|
|
|
// 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 14:14:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(0);
|
|
|
|
return MP_VM_RETURN_NORMAL; // Should be unreachable
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_make_raise_obj(mp_obj_t o) {
|
2014-02-15 09:10:44 -07: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 14:05:25 -07: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 06:35:08 -06:00
|
|
|
return mp_call_function_n_kw(o, 0, 0, NULL);
|
2014-02-15 09:10:44 -07: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 15:25:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level) {
|
2014-02-06 13:31:44 -07:00
|
|
|
DEBUG_printf("import name %s\n", qstr_str(name));
|
|
|
|
|
2013-12-10 10:27:24 -07:00
|
|
|
// build args array
|
2013-12-21 11:17:45 -07:00
|
|
|
mp_obj_t args[5];
|
2014-01-22 07:35:10 -07:00
|
|
|
args[0] = MP_OBJ_NEW_QSTR(name);
|
2013-12-21 11:17:45 -07:00
|
|
|
args[1] = mp_const_none; // TODO should be globals
|
|
|
|
args[2] = mp_const_none; // TODO should be locals
|
2013-12-10 10:27:24 -07: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 11:17:45 -07:00
|
|
|
return mp_builtin___import__(5, args);
|
2013-12-10 10:27:24 -07:00
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t mp_import_from(mp_obj_t module, qstr name) {
|
2014-02-06 13:31:44 -07:00
|
|
|
DEBUG_printf("import from %p %s\n", module, qstr_str(name));
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_obj_t x = mp_load_attr(module, name);
|
2013-12-10 10:27:24 -07:00
|
|
|
/* TODO convert AttributeError to ImportError
|
|
|
|
if (fail) {
|
|
|
|
(ImportError, "cannot import name %s", qstr_str(name), NULL)
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_import_all(mp_obj_t module) {
|
2014-02-13 15:22:06 -07:00
|
|
|
DEBUG_printf("import all %p\n", module);
|
|
|
|
|
|
|
|
mp_map_t *map = mp_obj_module_get_globals(module);
|
|
|
|
for (uint i = 0; i < map->alloc; i++) {
|
|
|
|
if (map->table[i].key != MP_OBJ_NULL) {
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_store_name(MP_OBJ_QSTR_VALUE(map->table[i].key), map->table[i].value);
|
2014-02-13 15:22:06 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_map_t *mp_locals_get(void) {
|
2014-01-03 07:03:48 -07:00
|
|
|
return map_locals;
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_locals_set(mp_map_t *m) {
|
|
|
|
DEBUG_OP_printf("mp_locals_set(%p)\n", m);
|
2014-01-03 07:03:48 -07:00
|
|
|
map_locals = m;
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_map_t *mp_globals_get(void) {
|
2014-01-03 07:03:48 -07:00
|
|
|
return map_globals;
|
|
|
|
}
|
|
|
|
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_globals_set(mp_map_t *m) {
|
|
|
|
DEBUG_OP_printf("mp_globals_set(%p)\n", m);
|
2014-01-03 07:03:48 -07:00
|
|
|
map_globals = m;
|
|
|
|
}
|
|
|
|
|
2014-04-04 04:52:59 -06:00
|
|
|
void *m_malloc_fail(int num_bytes) {
|
|
|
|
DEBUG_printf("memory allocation failed, allocating %d bytes\n", num_bytes);
|
|
|
|
nlr_jump((mp_obj_t)&mp_const_MemoryError_obj);
|
|
|
|
}
|
|
|
|
|
2013-11-02 14:34:54 -06:00
|
|
|
// these must correspond to the respective enum
|
2014-03-30 06:35:08 -06:00
|
|
|
void *const mp_fun_table[MP_F_NUMBER_OF] = {
|
|
|
|
mp_load_const_dec,
|
|
|
|
mp_load_const_str,
|
|
|
|
mp_load_name,
|
|
|
|
mp_load_global,
|
|
|
|
mp_load_build_class,
|
|
|
|
mp_load_attr,
|
|
|
|
mp_load_method,
|
|
|
|
mp_store_name,
|
|
|
|
mp_store_attr,
|
|
|
|
mp_store_subscr,
|
|
|
|
mp_obj_is_true,
|
|
|
|
mp_unary_op,
|
|
|
|
mp_binary_op,
|
2014-03-31 09:28:13 -06:00
|
|
|
mp_obj_new_tuple,
|
|
|
|
mp_obj_new_list,
|
|
|
|
mp_obj_list_append,
|
|
|
|
mp_obj_new_dict,
|
|
|
|
mp_obj_dict_store,
|
|
|
|
mp_obj_new_set,
|
|
|
|
mp_obj_set_store,
|
2014-03-30 06:35:08 -06:00
|
|
|
mp_make_function_from_id,
|
|
|
|
mp_call_function_n_kw_for_native,
|
|
|
|
mp_call_method_n_kw,
|
|
|
|
mp_getiter,
|
|
|
|
mp_iternext,
|
2013-10-04 12:53:11 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2014-03-30 06:35:08 -06:00
|
|
|
void mp_f_vector(mp_fun_kind_t fun_kind) {
|
|
|
|
(mp_f_table[fun_kind])();
|
2013-10-04 12:53:11 -06:00
|
|
|
}
|
|
|
|
*/
|