diff --git a/py/bc0.h b/py/bc0.h
index f1c7baa..c4b0d1d 100644
--- a/py/bc0.h
+++ b/py/bc0.h
@@ -34,12 +34,10 @@
 #define MP_BC_LOAD_CONST_TRUE    (0x12)
 #define MP_BC_LOAD_CONST_ELLIPSIS    (0x13)
 #define MP_BC_LOAD_CONST_SMALL_INT   (0x14) // signed var-int
-#define MP_BC_LOAD_CONST_INT     (0x15) // qstr
-#define MP_BC_LOAD_CONST_DEC     (0x16) // qstr
-#define MP_BC_LOAD_CONST_BYTES   (0x17) // qstr
-#define MP_BC_LOAD_CONST_STRING  (0x18) // qstr
-#define MP_BC_LOAD_CONST_OBJ     (0x09) // ptr; TODO renumber to be in order
-#define MP_BC_LOAD_NULL          (0x19)
+#define MP_BC_LOAD_CONST_BYTES   (0x15) // qstr
+#define MP_BC_LOAD_CONST_STRING  (0x16) // qstr
+#define MP_BC_LOAD_CONST_OBJ     (0x17) // ptr
+#define MP_BC_LOAD_NULL          (0x18)
 
 #define MP_BC_LOAD_FAST_N        (0x1a) // uint
 #define MP_BC_LOAD_DEREF         (0x1b) // uint
diff --git a/py/compile.c b/py/compile.c
index 7023e9c..b82fea7 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -47,6 +47,7 @@
     PN_maximum_number_of,
     PN_string, // special node for non-interned string
     PN_bytes, // special node for non-interned bytes
+    PN_const_object, // special node for a constant, generic Python object
 } pn_kind_t;
 
 #define EMIT(fun) (comp->emit_method_table->fun(comp->emit))
@@ -174,6 +175,7 @@
 #endif
             case PN_string:
             case PN_bytes:
+            case PN_const_object:
                 return pn;
         }
 
@@ -432,6 +434,9 @@
     if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_bytes)) {
         return true;
     }
+    if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_const_object)) {
+        return true;
+    }
     if (!MP_PARSE_NODE_IS_LEAF(pn)) {
         return false;
     }
@@ -486,6 +491,12 @@
         return;
     }
 
+    if (MP_PARSE_NODE_IS_STRUCT_KIND(pn, PN_const_object)) {
+        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
+        mp_obj_print((mp_obj_t)pns->nodes[0], PRINT_REPR);
+        return;
+    }
+
     assert(MP_PARSE_NODE_IS_LEAF(pn));
     if (MP_PARSE_NODE_IS_SMALL_INT(pn)) {
         vstr_printf(vstr, INT_FMT, MP_PARSE_NODE_LEAF_SMALL_INT(pn));
@@ -495,8 +506,6 @@
     mp_uint_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
     switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
         case MP_PARSE_NODE_ID: assert(0);
-        case MP_PARSE_NODE_INTEGER: vstr_printf(vstr, "%s", qstr_str(arg)); break;
-        case MP_PARSE_NODE_DECIMAL: vstr_printf(vstr, "%s", qstr_str(arg)); break;
         case MP_PARSE_NODE_STRING:
         case MP_PARSE_NODE_BYTES: {
             mp_uint_t len;
@@ -2159,7 +2168,8 @@
             // for non-REPL, evaluate then discard the expression
             if ((MP_PARSE_NODE_IS_LEAF(pns->nodes[0]) && !MP_PARSE_NODE_IS_ID(pns->nodes[0]))
                 || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_string)
-                || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_bytes)) {
+                || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_bytes)
+                || MP_PARSE_NODE_IS_STRUCT_KIND(pns->nodes[0], PN_const_object)) {
                 // do nothing with a lonely constant
             } else {
                 compile_node(comp, pns->nodes[0]); // just an expression
@@ -2954,6 +2964,10 @@
     }
 }
 
+STATIC void compile_const_object(compiler_t *comp, mp_parse_node_struct_t *pns) {
+    EMIT_ARG(load_const_obj, (mp_obj_t)pns->nodes[0]);
+}
+
 typedef void (*compile_function_t)(compiler_t*, mp_parse_node_struct_t*);
 STATIC compile_function_t compile_function[] = {
 #define nc NULL
@@ -2966,6 +2980,7 @@
     NULL,
     compile_string,
     compile_bytes,
+    compile_const_object,
 };
 
 STATIC void compile_node(compiler_t *comp, mp_parse_node_t pn) {
@@ -2978,8 +2993,6 @@
         mp_uint_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
         switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
             case MP_PARSE_NODE_ID: EMIT_ARG(load_id, arg); break;
-            case MP_PARSE_NODE_INTEGER: EMIT_ARG(load_const_int, arg); break;
-            case MP_PARSE_NODE_DECIMAL: EMIT_ARG(load_const_dec, arg); break;
             case MP_PARSE_NODE_STRING: EMIT_ARG(load_const_str, arg, false); break;
             case MP_PARSE_NODE_BYTES: EMIT_ARG(load_const_str, arg, true); break;
             case MP_PARSE_NODE_TOKEN: default:
diff --git a/py/emit.h b/py/emit.h
index 772ee04..5bfeaac 100644
--- a/py/emit.h
+++ b/py/emit.h
@@ -77,8 +77,6 @@
     void (*import_star)(emit_t *emit);
     void (*load_const_tok)(emit_t *emit, mp_token_kind_t tok);
     void (*load_const_small_int)(emit_t *emit, mp_int_t arg);
-    void (*load_const_int)(emit_t *emit, qstr qst);
-    void (*load_const_dec)(emit_t *emit, qstr qst);
     void (*load_const_str)(emit_t *emit, qstr qst, bool bytes);
     void (*load_const_obj)(emit_t *emit, void *obj);
     void (*load_null)(emit_t *emit);
diff --git a/py/emitbc.c b/py/emitbc.c
index f7f2b8d..53cae59 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -473,16 +473,6 @@
     }
 }
 
-STATIC void emit_bc_load_const_int(emit_t *emit, qstr qst) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qst);
-}
-
-STATIC void emit_bc_load_const_dec(emit_t *emit, qstr qst) {
-    emit_bc_pre(emit, 1);
-    emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qst);
-}
-
 STATIC void emit_bc_load_const_str(emit_t *emit, qstr qst, bool bytes) {
     emit_bc_pre(emit, 1);
     if (bytes) {
@@ -932,8 +922,6 @@
     emit_bc_import_star,
     emit_bc_load_const_tok,
     emit_bc_load_const_small_int,
-    emit_bc_load_const_int,
-    emit_bc_load_const_dec,
     emit_bc_load_const_str,
     emit_bc_load_const_obj,
     emit_bc_load_null,
diff --git a/py/emitcpy.c b/py/emitcpy.c
index 09a0e00..355ed10 100644
--- a/py/emitcpy.c
+++ b/py/emitcpy.c
@@ -171,20 +171,6 @@
     }
 }
 
-STATIC void emit_cpy_load_const_int(emit_t *emit, qstr qst) {
-    emit_pre(emit, 1, 3);
-    if (emit->pass == MP_PASS_EMIT) {
-        printf("LOAD_CONST %s\n", qstr_str(qst));
-    }
-}
-
-STATIC void emit_cpy_load_const_dec(emit_t *emit, qstr qst) {
-    emit_pre(emit, 1, 3);
-    if (emit->pass == MP_PASS_EMIT) {
-        printf("LOAD_CONST %s\n", qstr_str(qst));
-    }
-}
-
 STATIC void print_quoted_str(qstr qst, bool bytes) {
     const char *str = qstr_str(qst);
     int len = strlen(str);
@@ -839,8 +825,6 @@
     emit_cpy_import_star,
     emit_cpy_load_const_tok,
     emit_cpy_load_const_small_int,
-    emit_cpy_load_const_int,
-    emit_cpy_load_const_dec,
     emit_cpy_load_const_str,
     emit_cpy_load_const_obj,
     emit_cpy_load_null,
diff --git a/py/emitnative.c b/py/emitnative.c
index b1135f9..ca6dd18 100644
--- a/py/emitnative.c
+++ b/py/emitnative.c
@@ -1142,21 +1142,6 @@
     }
 }
 
-STATIC void emit_native_load_const_int(emit_t *emit, qstr qst) {
-    DEBUG_printf("load_const_int %s\n", qstr_str(qst));
-    // for viper: load integer, check fits in 32 bits
-    emit_native_pre(emit);
-    emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_INT, qst, REG_ARG_1);
-    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
-}
-
-STATIC void emit_native_load_const_dec(emit_t *emit, qstr qst) {
-    // for viper, a float/complex is just a Python object
-    emit_native_pre(emit);
-    emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_DEC, qst, REG_ARG_1);
-    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
-}
-
 STATIC void emit_native_load_const_str(emit_t *emit, qstr qst, bool bytes) {
     emit_native_pre(emit);
     // TODO: Eventually we want to be able to work with raw pointers in viper to
@@ -2317,8 +2302,6 @@
     emit_native_import_star,
     emit_native_load_const_tok,
     emit_native_load_const_small_int,
-    emit_native_load_const_int,
-    emit_native_load_const_dec,
     emit_native_load_const_str,
     emit_native_load_const_obj,
     emit_native_load_null,
diff --git a/py/emitpass1.c b/py/emitpass1.c
index c6d9278..b5e5f8e 100644
--- a/py/emitpass1.c
+++ b/py/emitpass1.c
@@ -192,8 +192,6 @@
     (void*)emit_pass1_dummy,
     (void*)emit_pass1_dummy,
     (void*)emit_pass1_dummy,
-    (void*)emit_pass1_dummy,
-    (void*)emit_pass1_dummy,
     #if MICROPY_PY_BUILTINS_SET
     (void*)emit_pass1_dummy,
     (void*)emit_pass1_dummy,
diff --git a/py/grammar.h b/py/grammar.h
index eb2f03c..3698abc 100644
--- a/py/grammar.h
+++ b/py/grammar.h
@@ -248,7 +248,7 @@
 // testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
 // trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
 
-DEF_RULE(atom, nc, or(10), tok(NAME), tok(NUMBER), rule(atom_string), tok(ELLIPSIS), tok(KW_NONE), tok(KW_TRUE), tok(KW_FALSE), rule(atom_paren), rule(atom_bracket), rule(atom_brace))
+DEF_RULE(atom, nc, or(11), tok(NAME), tok(INTEGER), tok(FLOAT_OR_IMAG), rule(atom_string), tok(ELLIPSIS), tok(KW_NONE), tok(KW_TRUE), tok(KW_FALSE), rule(atom_paren), rule(atom_bracket), rule(atom_brace))
 DEF_RULE(atom_string, c(atom_string), one_or_more, rule(string_or_bytes))
 DEF_RULE(string_or_bytes, nc, or(2), tok(STRING), tok(BYTES))
 DEF_RULE(atom_paren, c(atom_paren), and(3), tok(DEL_PAREN_OPEN), opt_rule(atom_2b), tok(DEL_PAREN_CLOSE))
diff --git a/py/lexer.c b/py/lexer.c
index e3d52e7..e778510 100644
--- a/py/lexer.c
+++ b/py/lexer.c
@@ -104,6 +104,10 @@
     return unichar_isdigit(lex->chr1);
 }
 
+STATIC bool is_following_letter(mp_lexer_t *lex) {
+    return unichar_isalpha(lex->chr1);
+}
+
 STATIC bool is_following_odigit(mp_lexer_t *lex) {
     return lex->chr1 >= '0' && lex->chr1 <= '7';
 }
@@ -540,7 +544,15 @@
         }
 
     } else if (is_digit(lex) || (is_char(lex, '.') && is_following_digit(lex))) {
-        lex->tok_kind = MP_TOKEN_NUMBER;
+        bool forced_integer = false;
+        if (is_char(lex, '.')) {
+            lex->tok_kind = MP_TOKEN_FLOAT_OR_IMAG;
+        } else {
+            lex->tok_kind = MP_TOKEN_INTEGER;
+            if (is_char(lex, '0') && is_following_letter(lex)) {
+                forced_integer = true;
+            }
+        }
 
         // get first char
         vstr_add_char(&lex->vstr, CUR_CHAR(lex));
@@ -548,14 +560,18 @@
 
         // get tail chars
         while (!is_end(lex)) {
-            if (is_char_or(lex, 'e', 'E')) {
+            if (!forced_integer && is_char_or(lex, 'e', 'E')) {
+                lex->tok_kind = MP_TOKEN_FLOAT_OR_IMAG;
                 vstr_add_char(&lex->vstr, 'e');
                 next_char(lex);
                 if (is_char(lex, '+') || is_char(lex, '-')) {
                     vstr_add_char(&lex->vstr, CUR_CHAR(lex));
                     next_char(lex);
                 }
-            } else if (is_letter(lex) || is_digit(lex) || is_char_or(lex, '_', '.')) {
+            } else if (is_letter(lex) || is_digit(lex) || is_char(lex, '.')) {
+                if (is_char_or3(lex, '.', 'j', 'J')) {
+                    lex->tok_kind = MP_TOKEN_FLOAT_OR_IMAG;
+                }
                 vstr_add_char(&lex->vstr, CUR_CHAR(lex));
                 next_char(lex);
             } else {
diff --git a/py/lexer.h b/py/lexer.h
index 3ec6b6d..3118df6 100644
--- a/py/lexer.h
+++ b/py/lexer.h
@@ -50,13 +50,14 @@
     MP_TOKEN_DEDENT,                // 7
 
     MP_TOKEN_NAME,                  // 8
-    MP_TOKEN_NUMBER,
+    MP_TOKEN_INTEGER,
+    MP_TOKEN_FLOAT_OR_IMAG,
     MP_TOKEN_STRING,
     MP_TOKEN_BYTES,
 
     MP_TOKEN_ELLIPSIS,
 
-    MP_TOKEN_KW_FALSE,              // 13
+    MP_TOKEN_KW_FALSE,              // 14
     MP_TOKEN_KW_NONE,
     MP_TOKEN_KW_TRUE,
     MP_TOKEN_KW_AND,
@@ -65,7 +66,7 @@
     MP_TOKEN_KW_BREAK,
     MP_TOKEN_KW_CLASS,
     MP_TOKEN_KW_CONTINUE,
-    MP_TOKEN_KW_DEF,                // 22
+    MP_TOKEN_KW_DEF,                // 23
     MP_TOKEN_KW_DEL,
     MP_TOKEN_KW_ELIF,
     MP_TOKEN_KW_ELSE,
@@ -75,7 +76,7 @@
     MP_TOKEN_KW_FROM,
     MP_TOKEN_KW_GLOBAL,
     MP_TOKEN_KW_IF,
-    MP_TOKEN_KW_IMPORT,             // 32
+    MP_TOKEN_KW_IMPORT,             // 33
     MP_TOKEN_KW_IN,
     MP_TOKEN_KW_IS,
     MP_TOKEN_KW_LAMBDA,
@@ -85,12 +86,12 @@
     MP_TOKEN_KW_PASS,
     MP_TOKEN_KW_RAISE,
     MP_TOKEN_KW_RETURN,
-    MP_TOKEN_KW_TRY,                // 42
+    MP_TOKEN_KW_TRY,                // 43
     MP_TOKEN_KW_WHILE,
     MP_TOKEN_KW_WITH,
     MP_TOKEN_KW_YIELD,
 
-    MP_TOKEN_OP_PLUS,               // 46
+    MP_TOKEN_OP_PLUS,               // 47
     MP_TOKEN_OP_MINUS,
     MP_TOKEN_OP_STAR,
     MP_TOKEN_OP_DBL_STAR,
@@ -100,7 +101,7 @@
     MP_TOKEN_OP_LESS,
     MP_TOKEN_OP_DBL_LESS,
     MP_TOKEN_OP_MORE,
-    MP_TOKEN_OP_DBL_MORE,           // 56
+    MP_TOKEN_OP_DBL_MORE,           // 57
     MP_TOKEN_OP_AMPERSAND,
     MP_TOKEN_OP_PIPE,
     MP_TOKEN_OP_CARET,
@@ -110,7 +111,7 @@
     MP_TOKEN_OP_DBL_EQUAL,
     MP_TOKEN_OP_NOT_EQUAL,
 
-    MP_TOKEN_DEL_PAREN_OPEN,        // 65
+    MP_TOKEN_DEL_PAREN_OPEN,        // 66
     MP_TOKEN_DEL_PAREN_CLOSE,
     MP_TOKEN_DEL_BRACKET_OPEN,
     MP_TOKEN_DEL_BRACKET_CLOSE,
@@ -120,7 +121,7 @@
     MP_TOKEN_DEL_COLON,
     MP_TOKEN_DEL_PERIOD,
     MP_TOKEN_DEL_SEMICOLON,
-    MP_TOKEN_DEL_AT,                // 75
+    MP_TOKEN_DEL_AT,                // 76
     MP_TOKEN_DEL_EQUAL,
     MP_TOKEN_DEL_PLUS_EQUAL,
     MP_TOKEN_DEL_MINUS_EQUAL,
@@ -130,7 +131,7 @@
     MP_TOKEN_DEL_PERCENT_EQUAL,
     MP_TOKEN_DEL_AMPERSAND_EQUAL,
     MP_TOKEN_DEL_PIPE_EQUAL,
-    MP_TOKEN_DEL_CARET_EQUAL,       // 85
+    MP_TOKEN_DEL_CARET_EQUAL,       // 86
     MP_TOKEN_DEL_DBL_MORE_EQUAL,
     MP_TOKEN_DEL_DBL_LESS_EQUAL,
     MP_TOKEN_DEL_DBL_STAR_EQUAL,
diff --git a/py/modstruct.c b/py/modstruct.c
index 681c585..1103e40 100644
--- a/py/modstruct.c
+++ b/py/modstruct.c
@@ -76,7 +76,7 @@
     while (unichar_isdigit(*++num)) {
         len++;
     }
-    mp_uint_t val = (mp_uint_t)MP_OBJ_SMALL_INT_VALUE(mp_parse_num_integer(*p, len, 10));
+    mp_uint_t val = (mp_uint_t)MP_OBJ_SMALL_INT_VALUE(mp_parse_num_integer(*p, len, 10, NULL));
     *p = num;
     return val;
 }
diff --git a/py/nativeglue.c b/py/nativeglue.c
index 43e7d69..14638d4 100644
--- a/py/nativeglue.c
+++ b/py/nativeglue.c
@@ -91,8 +91,6 @@
 void *const mp_fun_table[MP_F_NUMBER_OF] = {
     mp_convert_obj_to_native,
     mp_convert_native_to_obj,
-    mp_load_const_int,
-    mp_load_const_dec,
     mp_load_const_str,
     mp_load_const_bytes,
     mp_load_name,
diff --git a/py/objcomplex.c b/py/objcomplex.c
index 6a403f6..1415068 100644
--- a/py/objcomplex.c
+++ b/py/objcomplex.c
@@ -95,7 +95,7 @@
                 // a string, parse it
                 mp_uint_t l;
                 const char *s = mp_obj_str_get_data(args[0], &l);
-                return mp_parse_num_decimal(s, l, true, true);
+                return mp_parse_num_decimal(s, l, true, true, NULL);
             } else if (MP_OBJ_IS_TYPE(args[0], &mp_type_complex)) {
                 // a complex, just return it
                 return args[0];
diff --git a/py/objfloat.c b/py/objfloat.c
index 4323cec..2e8b7f7 100644
--- a/py/objfloat.c
+++ b/py/objfloat.c
@@ -77,7 +77,7 @@
                 // a string, parse it
                 mp_uint_t l;
                 const char *s = mp_obj_str_get_data(args[0], &l);
-                return mp_parse_num_decimal(s, l, false, false);
+                return mp_parse_num_decimal(s, l, false, false, NULL);
             } else if (MP_OBJ_IS_TYPE(args[0], &mp_type_float)) {
                 // a float, just return it
                 return args[0];
diff --git a/py/objint.c b/py/objint.c
index fd0b2be..4a4a21a 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -57,7 +57,7 @@
                 // a string, parse it
                 mp_uint_t l;
                 const char *s = mp_obj_str_get_data(args[0], &l);
-                return mp_parse_num_integer(s, l, 0);
+                return mp_parse_num_integer(s, l, 0, NULL);
 #if MICROPY_PY_BUILTINS_FLOAT
             } else if (MP_OBJ_IS_TYPE(args[0], &mp_type_float)) {
                 return mp_obj_new_int_from_float(mp_obj_float_get(args[0]));
@@ -73,7 +73,7 @@
             // TODO proper error checking of argument types
             mp_uint_t l;
             const char *s = mp_obj_str_get_data(args[0], &l);
-            return mp_parse_num_integer(s, l, mp_obj_get_int(args[1]));
+            return mp_parse_num_integer(s, l, mp_obj_get_int(args[1]), NULL);
         }
     }
 }
diff --git a/py/parse.c b/py/parse.c
index 569cf25..54e199e 100644
--- a/py/parse.c
+++ b/py/parse.c
@@ -72,6 +72,7 @@
     RULE_maximum_number_of,
     RULE_string, // special node for non-interned string
     RULE_bytes, // special node for non-interned bytes
+    RULE_const_object, // special node for a constant, generic Python object
 };
 
 #define ident                   (RULE_ACT_ALLOW_IDENT)
@@ -170,7 +171,7 @@
     if (kind == MP_PARSE_NODE_SMALL_INT) {
         return (mp_parse_node_t)(kind | (arg << 1));
     }
-    return (mp_parse_node_t)(kind | (arg << 5));
+    return (mp_parse_node_t)(kind | (arg << 4));
 }
 
 void mp_parse_node_free(mp_parse_node_t pn) {
@@ -180,6 +181,8 @@
         mp_uint_t rule_id = MP_PARSE_NODE_STRUCT_KIND(pns);
         if (rule_id == RULE_string || rule_id == RULE_bytes) {
             m_del(char, (char*)pns->nodes[0], (mp_uint_t)pns->nodes[1]);
+        } else if (rule_id == RULE_const_object) {
+            // don't free the const object since it's probably used by the compiled code
         } else {
             bool adjust = ADD_BLANK_NODE(rules[rule_id]);
             if (adjust) {
@@ -215,8 +218,6 @@
         mp_uint_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
         switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
             case MP_PARSE_NODE_ID: printf("id(%s)\n", qstr_str(arg)); break;
-            case MP_PARSE_NODE_INTEGER: printf("int(%s)\n", qstr_str(arg)); break;
-            case MP_PARSE_NODE_DECIMAL: printf("dec(%s)\n", qstr_str(arg)); break;
             case MP_PARSE_NODE_STRING: printf("str(%s)\n", qstr_str(arg)); break;
             case MP_PARSE_NODE_BYTES: printf("bytes(%s)\n", qstr_str(arg)); break;
             case MP_PARSE_NODE_TOKEN: printf("tok(" INT_FMT ")\n", arg); break;
@@ -229,6 +230,8 @@
             printf("literal str(%.*s)\n", (int)pns->nodes[1], (char*)pns->nodes[0]);
         } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_bytes) {
             printf("literal bytes(%.*s)\n", (int)pns->nodes[1], (char*)pns->nodes[0]);
+        } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_const_object) {
+            printf("literal const(%p)\n", (mp_obj_t)pns->nodes[0]);
         } else {
             mp_uint_t n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
 #ifdef USE_RULE_NAME
@@ -285,11 +288,11 @@
     parser->result_stack[parser->result_stack_top++] = pn;
 }
 
-STATIC void push_result_string_bytes(parser_t *parser, mp_uint_t src_line, mp_uint_t rule_kind, const char *str, mp_uint_t len) {
+STATIC mp_parse_node_t make_node_string_bytes(parser_t *parser, mp_uint_t src_line, mp_uint_t rule_kind, const char *str, mp_uint_t len) {
     mp_parse_node_struct_t *pn = m_new_obj_var_maybe(mp_parse_node_struct_t, mp_parse_node_t, 2);
     if (pn == NULL) {
         memory_error(parser);
-        return;
+        return MP_PARSE_NODE_NULL;
     }
     pn->source_line = src_line;
     pn->kind_num_nodes = rule_kind | (2 << 8);
@@ -297,7 +300,19 @@
     memcpy(p, str, len);
     pn->nodes[0] = (mp_int_t)p;
     pn->nodes[1] = len;
-    push_result_node(parser, (mp_parse_node_t)pn);
+    return (mp_parse_node_t)pn;
+}
+
+STATIC mp_parse_node_t make_node_const_object(parser_t *parser, mp_uint_t src_line, mp_obj_t obj) {
+    mp_parse_node_struct_t *pn = m_new_obj_var_maybe(mp_parse_node_struct_t, mp_parse_node_t, 1);
+    if (pn == NULL) {
+        memory_error(parser);
+        return MP_PARSE_NODE_NULL;
+    }
+    pn->source_line = src_line;
+    pn->kind_num_nodes = RULE_const_object | (1 << 8);
+    pn->nodes[0] = (mp_uint_t)obj;
+    return (mp_parse_node_t)pn;
 }
 
 STATIC void push_result_token(parser_t *parser) {
@@ -305,45 +320,16 @@
     mp_lexer_t *lex = parser->lexer;
     if (lex->tok_kind == MP_TOKEN_NAME) {
         pn = mp_parse_node_new_leaf(MP_PARSE_NODE_ID, qstr_from_strn(lex->vstr.buf, lex->vstr.len));
-    } else if (lex->tok_kind == MP_TOKEN_NUMBER) {
-        bool dec = false;
-        bool small_int = true;
-        mp_int_t int_val = 0;
-        mp_uint_t len = lex->vstr.len;
-        const char *str = lex->vstr.buf;
-        mp_uint_t base = 0;
-        mp_uint_t i = mp_parse_num_base(str, len, &base);
-        bool overflow = false;
-        for (; i < len; i++) {
-            mp_uint_t dig;
-            int clower = str[i] | 0x20;
-            if (unichar_isdigit(str[i]) && (mp_uint_t)(str[i] - '0') < base) {
-                dig = str[i] - '0';
-            } else if (base == 16 && 'a' <= clower && clower <= 'f') {
-                dig = clower - 'a' + 10;
-            } else if (str[i] == '.' || clower == 'e' || clower == 'j') {
-                dec = true;
-                break;
-            } else {
-                small_int = false;
-                break;
-            }
-            // add next digi and check for overflow
-            if (mp_small_int_mul_overflow(int_val, base)) {
-                overflow = true;
-            }
-            int_val = int_val * base + dig;
-            if (!MP_SMALL_INT_FITS(int_val)) {
-                overflow = true;
-            }
-        }
-        if (dec) {
-            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_DECIMAL, qstr_from_strn(str, len));
-        } else if (small_int && !overflow && MP_SMALL_INT_FITS(int_val)) {
-            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, int_val);
+    } else if (lex->tok_kind == MP_TOKEN_INTEGER) {
+        mp_obj_t o = mp_parse_num_integer(lex->vstr.buf, lex->vstr.len, 0, lex);
+        if (MP_OBJ_IS_SMALL_INT(o)) {
+            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, MP_OBJ_SMALL_INT_VALUE(o));
         } else {
-            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_INTEGER, qstr_from_strn(str, len));
+            pn = make_node_const_object(parser, lex->tok_line, o);
         }
+    } else if (lex->tok_kind == MP_TOKEN_FLOAT_OR_IMAG) {
+        mp_obj_t o = mp_parse_num_decimal(lex->vstr.buf, lex->vstr.len, true, false, lex);
+        pn = make_node_const_object(parser, lex->tok_line, o);
     } else if (lex->tok_kind == MP_TOKEN_STRING || lex->tok_kind == MP_TOKEN_BYTES) {
         // Don't automatically intern all strings/bytes.  doc strings (which are usually large)
         // will be discarded by the compiler, and so we shouldn't intern them.
@@ -360,8 +346,7 @@
             pn = mp_parse_node_new_leaf(lex->tok_kind == MP_TOKEN_STRING ? MP_PARSE_NODE_STRING : MP_PARSE_NODE_BYTES, qst);
         } else {
             // not interned, make a node holding a pointer to the string/bytes data
-            push_result_string_bytes(parser, lex->tok_line, lex->tok_kind == MP_TOKEN_STRING ? RULE_string : RULE_bytes, lex->vstr.buf, lex->vstr.len);
-            return;
+            pn = make_node_string_bytes(parser, lex->tok_line, lex->tok_kind == MP_TOKEN_STRING ? RULE_string : RULE_bytes, lex->vstr.buf, lex->vstr.len);
         }
     } else {
         pn = mp_parse_node_new_leaf(MP_PARSE_NODE_TOKEN, lex->tok_kind);
diff --git a/py/parse.h b/py/parse.h
index ee0025a..5d992a6 100644
--- a/py/parse.h
+++ b/py/parse.h
@@ -36,21 +36,17 @@
 //  - 0000...0000: no node
 //  - xxxx...xxx1: a small integer; bits 1 and above are the signed value, 2's complement
 //  - xxxx...xx00: pointer to mp_parse_node_struct_t
-//  - xx...x00010: an identifier; bits 5 and above are the qstr
-//  - xx...x00110: an integer; bits 5 and above are the qstr holding the value
-//  - xx...x01010: a decimal; bits 5 and above are the qstr holding the value
-//  - xx...x01110: a string; bits 5 and above are the qstr holding the value
-//  - xx...x10010: a string of bytes; bits 5 and above are the qstr holding the value
-//  - xx...x10110: a token; bits 5 and above are mp_token_kind_t
+//  - xx...xx0010: an identifier; bits 4 and above are the qstr
+//  - xx...xx0110: a string; bits 4 and above are the qstr holding the value
+//  - xx...xx1010: a string of bytes; bits 4 and above are the qstr holding the value
+//  - xx...xx1110: a token; bits 4 and above are mp_token_kind_t
 
 #define MP_PARSE_NODE_NULL      (0)
 #define MP_PARSE_NODE_SMALL_INT (0x1)
 #define MP_PARSE_NODE_ID        (0x02)
-#define MP_PARSE_NODE_INTEGER   (0x06)
-#define MP_PARSE_NODE_DECIMAL   (0x0a)
-#define MP_PARSE_NODE_STRING    (0x0e)
-#define MP_PARSE_NODE_BYTES     (0x12)
-#define MP_PARSE_NODE_TOKEN     (0x16)
+#define MP_PARSE_NODE_STRING    (0x06)
+#define MP_PARSE_NODE_BYTES     (0x0a)
+#define MP_PARSE_NODE_TOKEN     (0x0e)
 
 typedef mp_uint_t mp_parse_node_t; // must be pointer size
 
@@ -69,12 +65,12 @@
 #define MP_PARSE_NODE_IS_STRUCT_KIND(pn, k) ((pn) != MP_PARSE_NODE_NULL && ((pn) & 3) == 0 && MP_PARSE_NODE_STRUCT_KIND((mp_parse_node_struct_t*)(pn)) == (k))
 
 #define MP_PARSE_NODE_IS_SMALL_INT(pn) (((pn) & 0x1) == MP_PARSE_NODE_SMALL_INT)
-#define MP_PARSE_NODE_IS_ID(pn) (((pn) & 0x1f) == MP_PARSE_NODE_ID)
-#define MP_PARSE_NODE_IS_TOKEN(pn) (((pn) & 0x1f) == MP_PARSE_NODE_TOKEN)
-#define MP_PARSE_NODE_IS_TOKEN_KIND(pn, k) ((pn) == (MP_PARSE_NODE_TOKEN | ((k) << 5)))
+#define MP_PARSE_NODE_IS_ID(pn) (((pn) & 0x0f) == MP_PARSE_NODE_ID)
+#define MP_PARSE_NODE_IS_TOKEN(pn) (((pn) & 0x0f) == MP_PARSE_NODE_TOKEN)
+#define MP_PARSE_NODE_IS_TOKEN_KIND(pn, k) ((pn) == (MP_PARSE_NODE_TOKEN | ((k) << 4)))
 
-#define MP_PARSE_NODE_LEAF_KIND(pn) ((pn) & 0x1f)
-#define MP_PARSE_NODE_LEAF_ARG(pn) (((mp_uint_t)(pn)) >> 5)
+#define MP_PARSE_NODE_LEAF_KIND(pn) ((pn) & 0x0f)
+#define MP_PARSE_NODE_LEAF_ARG(pn) (((mp_uint_t)(pn)) >> 4)
 #define MP_PARSE_NODE_LEAF_SMALL_INT(pn) (((mp_int_t)(pn)) >> 1)
 #define MP_PARSE_NODE_STRUCT_KIND(pns) ((pns)->kind_num_nodes & 0xff)
 #define MP_PARSE_NODE_STRUCT_NUM_NODES(pns) ((pns)->kind_num_nodes >> 8)
diff --git a/py/parsenum.c b/py/parsenum.c
index 4706fef..ffd065d 100644
--- a/py/parsenum.c
+++ b/py/parsenum.c
@@ -35,7 +35,16 @@
 #include <math.h>
 #endif
 
-mp_obj_t mp_parse_num_integer(const char *restrict str_, mp_uint_t len, mp_uint_t base) {
+STATIC NORETURN void raise(mp_obj_t exc, mp_lexer_t *lex) {
+    // if lex!=NULL then the parser called us and we need to make a SyntaxError with traceback
+    if (lex != NULL) {
+        ((mp_obj_base_t*)exc)->type = &mp_type_SyntaxError;
+        mp_obj_exception_add_traceback(exc, lex->source_name, lex->tok_line, MP_QSTR_NULL);
+    }
+    nlr_raise(exc);
+}
+
+mp_obj_t mp_parse_num_integer(const char *restrict str_, mp_uint_t len, mp_uint_t base, mp_lexer_t *lex) {
     const byte *restrict str = (const byte *)str_;
     const byte *restrict top = str + len;
     bool neg = false;
@@ -43,6 +52,7 @@
 
     // check radix base
     if ((base != 0 && base < 2) || base > 36) {
+        // this won't be reached if lex!=NULL
         nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "int() arg 2 must be >= 2 and <= 36"));
     }
 
@@ -132,12 +142,15 @@
     }
 
 value_error:
+    // if lex!=NULL then the parser called us and we need to make a SyntaxError with traceback
     if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError,
-            "invalid syntax for integer"));
+        mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_SyntaxError,
+            "invalid syntax for integer");
+        raise(exc, lex);
     } else {
-        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
-            "invalid syntax for integer with base %d: '%s'", base, str));
+        mp_obj_t exc = mp_obj_new_exception_msg_varg(&mp_type_ValueError,
+            "invalid syntax for integer with base %d: '%s'", base, str_val_start);
+        raise(exc, lex);
     }
 }
 
@@ -147,7 +160,7 @@
     PARSE_DEC_IN_EXP,
 } parse_dec_in_t;
 
-mp_obj_t mp_parse_num_decimal(const char *str, mp_uint_t len, bool allow_imag, bool force_complex) {
+mp_obj_t mp_parse_num_decimal(const char *str, mp_uint_t len, bool allow_imag, bool force_complex, mp_lexer_t *lex) {
 #if MICROPY_PY_BUILTINS_FLOAT
     const char *top = str + len;
     mp_float_t dec_val = 0;
@@ -168,6 +181,8 @@
         }
     }
 
+    const char *str_val_start = str;
+
     // determine what the string is
     if (str < top && (str[0] | 0x20) == 'i') {
         // string starts with 'i', should be 'inf' or 'infinity' (case insensitive)
@@ -191,36 +206,43 @@
         // string should be a decimal number
         parse_dec_in_t in = PARSE_DEC_IN_INTG;
         bool exp_neg = false;
+        mp_float_t frac_mult = 0.1;
         mp_int_t exp_val = 0;
-        mp_int_t exp_extra = 0;
-        for (; str < top; str++) {
-            mp_uint_t dig = *str;
+        while (str < top) {
+            mp_uint_t dig = *str++;
             if ('0' <= dig && dig <= '9') {
                 dig -= '0';
                 if (in == PARSE_DEC_IN_EXP) {
                     exp_val = 10 * exp_val + dig;
                 } else {
-                    dec_val = 10 * dec_val + dig;
                     if (in == PARSE_DEC_IN_FRAC) {
-                        exp_extra -= 1;
+                        dec_val += dig * frac_mult;
+                        frac_mult *= 0.1;
+                    } else {
+                        dec_val = 10 * dec_val + dig;
                     }
                 }
             } else if (in == PARSE_DEC_IN_INTG && dig == '.') {
                 in = PARSE_DEC_IN_FRAC;
             } else if (in != PARSE_DEC_IN_EXP && ((dig | 0x20) == 'e')) {
                 in = PARSE_DEC_IN_EXP;
-                if (str[1] == '+') {
-                    str++;
-                } else if (str[1] == '-') {
-                    str++;
-                    exp_neg = true;
+                if (str < top) {
+                    if (str[0] == '+') {
+                        str++;
+                    } else if (str[0] == '-') {
+                        str++;
+                        exp_neg = true;
+                    }
+                }
+                if (str == top) {
+                    goto value_error;
                 }
             } else if (allow_imag && (dig | 0x20) == 'j') {
-                str++;
                 imag = true;
                 break;
             } else {
                 // unknown character
+                str--;
                 break;
             }
         }
@@ -229,7 +251,6 @@
         if (exp_neg) {
             exp_val = -exp_val;
         }
-        exp_val += exp_extra;
 
         // apply the exponent
         for (; exp_val > 0; exp_val--) {
@@ -245,13 +266,18 @@
         dec_val = -dec_val;
     }
 
+    // check we parsed something
+    if (str == str_val_start) {
+        goto value_error;
+    }
+
     // skip trailing space
     for (; str < top && unichar_isspace(*str); str++) {
     }
 
     // check we reached the end of the string
     if (str != top) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_SyntaxError, "invalid syntax for number"));
+        goto value_error;
     }
 
     // return the object
@@ -262,13 +288,16 @@
         return mp_obj_new_complex(dec_val, 0);
 #else
     if (imag || force_complex) {
-        mp_not_implemented("complex values not supported");
+        raise(mp_obj_new_exception_msg(&mp_type_ValueError, "complex values not supported"), lex);
 #endif
     } else {
         return mp_obj_new_float(dec_val);
     }
 
+value_error:
+    raise(mp_obj_new_exception_msg(&mp_type_ValueError, "invalid syntax for number"), lex);
+
 #else
-    nlr_raise(mp_obj_new_exception_msg(&mp_type_SyntaxError, "decimal numbers not supported"));
+    raise(mp_obj_new_exception_msg(&mp_type_ValueError, "decimal numbers not supported"), lex);
 #endif
 }
diff --git a/py/parsenum.h b/py/parsenum.h
index a769bdd..26aac49 100644
--- a/py/parsenum.h
+++ b/py/parsenum.h
@@ -27,10 +27,13 @@
 #define __MICROPY_INCLUDED_PY_PARSENUM_H__
 
 #include "py/mpconfig.h"
+#include "py/lexer.h"
 #include "py/obj.h"
 
 mp_uint_t mp_parse_num_base(const char *str, mp_uint_t len, mp_uint_t *base);
-mp_obj_t mp_parse_num_integer(const char *restrict str, mp_uint_t len, mp_uint_t base);
-mp_obj_t mp_parse_num_decimal(const char *str, mp_uint_t len, bool allow_imag, bool force_complex);
+
+// these functions raise a SyntaxError if lex!=NULL, else a ValueError
+mp_obj_t mp_parse_num_integer(const char *restrict str, mp_uint_t len, mp_uint_t base, mp_lexer_t *lex);
+mp_obj_t mp_parse_num_decimal(const char *str, mp_uint_t len, bool allow_imag, bool force_complex, mp_lexer_t *lex);
 
 #endif // __MICROPY_INCLUDED_PY_PARSENUM_H__
diff --git a/py/parsenumbase.c b/py/parsenumbase.c
index cb52405..31e4a91 100644
--- a/py/parsenumbase.c
+++ b/py/parsenumbase.c
@@ -29,8 +29,10 @@
 // find real radix base, and strip preceding '0x', '0o' and '0b'
 // puts base in *base, and returns number of bytes to skip the prefix
 mp_uint_t mp_parse_num_base(const char *str, mp_uint_t len, mp_uint_t *base) {
-    (void)len; // TODO use given len?
     const byte *p = (const byte*)str;
+    if (len <= 1) {
+        goto no_prefix;
+    }
     unichar c = *(p++);
     if ((*base == 0 || *base == 16) && c == '0') {
         c = *(p++);
@@ -57,10 +59,11 @@
             p -= 2;
         }
     } else {
+        p--;
+    no_prefix:
         if (*base == 0) {
             *base = 10;
         }
-        p--;
     }
     return p - (const byte*)str;
 }
diff --git a/py/runtime.c b/py/runtime.c
index 080d061..75dd467 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -103,20 +103,6 @@
 #endif
 }
 
-mp_obj_t mp_load_const_int(qstr qst) {
-    DEBUG_OP_printf("load '%s'\n", qstr_str(qst));
-    mp_uint_t len;
-    const byte* data = qstr_data(qst, &len);
-    return mp_parse_num_integer((const char*)data, len, 0);
-}
-
-mp_obj_t mp_load_const_dec(qstr qst) {
-    DEBUG_OP_printf("load '%s'\n", qstr_str(qst));
-    mp_uint_t len;
-    const byte* data = qstr_data(qst, &len);
-    return mp_parse_num_decimal((const char*)data, len, true, false);
-}
-
 mp_obj_t mp_load_const_str(qstr qst) {
     DEBUG_OP_printf("load '%s'\n", qstr_str(qst));
     return MP_OBJ_NEW_QSTR(qst);
diff --git a/py/runtime0.h b/py/runtime0.h
index dc4a526..b96e9c3 100644
--- a/py/runtime0.h
+++ b/py/runtime0.h
@@ -107,8 +107,6 @@
 typedef enum {
     MP_F_CONVERT_OBJ_TO_NATIVE = 0,
     MP_F_CONVERT_NATIVE_TO_OBJ,
-    MP_F_LOAD_CONST_INT,
-    MP_F_LOAD_CONST_DEC,
     MP_F_LOAD_CONST_STR,
     MP_F_LOAD_CONST_BYTES,
     MP_F_LOAD_NAME,
diff --git a/py/showbc.c b/py/showbc.c
index 1bdb96a..adfa754 100644
--- a/py/showbc.c
+++ b/py/showbc.c
@@ -161,16 +161,6 @@
             break;
         }
 
-        case MP_BC_LOAD_CONST_INT:
-            DECODE_QSTR;
-            printf("LOAD_CONST_INT %s", qstr_str(qst));
-            break;
-
-        case MP_BC_LOAD_CONST_DEC:
-            DECODE_QSTR;
-            printf("LOAD_CONST_DEC %s", qstr_str(qst));
-            break;
-
         case MP_BC_LOAD_CONST_BYTES:
             DECODE_QSTR;
             printf("LOAD_CONST_BYTES %s", qstr_str(qst));
diff --git a/py/vm.c b/py/vm.c
index 2dcc537..587948f 100644
--- a/py/vm.c
+++ b/py/vm.c
@@ -199,19 +199,6 @@
                     DISPATCH();
                 }
 
-                ENTRY(MP_BC_LOAD_CONST_INT): {
-                    DECODE_QSTR;
-                    PUSH(mp_load_const_int(qst));
-                    DISPATCH();
-                }
-
-                ENTRY(MP_BC_LOAD_CONST_DEC): {
-                    MARK_EXC_IP_SELECTIVE();
-                    DECODE_QSTR;
-                    PUSH(mp_load_const_dec(qst));
-                    DISPATCH();
-                }
-
                 ENTRY(MP_BC_LOAD_CONST_BYTES): {
                     DECODE_QSTR;
                     PUSH(mp_load_const_bytes(qst));
diff --git a/py/vmentrytable.h b/py/vmentrytable.h
index 7173c2d..d2a6abe 100644
--- a/py/vmentrytable.h
+++ b/py/vmentrytable.h
@@ -36,8 +36,6 @@
     [MP_BC_LOAD_CONST_TRUE] = &&entry_MP_BC_LOAD_CONST_TRUE,
     [MP_BC_LOAD_CONST_ELLIPSIS] = &&entry_MP_BC_LOAD_CONST_ELLIPSIS,
     [MP_BC_LOAD_CONST_SMALL_INT] = &&entry_MP_BC_LOAD_CONST_SMALL_INT,
-    [MP_BC_LOAD_CONST_INT] = &&entry_MP_BC_LOAD_CONST_INT,
-    [MP_BC_LOAD_CONST_DEC] = &&entry_MP_BC_LOAD_CONST_DEC,
     [MP_BC_LOAD_CONST_BYTES] = &&entry_MP_BC_LOAD_CONST_BYTES,
     [MP_BC_LOAD_CONST_STRING] = &&entry_MP_BC_LOAD_CONST_STRING,
     [MP_BC_LOAD_CONST_OBJ] = &&entry_MP_BC_LOAD_CONST_OBJ,