Merge remote-tracking branch 'upstream/master' into dict_feats

33 files changed, 372 insertions, 254 deletions

diff --git a/py/asmx64.c b/py/asmx64.c
index 226d4efee8..d3158170fb 100644
--- a/py/asmx64.c
+++ b/py/asmx64.c
@@ -1,16 +1,18 @@
 #include <stdio.h>
 #include <assert.h>
-#include <sys/types.h>
-#include <sys/mman.h>
 #include <string.h>
 
 #include "misc.h"
-#include "asmx64.h"
 #include "mpconfig.h"
 
 // wrapper around everything in this file
 #if MICROPY_EMIT_X64
 
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#include "asmx64.h"
+
 #if defined(__OpenBSD__) || defined(__MACH__)
 #define MAP_ANONYMOUS MAP_ANON
 #endif
diff --git a/py/gc.c b/py/gc.c
index 7d4cac6e74..054a3cc315 100644
--- a/py/gc.c
+++ b/py/gc.c
@@ -6,6 +6,8 @@
 #include "mpconfig.h"
 #include "gc.h"
 
+#if MICROPY_ENABLE_GC
+
 // a machine word is big enough to hold a pointer
 /*
 #define BYTES_PER_WORD (8)
@@ -380,3 +382,5 @@ int main(void) {
     gc_dump_at();
 }
 */
+
+#endif // MICROPY_ENABLE_GC
diff --git a/py/lexerunix.c b/py/lexerunix.c
index 14c28c16d9..5336610bae 100644
--- a/py/lexerunix.c
+++ b/py/lexerunix.c
@@ -4,8 +4,11 @@
 #include <fcntl.h>
 
 #include "misc.h"
+#include "mpconfig.h"
 #include "lexer.h"
 
+#if MICROPY_ENABLE_LEXER_UNIX
+
 typedef struct _str_buf_t {
     bool free;                  // free src_beg when done
     const char *src_beg;        // beginning of source
@@ -78,3 +81,5 @@ mp_lexer_t *mp_import_open_file(qstr mod_name) {
     vstr_printf(vstr, "%s.py", qstr_str(mod_name));
     return mp_lexer_new_from_file(vstr_str(vstr)); // TODO does lexer need to copy the string? can we free it here?
 }
+
+#endif // MICROPY_ENABLE_LEXER_UNIX
diff --git a/py/misc.h b/py/misc.h
index 153218ba2f..1bf4d8f291 100644
--- a/py/misc.h
+++ b/py/misc.h
@@ -5,11 +5,7 @@
 
 /** types *******************************************************/
 
-typedef int bool;
-enum {
-    false = 0,
-    true = 1
-};
+#include <stdbool.h>
 
 typedef unsigned char byte;
 typedef unsigned int uint;
diff --git a/py/mpconfig.h b/py/mpconfig.h
index 56495d9156..2017ba366a 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -4,26 +4,67 @@
 
 #include <mpconfigport.h>
 
-#ifndef INT_FMT
-// printf format spec to use for machine_int_t and friends
-#ifdef __LP64__
-// Archs where machine_int_t == long, long != int
-#define UINT_FMT "%lu"
-#define INT_FMT "%ld"
-#else
-// Archs where machine_int_t == int
-#define UINT_FMT "%u"
-#define INT_FMT "%d"
+// Any options not explicitly set in mpconfigport.h will get default
+// values below.
+
+/*****************************************************************************/
+/* Micro Python emitters                                                     */
+
+// Whether to emit CPython byte codes (for debugging/testing)
+// Enabling this overrides all other emitters
+#ifndef MICROPY_EMIT_CPYTHON
+#define MICROPY_EMIT_CPYTHON (0)
 #endif
-#endif //INT_FMT
 
+// Whether to emit x64 native code
+#ifndef MICROPY_EMIT_X64
+#define MICROPY_EMIT_X64 (0)
+#endif
 
-// Any options not explicitly set in mpconfigport.h will get default
-// values below.
+// Whether to emit thumb native code
+#ifndef MICROPY_EMIT_THUMB
+#define MICROPY_EMIT_THUMB (0)
+#endif
+
+// Whether to enable the thumb inline assembler
+#ifndef MICROPY_EMIT_INLINE_THUMB
+#define MICROPY_EMIT_INLINE_THUMB (0)
+#endif
+
+/*****************************************************************************/
+/* Internal debugging stuff                                                  */
 
 // Whether to collect memory allocation stats
 #ifndef MICROPY_MEM_STATS
-#define MICROPY_MEM_STATS (1)
+#define MICROPY_MEM_STATS (0)
+#endif
+
+// Whether to build code to show byte code
+#ifndef MICROPY_SHOW_BC
+#define MICROPY_SHOW_BC (0)
+#endif
+
+/*****************************************************************************/
+/* Fine control over Python features                                         */
+
+// Whether to include the garbage collector
+#ifndef MICROPY_ENABLE_GC
+#define MICROPY_ENABLE_GC (0)
+#endif
+
+// Whether to include REPL helper function
+#ifndef MICROPY_ENABLE_REPL_HELPERS
+#define MICROPY_ENABLE_REPL_HELPERS (0)
+#endif
+
+// Whether to include lexer helper function for unix
+#ifndef MICROPY_ENABLE_LEXER_UNIX
+#define MICROPY_ENABLE_LEXER_UNIX (0)
+#endif
+
+// Whether to support float and complex types
+#ifndef MICROPY_ENABLE_FLOAT
+#define MICROPY_ENABLE_FLOAT (0)
 #endif
 
 // Whether to support slice object and correspondingly
@@ -31,3 +72,19 @@
 #ifndef MICROPY_ENABLE_SLICE
 #define MICROPY_ENABLE_SLICE (1)
 #endif
+
+/*****************************************************************************/
+/* Miscellaneous settings                                                    */
+
+// printf format spec to use for machine_int_t and friends
+#ifndef INT_FMT
+#ifdef __LP64__
+// Archs where machine_int_t == long, long != int
+#define UINT_FMT "%lu"
+#define INT_FMT "%ld"
+#else
+// Archs where machine_int_t == int
+#define UINT_FMT "%u"
+#define INT_FMT "%d"
+#endif
+#endif //INT_FMT
diff --git a/py/mpqstrraw.h b/py/mpqstrraw.h
index fe74c3e927..eeed6f3a0a 100644
--- a/py/mpqstrraw.h
+++ b/py/mpqstrraw.h
@@ -30,6 +30,7 @@ Q(NameError)
 Q(SyntaxError)
 Q(TypeError)
 Q(ValueError)
+Q(OSError)
 
 Q(abs)
 Q(all)
diff --git a/py/obj.h b/py/obj.h
index 1ba7427cbb..332867a194 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -15,15 +15,14 @@ typedef machine_int_t mp_small_int_t;
 typedef machine_float_t mp_float_t;
 #endif
 
-// Anything that wants to be a Micro Python object must
-// have mp_obj_base_t as its first member (except NULL and small ints)
-
-typedef struct _mp_obj_base_t mp_obj_base_t;
-typedef struct _mp_obj_type_t mp_obj_type_t;
+// Anything that wants to be a Micro Python object must have
+// mp_obj_base_t as its first member (except NULL and small ints)
 
+struct _mp_obj_type_t;
 struct _mp_obj_base_t {
-    const mp_obj_type_t *type;
+    const struct _mp_obj_type_t *type;
 };
+typedef struct _mp_obj_base_t mp_obj_base_t;
 
 // The NULL object is used to indicate the absence of an object
 // It *cannot* be used when an mp_obj_t is expected, except where explicitly allowed
@@ -43,12 +42,17 @@ struct _mp_obj_base_t {
 
 #define MP_DECLARE_CONST_FUN_OBJ(obj_name) extern const mp_obj_fun_native_t obj_name
 
-#define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, 0, 0, fun_name}
-#define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, 1, 1, fun_name}
-#define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, 2, 2, fun_name}
-#define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, 3, 3, fun_name}
-#define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, n_args_min, (~((machine_uint_t)0)), fun_name}
-#define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, n_args_min, n_args_max, fun_name}
+#define MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, is_kw, n_args_min, n_args_max, fun_name) const mp_obj_fun_native_t obj_name = {{&fun_native_type}, is_kw, n_args_min, n_args_max, (void *)fun_name}
+#define MP_DEFINE_CONST_FUN_OBJ_0(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 0, 0, (mp_fun_0_t)fun_name)
+#define MP_DEFINE_CONST_FUN_OBJ_1(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 1, 1, (mp_fun_1_t)fun_name)
+#define MP_DEFINE_CONST_FUN_OBJ_2(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 2, 2, (mp_fun_2_t)fun_name)
+#define MP_DEFINE_CONST_FUN_OBJ_3(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, 3, 3, (mp_fun_3_t)fun_name)
+#define MP_DEFINE_CONST_FUN_OBJ_VAR(obj_name, n_args_min, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, n_args_min, (~((machine_uint_t)0)), (mp_fun_var_t)fun_name)
+#define MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(obj_name, n_args_min, n_args_max, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, false, n_args_min, n_args_max, (mp_fun_var_t)fun_name)
+#define MP_DEFINE_CONST_FUN_OBJ_KW(obj_name, fun_name) MP_DEFINE_CONST_FUN_OBJ_VOID_PTR(obj_name, true, 0, (~((machine_uint_t)0)), (mp_fun_var_t)fun_name)
+
+// Need to declare this here so we are not dependent on map.h
+struct _mp_map_t;
 
 // Type definitions for methods
 
@@ -58,10 +62,12 @@ typedef mp_obj_t (*mp_fun_2_t)(mp_obj_t, mp_obj_t);
 typedef mp_obj_t (*mp_fun_3_t)(mp_obj_t, mp_obj_t, mp_obj_t);
 typedef mp_obj_t (*mp_fun_t)(void);
 typedef mp_obj_t (*mp_fun_var_t)(int n, const mp_obj_t *);
+typedef mp_obj_t (*mp_fun_kw_t)(mp_obj_t*, struct _mp_map_t*);
 
 typedef void (*mp_print_fun_t)(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o);
 typedef mp_obj_t (*mp_make_new_fun_t)(mp_obj_t type_in, int n_args, const mp_obj_t *args); // args are in reverse order in the array
 typedef mp_obj_t (*mp_call_n_fun_t)(mp_obj_t fun, int n_args, const mp_obj_t *args); // args are in reverse order in the array
+typedef mp_obj_t (*mp_call_n_kw_fun_t)(mp_obj_t fun, int n_args, int n_kw, const mp_obj_t *args); // args are in reverse order in the array
 typedef mp_obj_t (*mp_unary_op_fun_t)(int op, mp_obj_t);
 typedef mp_obj_t (*mp_binary_op_fun_t)(int op, mp_obj_t, mp_obj_t);
 
@@ -77,13 +83,14 @@ struct _mp_obj_type_t {
     mp_make_new_fun_t make_new;     // to make an instance of the type
 
     mp_call_n_fun_t call_n;
+    mp_call_n_kw_fun_t call_n_kw;
     mp_unary_op_fun_t unary_op;     // can return NULL if op not supported
     mp_binary_op_fun_t binary_op;   // can return NULL if op not supported
 
     mp_fun_1_t getiter;
     mp_fun_1_t iternext;
 
-    const mp_method_t methods[];
+    const mp_method_t *methods;
 
     /*
     What we might need to add here:
@@ -108,6 +115,8 @@ struct _mp_obj_type_t {
     */
 };
 
+typedef struct _mp_obj_type_t mp_obj_type_t;
+
 // Constant objects, globally accessible
 
 extern const mp_obj_type_t mp_const_type;
@@ -118,10 +127,6 @@ extern const mp_obj_t mp_const_empty_tuple;
 extern const mp_obj_t mp_const_ellipsis;
 extern const mp_obj_t mp_const_stop_iteration; // special object indicating end of iteration (not StopIteration exception!)
 
-// Need to declare this here so we are not dependent on map.h
-
-struct _mp_map_t;
-
 // General API for objects
 
 mp_obj_t mp_obj_new_none(void);
@@ -144,8 +149,8 @@ mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun);
 mp_obj_t mp_obj_new_gen_wrap(uint n_locals, uint n_stack, mp_obj_t fun);
 mp_obj_t mp_obj_new_gen_instance(const byte *bytecode, uint n_state, int n_args, const mp_obj_t *args);
 mp_obj_t mp_obj_new_closure(mp_obj_t fun, mp_obj_t closure_tuple);
-mp_obj_t mp_obj_new_tuple(uint n, mp_obj_t *items);
-mp_obj_t mp_obj_new_tuple_reverse(uint n, mp_obj_t *items);
+mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items);
+mp_obj_t mp_obj_new_tuple_reverse(uint n, const mp_obj_t *items);
 mp_obj_t mp_obj_new_list(uint n, mp_obj_t *items);
 mp_obj_t mp_obj_new_list_reverse(uint n, mp_obj_t *items);
 mp_obj_t mp_obj_new_dict(int n_args);
@@ -234,13 +239,15 @@ void mp_obj_slice_get(mp_obj_t self_in, machine_int_t *start, machine_int_t *sto
 // functions
 typedef struct _mp_obj_fun_native_t { // need this so we can define const objects (to go in ROM)
     mp_obj_base_t base;
-    machine_uint_t n_args_min; // inclusive
+    bool is_kw : 1;
+    machine_uint_t n_args_min : (sizeof(machine_uint_t) - 1); // inclusive
     machine_uint_t n_args_max; // inclusive
     void *fun;
     // TODO add mp_map_t *globals
     // for const function objects, make an empty, const map
     // such functions won't be able to access the global scope, but that's probably okay
 } mp_obj_fun_native_t;
+
 extern const mp_obj_type_t fun_native_type;
 extern const mp_obj_type_t fun_bc_type;
 void mp_obj_fun_bc_get(mp_obj_t self_in, int *n_args, uint *n_state, const byte **code);
diff --git a/py/objbool.c b/py/objbool.c
index 77394dab99..cfab7db068 100644
--- a/py/objbool.c
+++ b/py/objbool.c
@@ -34,14 +34,8 @@ static mp_obj_t bool_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args
 const mp_obj_type_t bool_type = {
     { &mp_const_type },
     "bool",
-    bool_print, // print
-    bool_make_new, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .print = bool_print,
+    .make_new = bool_make_new,
 };
 
 static const mp_obj_bool_t false_obj = {{&bool_type}, false};
diff --git a/py/objboundmeth.c b/py/objboundmeth.c
index 4e6d2e0103..78e5c62494 100644
--- a/py/objboundmeth.c
+++ b/py/objboundmeth.c
@@ -36,14 +36,7 @@ mp_obj_t bound_meth_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
 const mp_obj_type_t bound_meth_type = {
     { &mp_const_type },
     "bound_method",
-    NULL, // print
-    NULL, // make_new
-    bound_meth_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .call_n = bound_meth_call_n,
 };
 
 mp_obj_t mp_obj_new_bound_meth(mp_obj_t self, mp_obj_t meth) {
diff --git a/py/objcell.c b/py/objcell.c
index 3465f99198..264125bf3a 100644
--- a/py/objcell.c
+++ b/py/objcell.c
@@ -26,14 +26,6 @@ void mp_obj_cell_set(mp_obj_t self_in, mp_obj_t obj) {
 const mp_obj_type_t cell_type = {
     { &mp_const_type },
     "cell",
-    NULL, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
 };
 
 mp_obj_t mp_obj_new_cell(mp_obj_t obj) {
diff --git a/py/objclass.c b/py/objclass.c
index 536abdf7e3..d13d1775a4 100644
--- a/py/objclass.c
+++ b/py/objclass.c
@@ -63,14 +63,7 @@ mp_map_t *mp_obj_class_get_locals(mp_obj_t self_in) {
 const mp_obj_type_t class_type = {
     { &mp_const_type },
     "class",
-    NULL, // print
-    NULL, // make_new
-    class_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .call_n = class_call_n,
 };
 
 mp_obj_t mp_obj_new_class(mp_map_t *class_locals) {
diff --git a/py/objclosure.c b/py/objclosure.c
index 3317eb86f4..b372ee6fe7 100644
--- a/py/objclosure.c
+++ b/py/objclosure.c
@@ -35,14 +35,7 @@ mp_obj_t closure_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
 const mp_obj_type_t closure_type = {
     { &mp_const_type },
     "closure",
-    NULL, // print
-    NULL, // make_new
-    closure_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .call_n = closure_call_n,
 };
 
 mp_obj_t mp_obj_new_closure(mp_obj_t fun, mp_obj_t closure_tuple) {
diff --git a/py/objcomplex.c b/py/objcomplex.c
index 46f43b54b5..1036bae420 100644
--- a/py/objcomplex.c
+++ b/py/objcomplex.c
@@ -87,14 +87,10 @@ static mp_obj_t complex_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
 const mp_obj_type_t complex_type = {
     { &mp_const_type },
     "complex",
-    complex_print, // print
-    complex_make_new, // make_new
-    NULL, // call_n
-    complex_unary_op, // unary_op
-    complex_binary_op, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = { { NULL, NULL }, },
+    .print = complex_print,
+    .make_new = complex_make_new,
+    .unary_op = complex_unary_op,
+    .binary_op = complex_binary_op,
 };
 
 mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag) {
diff --git a/py/objexcept.c b/py/objexcept.c
index 22b8c58126..829b147853 100644
--- a/py/objexcept.c
+++ b/py/objexcept.c
@@ -38,14 +38,7 @@ void exception_print(void (*print)(void *env, const char *fmt, ...), void *env,
 const mp_obj_type_t exception_type = {
     { &mp_const_type },
     "exception",
-    exception_print, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .print = exception_print,
 };
 
 mp_obj_t mp_obj_new_exception(qstr id) {
diff --git a/py/objfloat.c b/py/objfloat.c
index 336ae597fc..d21472d5d6 100644
--- a/py/objfloat.c
+++ b/py/objfloat.c
@@ -68,7 +68,6 @@ const mp_obj_type_t float_type = {
     .make_new = float_make_new,
     .unary_op = float_unary_op,
     .binary_op = float_binary_op,
-    .methods = { { NULL, NULL }, },
 };
 
 mp_obj_t mp_obj_new_float(mp_float_t value) {
diff --git a/py/objfun.c b/py/objfun.c
index 0db6459a39..395824b046 100644
--- a/py/objfun.c
+++ b/py/objfun.c
@@ -17,9 +17,13 @@
 
 // mp_obj_fun_native_t defined in obj.h
 
+mp_obj_t fun_native_call_n_kw(mp_obj_t self_in, int n_args, int n_kw, const mp_obj_t *args);
 // args are in reverse order in the array
 mp_obj_t fun_native_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
     mp_obj_fun_native_t *self = self_in;
+    if (self->is_kw) {
+        return fun_native_call_n_kw(self_in, n_args, 0, args);
+    }
     if (self->n_args_min == self->n_args_max) {
         // function requires a fixed number of arguments
 
@@ -69,19 +73,29 @@ mp_obj_t fun_native_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
     }
 }
 
+mp_obj_t fun_native_call_n_kw(mp_obj_t self_in, int n_args, int n_kw, const mp_obj_t *args) {
+    mp_obj_fun_native_t *self = self_in;
+
+    if (!self->is_kw) {
+        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "function does not take keyword arguments"));
+    }
+
+    mp_obj_t *vargs = mp_obj_new_tuple_reverse(n_args, args + 2*n_kw);
+    mp_map_t *kw_args = mp_map_new(MP_MAP_QSTR, n_kw);
+    for (int i = 0; i < 2*n_kw; i+=2) {
+        qstr name = mp_obj_str_get(args[i+1]);
+        mp_qstr_map_lookup(kw_args, name, true)->value = args[i];
+    }
+    mp_obj_t res = ((mp_fun_kw_t)self->fun)(vargs, kw_args);
+    /* TODO clean up vargs and kw_args */
+    return res;
+}
+
 const mp_obj_type_t fun_native_type = {
     { &mp_const_type },
     "function",
-    NULL, // print
-    NULL, // make_new
-    fun_native_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {
-        {NULL, NULL}, // end-of-list sentinel
-    },
+    .call_n = fun_native_call_n,
+    .call_n_kw = fun_native_call_n_kw,
 };
 
 mp_obj_t rt_make_function_0(mp_fun_0_t fun) {
@@ -174,16 +188,7 @@ mp_obj_t fun_bc_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
 const mp_obj_type_t fun_bc_type = {
     { &mp_const_type },
     "function",
-    NULL, // print
-    NULL, // make_new
-    fun_bc_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {
-        {NULL, NULL}, // end-of-list sentinel
-    },
+    .call_n = fun_bc_call_n,
 };
 
 mp_obj_t mp_obj_new_fun_bc(int n_args, uint n_state, const byte *code) {
@@ -288,16 +293,7 @@ mp_obj_t fun_asm_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
 static const mp_obj_type_t fun_asm_type = {
     { &mp_const_type },
     "function",
-    NULL, // print
-    NULL, // make_new
-    fun_asm_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {
-        {NULL, NULL}, // end-of-list sentinel
-    },
+    .call_n = fun_asm_call_n,
 };
 
 mp_obj_t mp_obj_new_fun_asm(uint n_args, void *fun) {
diff --git a/py/objgenerator.c b/py/objgenerator.c
index a91b0d6fc6..7eeb4ef80b 100644
--- a/py/objgenerator.c
+++ b/py/objgenerator.c
@@ -39,14 +39,7 @@ mp_obj_t gen_wrap_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
 const mp_obj_type_t gen_wrap_type = {
     { &mp_const_type },
     "generator",
-    NULL, // print
-    NULL, // make_new
-    gen_wrap_call_n, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .call_n = gen_wrap_call_n,
 };
 
 mp_obj_t mp_obj_new_gen_wrap(uint n_locals, uint n_stack, mp_obj_t fun) {
@@ -94,14 +87,9 @@ mp_obj_t gen_instance_iternext(mp_obj_t self_in) {
 const mp_obj_type_t gen_instance_type = {
     { &mp_const_type },
     "generator",
-    gen_instance_print, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    gen_instance_getiter, // getiter
-    gen_instance_iternext, // iternext
-    .methods = {{NULL, NULL},},
+    .print = gen_instance_print,
+    .getiter = gen_instance_getiter,
+    .iternext = gen_instance_iternext,
 };
 
 // args are in reverse order in the array
diff --git a/py/objinstance.c b/py/objinstance.c
index 8ef2773fd9..209643e2bf 100644
--- a/py/objinstance.c
+++ b/py/objinstance.c
@@ -92,14 +92,6 @@ void mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
 const mp_obj_type_t instance_type = {
     { &mp_const_type },
     "instance",
-    NULL, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
 };
 
 mp_obj_t mp_obj_new_instance(mp_obj_t class) {
diff --git a/py/objint.c b/py/objint.c
index 8d69c4e7a7..9cd5ebae29 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -34,7 +34,6 @@ const mp_obj_type_t int_type = {
     { &mp_const_type },
     "int",
     .make_new = int_make_new,
-    .methods = { { NULL, NULL }, },
 };
 
 mp_obj_t mp_obj_new_int(machine_int_t value) {
diff --git a/py/objlist.c b/py/objlist.c
index 02a6b1525b..5162fa09ff 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -8,6 +8,7 @@
 #include "mpconfig.h"
 #include "mpqstr.h"
 #include "obj.h"
+#include "map.h"
 #include "runtime0.h"
 #include "runtime.h"
 
@@ -57,6 +58,7 @@ static mp_obj_t list_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args
         default:
             nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "list takes at most 1 argument, %d given", (void*)(machine_int_t)n_args));
     }
+    return NULL;
 }
 
 static mp_obj_t list_binary_op(int op, mp_obj_t lhs, mp_obj_t rhs) {
@@ -119,14 +121,15 @@ static mp_obj_t list_pop(int n_args, const mp_obj_t *args) {
 }
 
 // TODO make this conform to CPython's definition of sort
-static void mp_quicksort(mp_obj_t *head, mp_obj_t *tail, mp_obj_t key_fn) {
+static void mp_quicksort(mp_obj_t *head, mp_obj_t *tail, mp_obj_t key_fn, bool reversed) {
+    int op = reversed ? RT_COMPARE_OP_MORE : RT_COMPARE_OP_LESS;
     while (head < tail) {
         mp_obj_t *h = head - 1;
         mp_obj_t *t = tail;
-        mp_obj_t v = rt_call_function_1(key_fn, tail[0]); // get pivot using key_fn
+        mp_obj_t v = key_fn == NULL ? tail[0] : rt_call_function_1(key_fn, tail[0]); // get pivot using key_fn
         for (;;) {
-            do ++h; while (rt_compare_op(RT_COMPARE_OP_LESS, rt_call_function_1(key_fn, h[0]), v) == mp_const_true);
-            do --t; while (h < t && rt_compare_op(RT_COMPARE_OP_LESS, v, rt_call_function_1(key_fn, t[0])) == mp_const_true);
+            do ++h; while (rt_compare_op(op, key_fn == NULL ? h[0] : rt_call_function_1(key_fn, h[0]), v) == mp_const_true);
+            do --t; while (h < t && rt_compare_op(op, v, key_fn == NULL ? t[0] : rt_call_function_1(key_fn, t[0])) == mp_const_true);
             if (h >= t) break;
             mp_obj_t x = h[0];
             h[0] = t[0];
@@ -135,16 +138,31 @@ static void mp_quicksort(mp_obj_t *head, mp_obj_t *tail, mp_obj_t key_fn) {
         mp_obj_t x = h[0];
         h[0] = tail[0];
         tail[0] = x;
-        mp_quicksort(head, t, key_fn);
+        mp_quicksort(head, t, key_fn, reversed);
         head = h + 1;
     }
 }
 
-static mp_obj_t list_sort(mp_obj_t self_in, mp_obj_t key_fn) {
-    assert(MP_OBJ_IS_TYPE(self_in, &list_type));
-    mp_obj_list_t *self = self_in;
+static mp_obj_t list_sort(mp_obj_t *args, mp_map_t *kwargs) {
+    mp_obj_t *args_items = NULL;
+    machine_uint_t args_len = 0;
+    qstr key_idx = qstr_from_str_static("key");
+    qstr reverse_idx = qstr_from_str_static("reverse");
+
+    assert(MP_OBJ_IS_TYPE(args, &tuple_type));
+    mp_obj_tuple_get(args, &args_len, &args_items);
+    assert(args_len >= 1);
+    if (args_len > 1) {
+        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError,
+                                          "list.sort takes no positional arguments"));
+    }
+    mp_obj_list_t *self = args_items[0];
     if (self->len > 1) {
-        mp_quicksort(self->items, self->items + self->len - 1, key_fn);
+        mp_map_elem_t *keyfun = mp_qstr_map_lookup(kwargs, key_idx, false);
+        mp_map_elem_t *reverse = mp_qstr_map_lookup(kwargs, reverse_idx, false);
+        mp_quicksort(self->items, self->items + self->len - 1,
+                     keyfun ? keyfun->value : NULL,
+                     reverse && reverse->value ? rt_is_true(reverse->value) : false);
     }
     return mp_const_none; // return None, as per CPython
 }
@@ -258,29 +276,30 @@ static MP_DEFINE_CONST_FUN_OBJ_3(list_insert_obj, list_insert);
 static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(list_pop_obj, 1, 2, list_pop);
 static MP_DEFINE_CONST_FUN_OBJ_2(list_remove_obj, list_remove);
 static MP_DEFINE_CONST_FUN_OBJ_1(list_reverse_obj, list_reverse);
-static MP_DEFINE_CONST_FUN_OBJ_2(list_sort_obj, list_sort);
+static MP_DEFINE_CONST_FUN_OBJ_KW(list_sort_obj, list_sort);
+
+static const mp_method_t list_type_methods[] = {
+    { "append", &list_append_obj },
+    { "clear", &list_clear_obj },
+    { "copy", &list_copy_obj },
+    { "count", &list_count_obj },
+    { "index", &list_index_obj },
+    { "insert", &list_insert_obj },
+    { "pop", &list_pop_obj },
+    { "remove", &list_remove_obj },
+    { "reverse", &list_reverse_obj },
+    { "sort", &list_sort_obj },
+    { NULL, NULL }, // end-of-list sentinel
+};
 
 const mp_obj_type_t list_type = {
     { &mp_const_type },
     "list",
     .print = list_print,
     .make_new = list_make_new,
-    .unary_op = NULL,
     .binary_op = list_binary_op,
     .getiter = list_getiter,
-    .methods = {
-        { "append", &list_append_obj },
-        { "clear", &list_clear_obj },
-        { "copy", &list_copy_obj },
-        { "count", &list_count_obj },
-        { "index", &list_index_obj },
-        { "insert", &list_insert_obj },
-        { "pop", &list_pop_obj },
-        { "remove", &list_remove_obj },
-        { "reverse", &list_reverse_obj },
-        { "sort", &list_sort_obj },
-        { NULL, NULL }, // end-of-list sentinel
-    },
+    .methods = list_type_methods,
 };
 
 static mp_obj_list_t *list_new(uint n) {
@@ -344,7 +363,6 @@ static const mp_obj_type_t list_it_type = {
     { &mp_const_type },
     "list_iterator",
     .iternext = list_it_iternext,
-    .methods = { { NULL, NULL }, },
 };
 
 mp_obj_t mp_obj_new_list_iterator(mp_obj_list_t *list, int cur) {
diff --git a/py/objmodule.c b/py/objmodule.c
index 2d6f9555e8..7b92b76f42 100644
--- a/py/objmodule.c
+++ b/py/objmodule.c
@@ -6,6 +6,7 @@
 #include "nlr.h"
 #include "misc.h"
 #include "mpconfig.h"
+#include "mpqstr.h"
 #include "obj.h"
 #include "runtime.h"
 #include "map.h"
@@ -24,21 +25,15 @@ void module_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_
 const mp_obj_type_t module_type = {
     { &mp_const_type },
     "module",
-    module_print, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .print = module_print,
 };
 
 mp_obj_t mp_obj_new_module(qstr module_name) {
     mp_obj_module_t *o = m_new_obj(mp_obj_module_t);
     o->base.type = &module_type;
     o->name = module_name;
-    o->globals = mp_map_new(MP_MAP_QSTR, 0);
+    o->globals = mp_map_new(MP_MAP_QSTR, 1);
+    mp_qstr_map_lookup(o->globals, MP_QSTR___name__, true)->value = mp_obj_new_str(module_name);
     return o;
 }
 
diff --git a/py/objnone.c b/py/objnone.c
index 877e61fe5c..c0efe6c0f5 100644
--- a/py/objnone.c
+++ b/py/objnone.c
@@ -18,7 +18,6 @@ const mp_obj_type_t none_type = {
     { &mp_const_type },
     "NoneType",
     .print = none_print,
-    .methods = {{NULL, NULL},},
 };
 
 static const mp_obj_none_t none_obj = {{&none_type}};
diff --git a/py/objrange.c b/py/objrange.c
index 1ef42673f4..a2a0e67b00 100644
--- a/py/objrange.c
+++ b/py/objrange.c
@@ -25,14 +25,7 @@ mp_obj_t range_getiter(mp_obj_t o_in) {
 static const mp_obj_type_t range_type = {
     { &mp_const_type} ,
     "range",
-    NULL, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    range_getiter,
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .getiter = range_getiter,
 };
 
 // range is a class and instances are immutable sequence objects
@@ -70,14 +63,7 @@ mp_obj_t range_it_iternext(mp_obj_t o_in) {
 static const mp_obj_type_t range_it_type = {
     { &mp_const_type },
     "range_iterator",
-    NULL, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    range_it_iternext,
-    .methods = {{NULL, NULL},},
+    .iternext = range_it_iternext,
 };
 
 mp_obj_t mp_obj_new_range_iterator(int cur, int stop, int step) {
diff --git a/py/objset.c b/py/objset.c
index dd9a4d1e1d..67dab11dfb 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -57,14 +57,8 @@ static mp_obj_t set_make_new(mp_obj_t type_in, int n_args, const mp_obj_t *args)
 const mp_obj_type_t set_type = {
     { &mp_const_type },
     "set",
-    set_print, // print
-    set_make_new, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = { { NULL, NULL }, },
+    .print = set_print,
+    .make_new = set_make_new,
 };
 
 mp_obj_t mp_obj_new_set(int n_args, mp_obj_t *items) {
diff --git a/py/objslice.c b/py/objslice.c
index da69b92af2..d95ccef06f 100644
--- a/py/objslice.c
+++ b/py/objslice.c
@@ -23,14 +23,7 @@ void ellipsis_print(void (*print)(void *env, const char *fmt, ...), void *env, m
 const mp_obj_type_t ellipsis_type = {
     { &mp_const_type },
     "ellipsis",
-    ellipsis_print, // print
-    NULL, // make_new
-    NULL, // call_n
-    NULL, // unary_op
-    NULL, // binary_op
-    NULL, // getiter
-    NULL, // iternext
-    .methods = {{NULL, NULL},},
+    .print = ellipsis_print,
 };
 
 static const mp_obj_ellipsis_t ellipsis_obj = {{&ellipsis_type}};
@@ -58,7 +51,6 @@ const mp_obj_type_t slice_type = {
     { &mp_const_type },
     "slice",
     .print = slice_print,
-    .methods = { { NULL, NULL }, },
 };
 
 // TODO: Make sure to handle "empty" values, which are signified by None in CPython
diff --git a/py/objstr.c b/py/objstr.c
index db3e0beca0..cc9f7f85b4 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -184,17 +184,19 @@ mp_obj_t str_format(int n_args, const mp_obj_t *args) {
 static MP_DEFINE_CONST_FUN_OBJ_2(str_join_obj, str_join);
 static MP_DEFINE_CONST_FUN_OBJ_VAR(str_format_obj, 1, str_format);
 
+static const mp_method_t str_type_methods[] = {
+    { "join", &str_join_obj },
+    { "format", &str_format_obj },
+    { NULL, NULL }, // end-of-list sentinel
+};
+
 const mp_obj_type_t str_type = {
     { &mp_const_type },
     "str",
     .print = str_print,
     .binary_op = str_binary_op,
     .getiter = str_getiter,
-    .methods = {
-        { "join", &str_join_obj },
-        { "format", &str_format_obj },
-        { NULL, NULL }, // end-of-list sentinel
-    },
+    .methods = str_type_methods,
 };
 
 mp_obj_t mp_obj_new_str(qstr qstr) {
@@ -235,7 +237,6 @@ static const mp_obj_type_t str_it_type = {
     { &mp_const_type },
     "str_iterator",
     .iternext = str_it_iternext,
-    .methods = { { NULL, NULL }, },
 };
 
 mp_obj_t mp_obj_new_str_iterator(mp_obj_str_t *str, int cur) {
diff --git a/py/objtuple.c b/py/objtuple.c
index ceca4200e4..0050fc5ea0 100644
--- a/py/objtuple.c
+++ b/py/objtuple.c
@@ -103,14 +103,13 @@ const mp_obj_type_t tuple_type = {
     .make_new = tuple_make_new,
     .binary_op = tuple_binary_op,
     .getiter = tuple_getiter,
-    .methods = {{NULL, NULL},},
 };
 
 // the zero-length tuple
 static const mp_obj_tuple_t empty_tuple_obj = {{&tuple_type}, 0};
 const mp_obj_t mp_const_empty_tuple = (mp_obj_t)&empty_tuple_obj;
 
-mp_obj_t mp_obj_new_tuple(uint n, mp_obj_t *items) {
+mp_obj_t mp_obj_new_tuple(uint n, const mp_obj_t *items) {
     if (n == 0) {
         return mp_const_empty_tuple;
     }
@@ -123,7 +122,7 @@ mp_obj_t mp_obj_new_tuple(uint n, mp_obj_t *items) {
     return o;
 }
 
-mp_obj_t mp_obj_new_tuple_reverse(uint n, mp_obj_t *items) {
+mp_obj_t mp_obj_new_tuple_reverse(uint n, const mp_obj_t *items) {
     if (n == 0) {
         return mp_const_empty_tuple;
     }
@@ -166,7 +165,6 @@ static const mp_obj_type_t tuple_it_type = {
     { &mp_const_type },
     "tuple_iterator",
     .iternext = tuple_it_iternext,
-    .methods = {{NULL, NULL},},
 };
 
 static mp_obj_t mp_obj_new_tuple_iterator(mp_obj_tuple_t *tuple, int cur) {
diff --git a/py/objtype.c b/py/objtype.c
index 37d40b38f4..8778c180ca 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -27,5 +27,4 @@ const mp_obj_type_t mp_const_type = {
     "type",
     .print = type_print,
     .call_n = type_call_n,
-    .methods = {{NULL, NULL},},
 };
diff --git a/py/py.mk b/py/py.mk
new file mode 100644
index 0000000000..3ed8a3e3d7
--- /dev/null
+++ b/py/py.mk
@@ -0,0 +1,105 @@
+# default settings; can be overriden in main Makefile
+
+ifndef PY_SRC
+PY_SRC = ../py
+endif
+
+ifndef BUILD
+BUILD = build
+endif
+
+# to create the build directory
+
+$(BUILD):
+	mkdir -p $@
+
+# where py object files go (they have a name prefix to prevent filename clashes)
+
+PY_BUILD = $(BUILD)/py.
+
+# py object files
+
+PY_O_BASENAME = \
+	nlrx86.o \
+	nlrx64.o \
+	nlrthumb.o \
+	malloc.o \
+	gc.o \
+	qstr.o \
+	vstr.o \
+	unicode.o \
+	lexer.o \
+	lexerunix.o \
+	parse.o \
+	scope.o \
+	compile.o \
+	emitcommon.o \
+	emitpass1.o \
+	emitcpy.o \
+	emitbc.o \
+	asmx64.o \
+	emitnx64.o \
+	asmthumb.o \
+	emitnthumb.o \
+	emitinlinethumb.o \
+	runtime.o \
+	map.o \
+	obj.o \
+	objbool.o \
+	objboundmeth.o \
+	objcell.o \
+	objclass.o \
+	objclosure.o \
+	objcomplex.o \
+	objdict.o \
+	objexcept.o \
+	objfloat.o \
+	objfun.o \
+	objgenerator.o \
+	objinstance.o \
+	objint.o \
+	objlist.o \
+	objmodule.o \
+	objnone.o \
+	objrange.o \
+	objset.o \
+	objslice.o \
+	objstr.o \
+	objtuple.o \
+	objtype.o \
+	builtin.o \
+	builtinimport.o \
+	vm.o \
+	showbc.o \
+	repl.o \
+
+# prepend the build destination prefix to the py object files
+
+PY_O = $(addprefix $(PY_BUILD), $(PY_O_BASENAME))
+
+$(PY_BUILD)emitnx64.o: $(PY_SRC)/emitnative.c $(PY_SRC)/emit.h mpconfigport.h
+	$(CC) $(CFLAGS) -DN_X64 -c -o $@ $<
+
+$(PY_BUILD)emitnthumb.o: $(PY_SRC)/emitnative.c $(PY_SRC)/emit.h mpconfigport.h
+	$(CC) $(CFLAGS) -DN_THUMB -c -o $@ $<
+
+$(PY_BUILD)%.o: $(PY_SRC)/%.S
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+$(PY_BUILD)%.o: $(PY_SRC)/%.c mpconfigport.h
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+# optimising gc for speed; 5ms down to 4ms on pybv2
+$(PY_BUILD)gc.o: $(PY_SRC)/gc.c
+	$(CC) $(CFLAGS) -O3 -c -o $@ $<
+
+# optimising vm for speed, adds only a small amount to code size but makes a huge difference to speed (20% faster)
+$(PY_BUILD)vm.o: $(PY_SRC)/vm.c
+	$(CC) $(CFLAGS) -O3 -c -o $@ $<
+
+# header dependencies
+
+$(PY_BUILD)parse.o: $(PY_SRC)/grammar.h
+$(PY_BUILD)compile.o: $(PY_SRC)/grammar.h
+$(PY_BUILD)/emitcpy.o: $(PY_SRC)/emit.h
+$(PY_BUILD)emitbc.o: $(PY_SRC)/emit.h
diff --git a/py/repl.c b/py/repl.c
index 4241ef0e4c..473313c1ef 100644
--- a/py/repl.c
+++ b/py/repl.c
@@ -1,6 +1,9 @@
 #include "misc.h"
+#include "mpconfig.h"
 #include "repl.h"
 
+#if MICROPY_ENABLE_REPL_HELPERS
+
 bool str_startswith_word(const char *str, const char *head) {
     int i;
     for (i = 0; str[i] && head[i]; i++) {
@@ -42,3 +45,5 @@ bool mp_repl_is_compound_stmt(const char *line) {
     }
     return n_paren > 0 || n_brack > 0 || n_brace > 0;
 }
+
+#endif // MICROPY_ENABLE_REPL_HELPERS
diff --git a/py/repl.h b/py/repl.h
index 02fe523ed4..23259fa90d 100644
--- a/py/repl.h
+++ b/py/repl.h
@@ -1 +1,3 @@
+#if MICROPY_ENABLE_REPL_HELPERS
 bool mp_repl_is_compound_stmt(const char *line);
+#endif
diff --git a/py/runtime.c b/py/runtime.c
index f3fabc39c9..5c476d9ecf 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -61,7 +61,8 @@ typedef struct _mp_code_t {
 } mp_code_t;
 
 static int next_unique_code_id;
-static mp_code_t *unique_codes;
+static machine_uint_t unique_codes_alloc = 0;
+static mp_code_t *unique_codes = NULL;
 
 #ifdef WRITE_CODE
 FILE *fp_write_code = NULL;
@@ -83,6 +84,7 @@ void rt_init(void) {
     mp_qstr_map_lookup(&map_builtins, MP_QSTR_TypeError, true)->value = mp_obj_new_exception(MP_QSTR_TypeError);
     mp_qstr_map_lookup(&map_builtins, MP_QSTR_SyntaxError, true)->value = mp_obj_new_exception(MP_QSTR_SyntaxError);
     mp_qstr_map_lookup(&map_builtins, MP_QSTR_ValueError, true)->value = mp_obj_new_exception(MP_QSTR_ValueError);
+    mp_qstr_map_lookup(&map_builtins, MP_QSTR_OSError, true)->value = mp_obj_new_exception(MP_QSTR_OSError);
 
     // built-in objects
     mp_qstr_map_lookup(&map_builtins, MP_QSTR_Ellipsis, true)->value = mp_const_ellipsis;
@@ -126,6 +128,7 @@ void rt_init(void) {
     mp_qstr_map_lookup(&map_builtins, MP_QSTR_sum, true)->value = rt_make_function_var(1, mp_builtin_sum);
 
     next_unique_code_id = 1; // 0 indicates "no code"
+    unique_codes_alloc = 0;
     unique_codes = NULL;
 
 #ifdef WRITE_CODE
@@ -134,6 +137,7 @@ void rt_init(void) {
 }
 
 void rt_deinit(void) {
+    m_del(mp_code_t, unique_codes, unique_codes_alloc);
 #ifdef WRITE_CODE
     if (fp_write_code != NULL) {
         fclose(fp_write_code);
@@ -146,18 +150,20 @@ int rt_get_unique_code_id(void) {
 }
 
 static void alloc_unique_codes(void) {
-    if (unique_codes == NULL) {
-        unique_codes = m_new(mp_code_t, next_unique_code_id + 10); // XXX hack until we fix the REPL allocation problem
-        for (int i = 0; i < next_unique_code_id; i++) {
+    if (next_unique_code_id > unique_codes_alloc) {
+        // increase size of unique_codes table
+        unique_codes = m_renew(mp_code_t, unique_codes, unique_codes_alloc, next_unique_code_id);
+        for (int i = unique_codes_alloc; i < next_unique_code_id; i++) {
             unique_codes[i].kind = MP_CODE_NONE;
         }
+        unique_codes_alloc = next_unique_code_id;
     }
 }
 
 void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args, int n_locals, int n_stack, bool is_generator) {
     alloc_unique_codes();
 
-    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
+    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id && unique_codes[unique_code_id].kind == MP_CODE_NONE);
     unique_codes[unique_code_id].kind = MP_CODE_BYTE;
     unique_codes[unique_code_id].n_args = n_args;
     unique_codes[unique_code_id].n_locals = n_locals;
@@ -192,7 +198,7 @@ void rt_assign_byte_code(int unique_code_id, byte *code, uint len, int n_args, i
 void rt_assign_native_code(int unique_code_id, void *fun, uint len, int n_args) {
     alloc_unique_codes();
 
-    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
+    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id && unique_codes[unique_code_id].kind == MP_CODE_NONE);
     unique_codes[unique_code_id].kind = MP_CODE_NATIVE;
     unique_codes[unique_code_id].n_args = n_args;
     unique_codes[unique_code_id].n_locals = 0;
@@ -225,7 +231,7 @@ void rt_assign_native_code(int unique_code_id, void *fun, uint len, int n_args)
 void rt_assign_inline_asm_code(int unique_code_id, void *fun, uint len, int n_args) {
     alloc_unique_codes();
 
-    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id);
+    assert(1 <= unique_code_id && unique_code_id < next_unique_code_id && unique_codes[unique_code_id].kind == MP_CODE_NONE);
     unique_codes[unique_code_id].kind = MP_CODE_INLINE_ASM;
     unique_codes[unique_code_id].n_args = n_args;
     unique_codes[unique_code_id].n_locals = 0;
@@ -683,10 +689,20 @@ mp_obj_t rt_call_function_n(mp_obj_t fun_in, int n_args, const mp_obj_t *args) {
 
 // args are in reverse order in the array; keyword arguments come first, value then key
 // eg: (value1, key1, value0, key0, arg1, arg0)
-mp_obj_t rt_call_function_n_kw(mp_obj_t fun, uint n_args, uint n_kw, const mp_obj_t *args) {
-    // TODO
-    assert(0);
-    return mp_const_none;
+mp_obj_t rt_call_function_n_kw(mp_obj_t fun_in, uint n_args, uint n_kw, const mp_obj_t *args) {
+    // TODO merge this and _n into a single, smarter thing
+    DEBUG_OP_printf("calling function %p(n_args=%d, n_kw=%d, args=%p)\n", fun_in, n_args, n_kw, args);
+
+    if (MP_OBJ_IS_SMALL_INT(fun_in)) {
+        nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "'int' object is not callable"));
+    } else {
+        mp_obj_base_t *fun = fun_in;
+        if (fun->type->call_n_kw != NULL) {
+            return fun->type->call_n_kw(fun_in, n_args, n_kw, args);
+        } else {
+            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "'%s' object is not callable", fun->type->name));
+        }
+    }
 }
 
 // args contains: arg(n_args-1)  arg(n_args-2)  ...  arg(0)  self/NULL  fun
@@ -775,10 +791,12 @@ mp_obj_t rt_load_attr(mp_obj_t base, qstr attr) {
     } else if (MP_OBJ_IS_OBJ(base)) {
         // generic method lookup
         mp_obj_base_t *o = base;
-        const mp_method_t *meth = &o->type->methods[0];
-        for (; meth->name != NULL; meth++) {
-            if (strcmp(meth->name, qstr_str(attr)) == 0) {
-                return mp_obj_new_bound_meth(base, (mp_obj_t)meth->fun);
+        const mp_method_t *meth = o->type->methods;
+        if (meth != NULL) {
+            for (; meth->name != NULL; meth++) {
+                if (strcmp(meth->name, qstr_str(attr)) == 0) {
+                    return mp_obj_new_bound_meth(base, (mp_obj_t)meth->fun);
+                }
             }
         }
     }
@@ -799,12 +817,14 @@ void rt_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
     } else if (MP_OBJ_IS_OBJ(base)) {
         // generic method lookup
         mp_obj_base_t *o = base;
-        const mp_method_t *meth = &o->type->methods[0];
-        for (; meth->name != NULL; meth++) {
-            if (strcmp(meth->name, qstr_str(attr)) == 0) {
-                dest[1] = (mp_obj_t)meth->fun;
-                dest[0] = base;
-                return;
+        const mp_method_t *meth = o->type->methods;
+        if (meth != NULL) {
+            for (; meth->name != NULL; meth++) {
+                if (strcmp(meth->name, qstr_str(attr)) == 0) {
+                    dest[1] = (mp_obj_t)meth->fun;
+                    dest[0] = base;
+                    return;
+                }
             }
         }
     }
diff --git a/py/showbc.c b/py/showbc.c
index eb7d41b24d..aea0aff67a 100644
--- a/py/showbc.c
+++ b/py/showbc.c
@@ -8,6 +8,8 @@
 #include "mpconfig.h"
 #include "bc0.h"
 
+#if MICROPY_SHOW_BC
+
 #define DECODE_UINT do { unum = *ip++; if (unum > 127) { unum = ((unum & 0x3f) << 8) | (*ip++); } } while (0)
 #define DECODE_ULABEL do { unum = (ip[0] | (ip[1] << 8)); ip += 2; } while (0)
 #define DECODE_SLABEL do { unum = (ip[0] | (ip[1] << 8)) - 0x8000; ip += 2; } while (0)
@@ -363,3 +365,5 @@ void mp_show_byte_code(const byte *ip, int len) {
         printf("\n");
     }
 }
+
+#endif // MICROPY_SHOW_BC