assert(2 <= n_args);

// set the new classes __locals__ object

return new_class;

}

MP_DEFINE_CONST_FUN_OBJ_VAR(mp_builtin___build_class___obj, 2, mp_builtin___build_class__);

STATIC mp_obj_t mp_builtin___repl_print__(mp_obj_t o) {

}

return mp_const_none;

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin___repl_print___obj, mp_builtin___repl_print__);

STATIC mp_obj_t mp_builtin_abs(mp_obj_t o_in) {

return mp_const_none;

}

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_abs_obj, mp_builtin_abs);

STATIC mp_obj_t mp_builtin_all(mp_obj_t o_in) {

}

return mp_const_true;

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_all_obj, mp_builtin_all);

STATIC mp_obj_t mp_builtin_any(mp_obj_t o_in) {

}

return mp_const_false;

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_any_obj, mp_builtin_any);

STATIC mp_obj_t mp_builtin_bin(mp_obj_t o_in) {

mp_obj_t args[] = { MP_OBJ_NEW_QSTR(MP_QSTR__brace_open__colon__hash_b_brace_close_), o_in };

return mp_obj_str_format(MP_ARRAY_SIZE(args), args);

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_bin_obj, mp_builtin_bin);

STATIC mp_obj_t mp_builtin_callable(mp_obj_t o_in) {

return mp_const_false;

}

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_callable_obj, mp_builtin_callable);

STATIC mp_obj_t mp_builtin_chr(mp_obj_t o_in) {

}

#endif

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_chr_obj, mp_builtin_chr);

// TODO make this function more general and less of a hack

mp_obj_dict_t *dict = NULL;

mp_obj_t dir = mp_obj_new_list(0, NULL);

if (dict != NULL) {

if (MP_MAP_SLOT_IS_FILLED(&dict->map, i)) {

mp_obj_list_append(dir, dict->map.table[i].key);

}

return dir;

}

MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_dir_obj, 0, 1, mp_builtin_dir);

STATIC mp_obj_t mp_builtin_divmod(mp_obj_t o1_in, mp_obj_t o2_in) {

nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "unsupported operand type(s) for divmod(): '%s' and '%s'", mp_obj_get_type_str(o1_in), mp_obj_get_type_str(o2_in)));

}

}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_divmod_obj, mp_builtin_divmod);

STATIC mp_obj_t mp_builtin_hash(mp_obj_t o_in) {

// TODO hash will generally overflow small integer; can we safely truncate it?

return mp_obj_new_int(mp_obj_hash(o_in));

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_hash_obj, mp_builtin_hash);

STATIC mp_obj_t mp_builtin_hex(mp_obj_t o_in) {

return mp_binary_op(MP_BINARY_OP_MODULO, MP_OBJ_NEW_QSTR(MP_QSTR__percent__hash_x), o_in);

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_hex_obj, mp_builtin_hex);

STATIC mp_obj_t mp_builtin_iter(mp_obj_t o_in) {

return mp_getiter(o_in);

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_iter_obj, mp_builtin_iter);

mp_map_elem_t *key_elem = mp_map_lookup(kwargs, MP_OBJ_NEW_QSTR(MP_QSTR_key), MP_MAP_LOOKUP);

mp_obj_t key_fn = key_elem == NULL ? MP_OBJ_NULL : key_elem->value;

if (n_args == 1) {

}

}

return mp_builtin_min_max(n_args, args, kwargs, MP_BINARY_OP_MORE);

}

MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_max_obj, 1, mp_builtin_max);

return mp_builtin_min_max(n_args, args, kwargs, MP_BINARY_OP_LESS);

}

MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_min_obj, 1, mp_builtin_min);

return ret;

}

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_next_obj, mp_builtin_next);

STATIC mp_obj_t mp_builtin_oct(mp_obj_t o_in) {

return mp_binary_op(MP_BINARY_OP_MODULO, MP_OBJ_NEW_QSTR(MP_QSTR__percent__hash_o), o_in);

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_oct_obj, mp_builtin_oct);

STATIC mp_obj_t mp_builtin_ord(mp_obj_t o_in) {

const char *str = mp_obj_str_get_data(o_in, &len);

#if MICROPY_PY_BUILTINS_STR_UNICODE

mp_uint_t charlen = unichar_charlen(str, len);

}

#endif

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_ord_obj, mp_builtin_ord);

assert(2 <= n_args && n_args <= 3);

switch (n_args) {

case 2: return mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]);

default: return mp_binary_op(MP_BINARY_OP_MODULO, mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]), args[2]); // TODO optimise...

}

}

MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_pow_obj, 2, 3, mp_builtin_pow);

mp_map_elem_t *sep_elem = mp_map_lookup(kwargs, MP_OBJ_NEW_QSTR(MP_QSTR_sep), MP_MAP_LOOKUP);

mp_map_elem_t *end_elem = mp_map_lookup(kwargs, MP_OBJ_NEW_QSTR(MP_QSTR_end), MP_MAP_LOOKUP);

const char *sep_data = " ";

const char *end_data = "\n";

if (sep_elem != NULL && sep_elem->value != mp_const_none) {

sep_data = mp_obj_str_get_data(sep_elem->value, &sep_len);

}

#endif

return mp_const_none;

}

MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_print_obj, 0, mp_builtin_print);

STATIC mp_obj_t mp_builtin_repr(mp_obj_t o_in) {

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_repr_obj, mp_builtin_repr);

assert(1 <= n_args && n_args <= 2);

mp_obj_t value;

switch (n_args) {

}

return value;

}

MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_sum_obj, 1, 2, mp_builtin_sum);

assert(n_args >= 1);

if (n_args > 1) {

nlr_raise(mp_obj_new_exception_msg(&mp_type_TypeError,

return self;

}

MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_sorted_obj, 1, mp_builtin_sorted);

STATIC mp_obj_t mp_builtin_id(mp_obj_t o_in) {

return mp_obj_new_int_from_uint((mp_uint_t)id);

}

}

MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_id_obj, mp_builtin_id);

}

}

mp_obj_t attr = args[1];

if (MP_OBJ_IS_TYPE(attr, &mp_type_str)) {

attr = mp_obj_str_intern(attr);

}

return mp_load_attr_default(args[0], MP_OBJ_QSTR_VALUE(attr), defval);

}

MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_getattr_obj, 2, 3, mp_builtin_getattr);

STATIC mp_obj_t mp_builtin_hasattr(mp_obj_t object_in, mp_obj_t attr_in) {

return MP_BOOL(dest[0] != MP_OBJ_NULL);

}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_hasattr_obj, mp_builtin_hasattr);

#include "builtin.h"

STATIC mp_obj_t parse_compile_execute(mp_obj_t o_in, mp_parse_input_kind_t parse_input_kind) {

const char *str = mp_obj_str_get_data(o_in, &str_len);

// create the lexer

// go through each path looking for a directory or file

for (int i = 0; i < path_num; i++) {

vstr_reset(dest);

const char *p = mp_obj_str_get_data(path_items[i], &p_len);

if (p_len > 0) {

vstr_add_strn(dest, p, p_len);

}

}

if (level != 0) {

// What we want to do here is to take name of current module,

printf("\n");

uint dots_seen = 0;

const char *p = this_name + this_name_l - 1;

// Otherwise, we need to return top-level package

return top_module_obj;

}

MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin___import___obj, 1, 5, mp_builtin___import__);

mp_obj_t mp_obj_new_cell(mp_obj_t obj);

mp_obj_t mp_obj_new_int(mp_int_t value);

mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value);

mp_obj_t mp_obj_new_int_from_ll(long long val); // this must return a multi-precision integer object (or raise an overflow exception)

#if MICROPY_PY_BUILTINS_FLOAT

mp_obj_t mp_obj_new_float(mp_float_t val);

mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag);

mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type);

mp_obj_t mp_obj_new_exception_arg1(const mp_obj_type_t *exc_type, mp_obj_t arg);

mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg);

mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!)

mp_obj_t mp_obj_new_fun_bc(mp_uint_t scope_flags, qstr *args, mp_uint_t n_pos_args, mp_uint_t n_kwonly_args, mp_obj_t def_args, mp_obj_t def_kw_args, const byte *code);

mp_obj_t mp_obj_new_fun_native(mp_uint_t n_args, void *fun_data);

mp_obj_t mp_obj_new_fun_viper(mp_uint_t n_args, void *fun_data, mp_uint_t type_sig);

mp_obj_t mp_obj_new_fun_asm(mp_uint_t n_args, void *fun_data);

mp_obj_t mp_obj_new_gen_wrap(mp_obj_t fun);

mp_obj_t mp_obj_new_tuple(mp_uint_t n, const mp_obj_t *items);

mp_obj_t mp_obj_new_list(mp_uint_t n, mp_obj_t *items);

mp_obj_t mp_obj_new_dict(mp_uint_t n_args);

void mp_init_emergency_exception_buf(void);

mp_obj_t mp_obj_str_builder_end(mp_obj_t o_in);

mp_obj_t mp_obj_str_builder_end_with_len(mp_obj_t o_in, mp_uint_t len);

bool mp_obj_str_equal(mp_obj_t s1, mp_obj_t s2);

qstr mp_obj_str_get_qstr(mp_obj_t self_in); // use this if you will anyway convert the string to a qstr

const char *mp_obj_str_get_str(mp_obj_t self_in); // use this only if you need the string to be null terminated

mp_obj_t mp_obj_str_intern(mp_obj_t str);

#if MICROPY_PY_BUILTINS_FLOAT

void mp_obj_slice_get(mp_obj_t self_in, mp_obj_t *start, mp_obj_t *stop, mp_obj_t *step);

#define MP_OBJ_FUN_ARGS_MAX (0xffff) // to set maximum value in n_args_max below

mp_int_t step;

} mp_bound_slice_t;

#if MICROPY_PY_BUILTINS_SLICE

bool mp_seq_get_fast_slice_indexes(mp_uint_t len, mp_obj_t slice, mp_bound_slice_t *indexes);

#define mp_seq_copy(dest, src, len, item_t) memcpy(dest, src, len * sizeof(item_t))

#define mp_seq_cat(dest, src1, len1, src2, len2, item_t) { memcpy(dest, src1, (len1) * sizeof(item_t)); memcpy(dest + (len1), src2, (len2) * sizeof(item_t)); }

#define mp_seq_clear(start, len, alloc_len, item_sz) memset((byte*)(start) + (len) * (item_sz), 0, ((alloc_len) - (len)) * (item_sz))

#define mp_seq_replace_slice_no_grow(dest, dest_len, beg, end, slice, slice_len, item_t) \