diff options
| author | Jim Mussared | 2020-03-02 22:35:22 +1100 |
|---|---|---|
| committer | Damien George | 2020-04-05 15:02:06 +1000 |
| commit | def76fe4d9bbc2c342594dc05861b24d7165d274 (patch) | |
| tree | d04ad778e2421de0a85835227ba5bcb08562ec24 /py | |
| parent | 85858e72dfdc3e941c2e620e94de05ad663138b1 (diff) | |
all: Use MP_ERROR_TEXT for all error messages.
Diffstat (limited to 'py')
45 files changed, 326 insertions, 326 deletions
diff --git a/py/argcheck.c b/py/argcheck.c index 88c4b8bf3..c333ead05 100644 --- a/py/argcheck.c +++ b/py/argcheck.c @@ -41,7 +41,7 @@ void mp_arg_check_num_sig(size_t n_args, size_t n_kw, uint32_t sig) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE mp_arg_error_terse_mismatch(); #else - mp_raise_TypeError("function doesn't take keyword arguments"); + mp_raise_TypeError(MP_ERROR_TEXT("function doesn't take keyword arguments")); #endif } @@ -51,7 +51,7 @@ void mp_arg_check_num_sig(size_t n_args, size_t n_kw, uint32_t sig) { mp_arg_error_terse_mismatch(); #else mp_raise_msg_varg(&mp_type_TypeError, - "function takes %d positional arguments but %d were given", + MP_ERROR_TEXT("function takes %d positional arguments but %d were given"), n_args_min, n_args); #endif } @@ -61,7 +61,7 @@ void mp_arg_check_num_sig(size_t n_args, size_t n_kw, uint32_t sig) { mp_arg_error_terse_mismatch(); #else mp_raise_msg_varg(&mp_type_TypeError, - "function missing %d required positional arguments", + MP_ERROR_TEXT("function missing %d required positional arguments"), n_args_min - n_args); #endif } else if (n_args > n_args_max) { @@ -69,7 +69,7 @@ void mp_arg_check_num_sig(size_t n_args, size_t n_kw, uint32_t sig) { mp_arg_error_terse_mismatch(); #else mp_raise_msg_varg(&mp_type_TypeError, - "function expected at most %d arguments, got %d", + MP_ERROR_TEXT("function expected at most %d arguments, got %d"), n_args_max, n_args); #endif } @@ -93,7 +93,7 @@ void mp_arg_parse_all(size_t n_pos, const mp_obj_t *pos, mp_map_t *kws, size_t n #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE mp_arg_error_terse_mismatch(); #else - mp_raise_msg_varg(&mp_type_TypeError, "'%q' argument required", allowed[i].qst); + mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("'%q' argument required"), allowed[i].qst); #endif } out_vals[i] = allowed[i].defval; @@ -118,7 +118,7 @@ void mp_arg_parse_all(size_t n_pos, const mp_obj_t *pos, mp_map_t *kws, size_t n mp_arg_error_terse_mismatch(); #else // TODO better error message - mp_raise_TypeError("extra positional arguments given"); + mp_raise_TypeError(MP_ERROR_TEXT("extra positional arguments given")); #endif } if (kws_found < kws->used) { @@ -126,7 +126,7 @@ void mp_arg_parse_all(size_t n_pos, const mp_obj_t *pos, mp_map_t *kws, size_t n mp_arg_error_terse_mismatch(); #else // TODO better error message - mp_raise_TypeError("extra keyword arguments given"); + mp_raise_TypeError(MP_ERROR_TEXT("extra keyword arguments given")); #endif } } @@ -138,11 +138,11 @@ void mp_arg_parse_all_kw_array(size_t n_pos, size_t n_kw, const mp_obj_t *args, } NORETURN void mp_arg_error_terse_mismatch(void) { - mp_raise_TypeError("argument num/types mismatch"); + mp_raise_TypeError(MP_ERROR_TEXT("argument num/types mismatch")); } #if MICROPY_CPYTHON_COMPAT NORETURN void mp_arg_error_unimpl_kw(void) { - mp_raise_NotImplementedError("keyword argument(s) not yet implemented - use normal args instead"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("keyword argument(s) not yet implemented - use normal args instead")); } #endif @@ -84,10 +84,10 @@ STATIC NORETURN void fun_pos_args_mismatch(mp_obj_fun_bc_t *f, size_t expected, #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL (void)f; mp_raise_msg_varg(&mp_type_TypeError, - "function takes %d positional arguments but %d were given", expected, given); + MP_ERROR_TEXT("function takes %d positional arguments but %d were given"), expected, given); #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED mp_raise_msg_varg(&mp_type_TypeError, - "%q() takes %d positional arguments but %d were given", + MP_ERROR_TEXT("%q() takes %d positional arguments but %d were given"), mp_obj_fun_get_name(MP_OBJ_FROM_PTR(f)), expected, given); #endif } @@ -204,7 +204,7 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw if (wanted_arg_name == arg_names[j]) { if (code_state->state[n_state - 1 - j] != MP_OBJ_NULL) { mp_raise_msg_varg(&mp_type_TypeError, - "function got multiple values for argument '%q'", MP_OBJ_QSTR_VALUE(wanted_arg_name)); + MP_ERROR_TEXT("function got multiple values for argument '%q'"), MP_OBJ_QSTR_VALUE(wanted_arg_name)); } code_state->state[n_state - 1 - j] = kwargs[2 * i + 1]; goto continue2; @@ -213,10 +213,10 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw // Didn't find name match with positional args if ((scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) == 0) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("unexpected keyword argument"); + mp_raise_TypeError(MP_ERROR_TEXT("unexpected keyword argument")); #else mp_raise_msg_varg(&mp_type_TypeError, - "unexpected keyword argument '%q'", MP_OBJ_QSTR_VALUE(wanted_arg_name)); + MP_ERROR_TEXT("unexpected keyword argument '%q'"), MP_OBJ_QSTR_VALUE(wanted_arg_name)); #endif } mp_obj_dict_store(dict, kwargs[2 * i], kwargs[2 * i + 1]); @@ -242,7 +242,7 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw while (d < &code_state->state[n_state]) { if (*d++ == MP_OBJ_NULL) { mp_raise_msg_varg(&mp_type_TypeError, - "function missing required positional argument #%d", &code_state->state[n_state] - d); + MP_ERROR_TEXT("function missing required positional argument #%d"), &code_state->state[n_state] - d); } } @@ -258,7 +258,7 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw code_state->state[n_state - 1 - n_pos_args - i] = elem->value; } else { mp_raise_msg_varg(&mp_type_TypeError, - "function missing required keyword argument '%q'", MP_OBJ_QSTR_VALUE(arg_names[n_pos_args + i])); + MP_ERROR_TEXT("function missing required keyword argument '%q'"), MP_OBJ_QSTR_VALUE(arg_names[n_pos_args + i])); } } } @@ -266,7 +266,7 @@ void mp_setup_code_state(mp_code_state_t *code_state, size_t n_args, size_t n_kw } else { // no keyword arguments given if (n_kwonly_args != 0) { - mp_raise_TypeError("function missing keyword-only argument"); + mp_raise_TypeError(MP_ERROR_TEXT("function missing keyword-only argument")); } if ((scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) { *var_pos_kw_args = mp_obj_new_dict(0); diff --git a/py/binary.c b/py/binary.c index d4898c143..c47d9d3fe 100644 --- a/py/binary.c +++ b/py/binary.c @@ -135,7 +135,7 @@ size_t mp_binary_get_size(char struct_type, char val_type, size_t *palign) { } if (size == 0) { - mp_raise_ValueError("bad typecode"); + mp_raise_ValueError(MP_ERROR_TEXT("bad typecode")); } if (palign != NULL) { diff --git a/py/builtinevex.c b/py/builtinevex.c index 4e6120548..800a20223 100644 --- a/py/builtinevex.c +++ b/py/builtinevex.c @@ -100,7 +100,7 @@ STATIC mp_obj_t mp_builtin_compile(size_t n_args, const mp_obj_t *args) { parse_input_kind = MP_PARSE_EVAL_INPUT; break; default: - mp_raise_ValueError("bad compile mode"); + mp_raise_ValueError(MP_ERROR_TEXT("bad compile mode")); } mp_obj_code_t *code = m_new_obj(mp_obj_code_t); diff --git a/py/builtinimport.c b/py/builtinimport.c index 50106a88e..5c82c68d9 100644 --- a/py/builtinimport.c +++ b/py/builtinimport.c @@ -228,7 +228,7 @@ STATIC void do_load(mp_obj_t module_obj, vstr_t *file) { } #else // If we get here then the file was not frozen and we can't compile scripts. - mp_raise_msg(&mp_type_ImportError, "script compilation not supported"); + mp_raise_msg(&mp_type_ImportError, MP_ERROR_TEXT("script compilation not supported")); #endif } @@ -313,7 +313,7 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) { // We must have some component left over to import from if (p == this_name) { - mp_raise_ValueError("cannot perform relative import"); + mp_raise_ValueError(MP_ERROR_TEXT("cannot perform relative import")); } uint new_mod_l = (mod_len == 0 ? (size_t)(p - this_name) : (size_t)(p - this_name) + 1 + mod_len); @@ -397,9 +397,9 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) { if (module_obj == MP_OBJ_NULL) { // couldn't find the file, so fail #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_msg(&mp_type_ImportError, "module not found"); + mp_raise_msg(&mp_type_ImportError, MP_ERROR_TEXT("module not found")); #else - mp_raise_msg_varg(&mp_type_ImportError, "no module named '%q'", mod_name); + mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("no module named '%q'"), mod_name); #endif } } else { @@ -478,7 +478,7 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) { mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) { // Check that it's not a relative import if (n_args >= 5 && MP_OBJ_SMALL_INT_VALUE(args[4]) != 0) { - mp_raise_NotImplementedError("relative import"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("relative import")); } // Check if module already exists, and return it if it does @@ -500,9 +500,9 @@ mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) { // Couldn't find the module, so fail #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_msg(&mp_type_ImportError, "module not found"); + mp_raise_msg(&mp_type_ImportError, MP_ERROR_TEXT("module not found")); #else - mp_raise_msg_varg(&mp_type_ImportError, "no module named '%q'", module_name_qstr); + mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("no module named '%q'"), module_name_qstr); #endif } diff --git a/py/compile.c b/py/compile.c index 5daeb6e18..4ce69c415 100644 --- a/py/compile.c +++ b/py/compile.c @@ -449,7 +449,7 @@ STATIC void c_assign_atom_expr(compiler_t *comp, mp_parse_node_struct_t *pns, as } } - compile_syntax_error(comp, (mp_parse_node_t)pns, "can't assign to expression"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("can't assign to expression")); } // we need to allow for a caller passing in 1 initial node (node_head) followed by an array of nodes (nodes_tail) @@ -468,7 +468,7 @@ STATIC void c_assign_tuple(compiler_t *comp, mp_parse_node_t node_head, uint num EMIT_ARG(unpack_ex, num_head + i, num_tail - i - 1); have_star_index = num_head + i; } else { - compile_syntax_error(comp, nodes_tail[i], "multiple *x in assignment"); + compile_syntax_error(comp, nodes_tail[i], MP_ERROR_TEXT("multiple *x in assignment")); return; } } @@ -594,7 +594,7 @@ STATIC void c_assign(compiler_t *comp, mp_parse_node_t pn, assign_kind_t assign_ return; cannot_assign: - compile_syntax_error(comp, pn, "can't assign to expression"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("can't assign to expression")); } // stuff for lambda and comprehensions and generators: @@ -699,7 +699,7 @@ STATIC void compile_funcdef_lambdef_param(compiler_t *comp, mp_parse_node_t pn) // check for non-default parameters given after default parameters (allowed by parser, but not syntactically valid) if (!comp->have_star && comp->num_default_params != 0) { - compile_syntax_error(comp, pn, "non-default argument follows default argument"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("non-default argument follows default argument")); return; } @@ -828,7 +828,7 @@ STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_ } if (name_len != 2) { - compile_syntax_error(comp, name_nodes[0], "invalid micropython decorator"); + compile_syntax_error(comp, name_nodes[0], MP_ERROR_TEXT("invalid micropython decorator")); return true; } @@ -853,17 +853,17 @@ STATIC bool compile_built_in_decorator(compiler_t *comp, int name_len, mp_parse_ #endif #endif } else { - compile_syntax_error(comp, name_nodes[1], "invalid micropython decorator"); + compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid micropython decorator")); } #if MICROPY_DYNAMIC_COMPILER if (*emit_options == MP_EMIT_OPT_NATIVE_PYTHON || *emit_options == MP_EMIT_OPT_VIPER) { if (emit_native_table[mp_dynamic_compiler.native_arch] == NULL) { - compile_syntax_error(comp, name_nodes[1], "invalid arch"); + compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid arch")); } } else if (*emit_options == MP_EMIT_OPT_ASM) { if (emit_asm_table[mp_dynamic_compiler.native_arch] == NULL) { - compile_syntax_error(comp, name_nodes[1], "invalid arch"); + compile_syntax_error(comp, name_nodes[1], MP_ERROR_TEXT("invalid arch")); } } #endif @@ -1019,7 +1019,7 @@ STATIC void c_del_stmt(compiler_t *comp, mp_parse_node_t pn) { return; cannot_delete: - compile_syntax_error(comp, (mp_parse_node_t)pn, "can't delete expression"); + compile_syntax_error(comp, (mp_parse_node_t)pn, MP_ERROR_TEXT("can't delete expression")); } STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) { @@ -1034,7 +1034,7 @@ STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pn label = comp->continue_label; } if (label == INVALID_LABEL) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "'break'/'continue' outside loop"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'break'/'continue' outside loop")); } assert(comp->cur_except_level >= comp->break_continue_except_level); EMIT_ARG(unwind_jump, label, comp->cur_except_level - comp->break_continue_except_level); @@ -1043,7 +1043,7 @@ STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pn STATIC void compile_return_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) { #if MICROPY_CPYTHON_COMPAT if (comp->scope_cur->kind != SCOPE_FUNCTION) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "'return' outside function"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'return' outside function")); return; } #endif @@ -1201,7 +1201,7 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) { if (MP_PARSE_NODE_IS_TOKEN_KIND(pns->nodes[1], MP_TOKEN_OP_STAR)) { #if MICROPY_CPYTHON_COMPAT if (comp->scope_cur->kind != SCOPE_MODULE) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "import * not at module level"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("import * not at module level")); return; } #endif @@ -1251,7 +1251,7 @@ STATIC void compile_import_from(compiler_t *comp, mp_parse_node_struct_t *pns) { STATIC void compile_declare_global(compiler_t *comp, mp_parse_node_t pn, id_info_t *id_info) { if (id_info->kind != ID_INFO_KIND_UNDECIDED && id_info->kind != ID_INFO_KIND_GLOBAL_EXPLICIT) { - compile_syntax_error(comp, pn, "identifier redefined as global"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("identifier redefined as global")); return; } id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT; @@ -1268,10 +1268,10 @@ STATIC void compile_declare_nonlocal(compiler_t *comp, mp_parse_node_t pn, id_in id_info->kind = ID_INFO_KIND_GLOBAL_IMPLICIT; scope_check_to_close_over(comp->scope_cur, id_info); if (id_info->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { - compile_syntax_error(comp, pn, "no binding for nonlocal found"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("no binding for nonlocal found")); } } else if (id_info->kind != ID_INFO_KIND_FREE) { - compile_syntax_error(comp, pn, "identifier redefined as nonlocal"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("identifier redefined as nonlocal")); } } @@ -1280,7 +1280,7 @@ STATIC void compile_global_nonlocal_stmt(compiler_t *comp, mp_parse_node_struct_ bool is_global = MP_PARSE_NODE_STRUCT_KIND(pns) == PN_global_stmt; if (!is_global && comp->scope_cur->kind == SCOPE_MODULE) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "can't declare nonlocal in outer code"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("can't declare nonlocal in outer code")); return; } @@ -1625,7 +1625,7 @@ STATIC void compile_try_except(compiler_t *comp, mp_parse_node_t pn_body, int n_ if (MP_PARSE_NODE_IS_NULL(pns_except->nodes[0])) { // this is a catch all exception handler if (i + 1 != n_except) { - compile_syntax_error(comp, pn_excepts[i], "default 'except' must be last"); + compile_syntax_error(comp, pn_excepts[i], MP_ERROR_TEXT("default 'except' must be last")); compile_decrease_except_level(comp); return; } @@ -2180,7 +2180,7 @@ STATIC void compile_comparison(compiler_t *comp, mp_parse_node_struct_t *pns) { } STATIC void compile_star_expr(compiler_t *comp, mp_parse_node_struct_t *pns) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "*x must be assignment target"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("*x must be assignment target")); } STATIC void compile_binary_op(compiler_t *comp, mp_parse_node_struct_t *pns) { @@ -2263,7 +2263,7 @@ STATIC void compile_atom_expr_normal(compiler_t *comp, mp_parse_node_struct_t *p } if (!found) { compile_syntax_error(comp, (mp_parse_node_t)pns_trail[0], - "super() can't find self"); // really a TypeError + MP_ERROR_TEXT("super() can't find self")); // really a TypeError return; } @@ -2340,14 +2340,14 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar mp_parse_node_struct_t *pns_arg = (mp_parse_node_struct_t *)args[i]; if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_star) { if (star_flags & MP_EMIT_STAR_FLAG_SINGLE) { - compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "can't have multiple *x"); + compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("can't have multiple *x")); return; } star_flags |= MP_EMIT_STAR_FLAG_SINGLE; star_args_node = pns_arg; } else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_arglist_dbl_star) { if (star_flags & MP_EMIT_STAR_FLAG_DOUBLE) { - compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "can't have multiple **x"); + compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("can't have multiple **x")); return; } star_flags |= MP_EMIT_STAR_FLAG_DOUBLE; @@ -2355,7 +2355,7 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar } else if (MP_PARSE_NODE_STRUCT_KIND(pns_arg) == PN_argument) { if (!MP_PARSE_NODE_IS_STRUCT_KIND(pns_arg->nodes[1], PN_comp_for)) { if (!MP_PARSE_NODE_IS_ID(pns_arg->nodes[0])) { - compile_syntax_error(comp, (mp_parse_node_t)pns_arg, "LHS of keyword arg must be an id"); + compile_syntax_error(comp, (mp_parse_node_t)pns_arg, MP_ERROR_TEXT("LHS of keyword arg must be an id")); return; } EMIT_ARG(load_const_str, MP_PARSE_NODE_LEAF_ARG(pns_arg->nodes[0])); @@ -2371,11 +2371,11 @@ STATIC void compile_trailer_paren_helper(compiler_t *comp, mp_parse_node_t pn_ar } else { normal_argument: if (star_flags) { - compile_syntax_error(comp, args[i], "non-keyword arg after */**"); + compile_syntax_error(comp, args[i], MP_ERROR_TEXT("non-keyword arg after */**")); return; } if (n_keyword > 0) { - compile_syntax_error(comp, args[i], "non-keyword arg after keyword arg"); + compile_syntax_error(comp, args[i], MP_ERROR_TEXT("non-keyword arg after keyword arg")); return; } compile_node(comp, args[i]); @@ -2553,9 +2553,9 @@ STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t * if (is_dict) { if (!is_key_value) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - compile_syntax_error(comp, (mp_parse_node_t)pns, "invalid syntax"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("invalid syntax")); #else - compile_syntax_error(comp, (mp_parse_node_t)pns, "expecting key:value for dict"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("expecting key:value for dict")); #endif return; } @@ -2563,9 +2563,9 @@ STATIC void compile_atom_brace_helper(compiler_t *comp, mp_parse_node_struct_t * } else { if (is_key_value) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - compile_syntax_error(comp, (mp_parse_node_t)pns, "invalid syntax"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("invalid syntax")); #else - compile_syntax_error(comp, (mp_parse_node_t)pns, "expecting just a value for set"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("expecting just a value for set")); #endif return; } @@ -2694,7 +2694,7 @@ STATIC void compile_classdef(compiler_t *comp, mp_parse_node_struct_t *pns) { STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) { if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "'yield' outside function"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'yield' outside function")); return; } if (MP_PARSE_NODE_IS_NULL(pns->nodes[0])) { @@ -2715,7 +2715,7 @@ STATIC void compile_yield_expr(compiler_t *comp, mp_parse_node_struct_t *pns) { #if MICROPY_PY_ASYNC_AWAIT STATIC void compile_atom_expr_await(compiler_t *comp, mp_parse_node_struct_t *pns) { if (comp->scope_cur->kind != SCOPE_FUNCTION && comp->scope_cur->kind != SCOPE_LAMBDA) { - compile_syntax_error(comp, (mp_parse_node_t)pns, "'await' outside function"); + compile_syntax_error(comp, (mp_parse_node_t)pns, MP_ERROR_TEXT("'await' outside function")); return; } compile_atom_expr_normal(comp, pns); @@ -2819,11 +2819,11 @@ STATIC int compile_viper_type_annotation(compiler_t *comp, mp_parse_node_t pn_an qstr type_name = MP_PARSE_NODE_LEAF_ARG(pn_annotation); native_type = mp_native_type_from_qstr(type_name); if (native_type < 0) { - comp->compile_error = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, "unknown type '%q'", type_name); + comp->compile_error = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, MP_ERROR_TEXT("unknown type '%q'"), type_name); native_type = 0; } } else { - compile_syntax_error(comp, pn_annotation, "annotation must be an identifier"); + compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("annotation must be an identifier")); } return native_type; } @@ -2834,7 +2834,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn // check that **kw is last if ((comp->scope_cur->scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) != 0) { - compile_syntax_error(comp, pn, "invalid syntax"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("invalid syntax")); return; } @@ -2866,7 +2866,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == pn_star) { if (comp->have_star) { // more than one star - compile_syntax_error(comp, pn, "invalid syntax"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("invalid syntax")); return; } comp->have_star = true; @@ -2900,7 +2900,7 @@ STATIC void compile_scope_func_lambda_param(compiler_t *comp, mp_parse_node_t pn if (param_name != MP_QSTRnull) { id_info_t *id_info = scope_find_or_add_id(comp->scope_cur, param_name, ID_INFO_KIND_UNDECIDED); if (id_info->kind != ID_INFO_KIND_UNDECIDED) { - compile_syntax_error(comp, pn, "argument name reused"); + compile_syntax_error(comp, pn, MP_ERROR_TEXT("argument name reused")); return; } id_info->kind = ID_INFO_KIND_LOCAL; @@ -3179,7 +3179,7 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind comp->next_label = 0; if (scope->kind != SCOPE_FUNCTION) { - compile_syntax_error(comp, MP_PARSE_NODE_NULL, "inline assembler must be a function"); + compile_syntax_error(comp, MP_PARSE_NODE_NULL, MP_ERROR_TEXT("inline assembler must be a function")); return; } @@ -3225,11 +3225,11 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind type_sig = MP_NATIVE_TYPE_UINT; break; default: - compile_syntax_error(comp, pn_annotation, "unknown type"); + compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("unknown type")); return; } } else { - compile_syntax_error(comp, pn_annotation, "return annotation must be an identifier"); + compile_syntax_error(comp, pn_annotation, MP_ERROR_TEXT("return annotation must be an identifier")); } } @@ -3246,7 +3246,7 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind } else if (MP_PARSE_NODE_STRUCT_KIND(pns2) != PN_expr_stmt) { // not an instruction; error not_an_instruction: - compile_syntax_error(comp, nodes[i], "expecting an assembler instruction"); + compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("expecting an assembler instruction")); return; } @@ -3276,19 +3276,19 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind // emit instructions if (op == MP_QSTR_label) { if (!(n_args == 1 && MP_PARSE_NODE_IS_ID(pn_arg[0]))) { - compile_syntax_error(comp, nodes[i], "'label' requires 1 argument"); + compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'label' requires 1 argument")); return; } uint lab = comp_next_label(comp); if (pass > MP_PASS_SCOPE) { if (!EMIT_INLINE_ASM_ARG(label, lab, MP_PARSE_NODE_LEAF_ARG(pn_arg[0]))) { - compile_syntax_error(comp, nodes[i], "label redefined"); + compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("label redefined")); return; } } } else if (op == MP_QSTR_align) { if (!(n_args == 1 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) { - compile_syntax_error(comp, nodes[i], "'align' requires 1 argument"); + compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'align' requires 1 argument")); return; } if (pass > MP_PASS_SCOPE) { @@ -3297,14 +3297,14 @@ STATIC void compile_scope_inline_asm(compiler_t *comp, scope_t *scope, pass_kind } } else if (op == MP_QSTR_data) { if (!(n_args >= 2 && MP_PARSE_NODE_IS_SMALL_INT(pn_arg[0]))) { - compile_syntax_error(comp, nodes[i], "'data' requires at least 2 arguments"); + compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'data' requires at least 2 arguments")); return; } if (pass > MP_PASS_SCOPE) { mp_int_t bytesize = MP_PARSE_NODE_LEAF_SMALL_INT(pn_arg[0]); for (uint j = 1; j < n_args; j++) { if (!MP_PARSE_NODE_IS_SMALL_INT(pn_arg[j])) { - compile_syntax_error(comp, nodes[i], "'data' requires integer arguments"); + compile_syntax_error(comp, nodes[i], MP_ERROR_TEXT("'data' requires integer arguments")); return; } mp_asm_base_data((mp_asm_base_t *)comp->emit_inline_asm, diff --git a/py/emitinlinethumb.c b/py/emitinlinethumb.c index 7cf6f1cbb..2853da26c 100644 --- a/py/emitinlinethumb.c +++ b/py/emitinlinethumb.c @@ -99,17 +99,17 @@ STATIC void emit_inline_thumb_end_pass(emit_inline_asm_t *emit, mp_uint_t type_s STATIC mp_uint_t emit_inline_thumb_count_params(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params) { if (n_params > 4) { - emit_inline_thumb_error_msg(emit, "can only have up to 4 parameters to Thumb assembly"); + emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("can only have up to 4 parameters to Thumb assembly")); return 0; } for (mp_uint_t i = 0; i < n_params; i++) { if (!MP_PARSE_NODE_IS_ID(pn_params[i])) { - emit_inline_thumb_error_msg(emit, "parameters must be registers in sequence r0 to r3"); + emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence r0 to r3")); return 0; } const char *p = qstr_str(MP_PARSE_NODE_LEAF_ARG(pn_params[i])); if (!(strlen(p) == 2 && p[0] == 'r' && p[1] == '0' + i)) { - emit_inline_thumb_error_msg(emit, "parameters must be registers in sequence r0 to r3"); + emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence r0 to r3")); return 0; } } @@ -189,7 +189,7 @@ STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_n if (r->reg > max_reg) { emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, - "'%s' expects at most r%d", op, max_reg)); + MP_ERROR_TEXT("'%s' expects at most r%d"), op, max_reg)); return 0; } else { return r->reg; @@ -198,7 +198,7 @@ STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_n } emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, - "'%s' expects a register", op)); + MP_ERROR_TEXT("'%s' expects a register"), op)); return 0; } @@ -212,7 +212,7 @@ STATIC mp_uint_t get_arg_special_reg(emit_inline_asm_t *emit, const char *op, mp } emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, - "'%s' expects a special register", op)); + MP_ERROR_TEXT("'%s' expects a special register"), op)); return 0; } @@ -231,7 +231,7 @@ STATIC mp_uint_t get_arg_vfpreg(emit_inline_asm_t *emit, const char *op, mp_pars if (regno > 31) { emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, - "'%s' expects at most r%d", op, 31)); + MP_ERROR_TEXT("'%s' expects at most r%d"), op, 31)); return 0; } else { return regno; @@ -240,7 +240,7 @@ STATIC mp_uint_t get_arg_vfpreg(emit_inline_asm_t *emit, const char *op, mp_pars malformed: emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, - "'%s' expects an FPU register", op)); + MP_ERROR_TEXT("'%s' expects an FPU register"), op)); return 0; } #endif @@ -293,19 +293,19 @@ STATIC mp_uint_t get_arg_reglist(emit_inline_asm_t *emit, const char *op, mp_par return reglist; bad_arg: - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects {r0, r1, ...}", op)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects {r0, r1, ...}"), op)); return 0; } STATIC uint32_t get_arg_i(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn, uint32_t fit_mask) { mp_obj_t o; if (!mp_parse_node_get_int_maybe(pn, &o)) { - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an integer", op)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects an integer"), op)); return 0; } uint32_t i = mp_obj_get_int_truncated(o); if ((i & (~fit_mask)) != 0) { - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' integer 0x%x doesn't fit in mask 0x%x", op, i, fit_mask)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' integer 0x%x doesn't fit in mask 0x%x"), op, i, fit_mask)); return 0; } return i; @@ -329,13 +329,13 @@ STATIC bool get_arg_addr(emit_inline_asm_t *emit, const char *op, mp_parse_node_ return true; bad_arg: - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an address of the form [a, b]", op)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects an address of the form [a, b]"), op)); return false; } STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) { if (!MP_PARSE_NODE_IS_ID(pn)) { - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects a label", op)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects a label"), op)); return 0; } qstr label_qstr = MP_PARSE_NODE_LEAF_ARG(pn); @@ -346,7 +346,7 @@ STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_ } // only need to have the labels on the last pass if (emit->pass == MP_PASS_EMIT) { - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "label '%q' not defined", label_qstr)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("label '%q' not defined"), label_qstr)); } return 0; } @@ -817,11 +817,11 @@ STATIC void emit_inline_thumb_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_a return; unknown_op: - emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "unsupported Thumb instruction '%s' with %d arguments", op_str, n_args)); + emit_inline_thumb_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("unsupported Thumb instruction '%s' with %d arguments"), op_str, n_args)); return; branch_not_in_range: - emit_inline_thumb_error_msg(emit, "branch not in range"); + emit_inline_thumb_error_msg(emit, MP_ERROR_TEXT("branch not in range")); return; } diff --git a/py/emitinlinextensa.c b/py/emitinlinextensa.c index 677638277..6cc2e4d34 100644 --- a/py/emitinlinextensa.c +++ b/py/emitinlinextensa.c @@ -43,7 +43,7 @@ struct _emit_inline_asm_t { qstr *label_lookup; }; -STATIC void emit_inline_xtensa_error_msg(emit_inline_asm_t *emit, const char *msg) { +STATIC void emit_inline_xtensa_error_msg(emit_inline_asm_t *emit, mp_rom_error_text_t msg) { *emit->error_slot = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg); } @@ -83,17 +83,17 @@ STATIC void emit_inline_xtensa_end_pass(emit_inline_asm_t *emit, mp_uint_t type_ STATIC mp_uint_t emit_inline_xtensa_count_params(emit_inline_asm_t *emit, mp_uint_t n_params, mp_parse_node_t *pn_params) { if (n_params > 4) { - emit_inline_xtensa_error_msg(emit, "can only have up to 4 parameters to Xtensa assembly"); + emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("can only have up to 4 parameters to Xtensa assembly")); return 0; } for (mp_uint_t i = 0; i < n_params; i++) { if (!MP_PARSE_NODE_IS_ID(pn_params[i])) { - emit_inline_xtensa_error_msg(emit, "parameters must be registers in sequence a2 to a5"); + emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence a2 to a5")); return 0; } const char *p = qstr_str(MP_PARSE_NODE_LEAF_ARG(pn_params[i])); if (!(strlen(p) == 2 && p[0] == 'a' && p[1] == '2' + i)) { - emit_inline_xtensa_error_msg(emit, "parameters must be registers in sequence a2 to a5"); + emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("parameters must be registers in sequence a2 to a5")); return 0; } } @@ -161,19 +161,19 @@ STATIC mp_uint_t get_arg_reg(emit_inline_asm_t *emit, const char *op, mp_parse_n } emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, - "'%s' expects a register", op)); + MP_ERROR_TEXT("'%s' expects a register"), op)); return 0; } STATIC uint32_t get_arg_i(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn, int min, int max) { mp_obj_t o; if (!mp_parse_node_get_int_maybe(pn, &o)) { - emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects an integer", op)); + emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects an integer"), op)); return 0; } uint32_t i = mp_obj_get_int_truncated(o); if (min != max && ((int)i < min || (int)i > max)) { - emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' integer %d isn't within range %d..%d", op, i, min, max)); + emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' integer %d isn't within range %d..%d"), op, i, min, max)); return 0; } return i; @@ -181,7 +181,7 @@ STATIC uint32_t get_arg_i(emit_inline_asm_t *emit, const char *op, mp_parse_node STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_t pn) { if (!MP_PARSE_NODE_IS_ID(pn)) { - emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "'%s' expects a label", op)); + emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("'%s' expects a label"), op)); return 0; } qstr label_qstr = MP_PARSE_NODE_LEAF_ARG(pn); @@ -192,7 +192,7 @@ STATIC int get_arg_label(emit_inline_asm_t *emit, const char *op, mp_parse_node_ } // only need to have the labels on the last pass if (emit->pass == MP_PASS_EMIT) { - emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "label '%q' not defined", label_qstr)); + emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("label '%q' not defined"), label_qstr)); } return 0; } @@ -326,12 +326,12 @@ STATIC void emit_inline_xtensa_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_ return; unknown_op: - emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, "unsupported Xtensa instruction '%s' with %d arguments", op_str, n_args)); + emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, MP_ERROR_TEXT("unsupported Xtensa instruction '%s' with %d arguments"), op_str, n_args)); return; /* branch_not_in_range: - emit_inline_xtensa_error_msg(emit, "branch not in range"); + emit_inline_xtensa_error_msg(emit, MP_ERROR_TEXT("branch not in range")); return; */ } diff --git a/py/emitnative.c b/py/emitnative.c index 7deabe3e8..6c8e9feeb 100644 --- a/py/emitnative.c +++ b/py/emitnative.c @@ -841,7 +841,7 @@ STATIC vtype_kind_t load_reg_stack_imm(emit_t *emit, int reg_dest, const stack_i } else if (si->vtype == VTYPE_PTR_NONE) { emit_native_mov_reg_const(emit, reg_dest, MP_F_CONST_NONE_OBJ); } else { - mp_raise_NotImplementedError("conversion to object"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("conversion to object")); } return VTYPE_PYOBJ; } @@ -1415,7 +1415,7 @@ STATIC void emit_native_load_fast(emit_t *emit, qstr qst, mp_uint_t local_num) { DEBUG_printf("load_fast(%s, " UINT_FMT ")\n", qstr_str(qst), local_num); vtype_kind_t vtype = emit->local_vtype[local_num]; if (vtype == VTYPE_UNBOUND) { - EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "local '%q' used before type known", qst); + EMIT_NATIVE_VIPER_TYPE_ERROR(emit, MP_ERROR_TEXT("local '%q' used before type known"), qst); } emit_native_pre(emit); if (local_num < REG_LOCAL_NUM && CAN_USE_REGS_FOR_LOCALS(emit)) { @@ -1590,7 +1590,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) { } default: EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't load from '%q'", vtype_to_qstr(vtype_base)); + MP_ERROR_TEXT("can't load from '%q'"), vtype_to_qstr(vtype_base)); } } else { // index is not an immediate @@ -1600,7 +1600,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) { emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) { EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't load with '%q' index", vtype_to_qstr(vtype_index)); + MP_ERROR_TEXT("can't load with '%q' index"), vtype_to_qstr(vtype_index)); } switch (vtype_base) { case VTYPE_PTR8: { @@ -1628,7 +1628,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) { } default: EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't load from '%q'", vtype_to_qstr(vtype_base)); + MP_ERROR_TEXT("can't load from '%q'"), vtype_to_qstr(vtype_base)); } } emit_post_push_reg(emit, VTYPE_INT, REG_RET); @@ -1652,7 +1652,7 @@ STATIC void emit_native_store_fast(emit_t *emit, qstr qst, mp_uint_t local_num) } else if (emit->local_vtype[local_num] != vtype) { // type of local is not the same as object stored in it EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "local '%q' has type '%q' but source is '%q'", + MP_ERROR_TEXT("local '%q' has type '%q' but source is '%q'"), qst, vtype_to_qstr(emit->local_vtype[local_num]), vtype_to_qstr(vtype)); } } @@ -1753,7 +1753,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) { #endif if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) { EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't store '%q'", vtype_to_qstr(vtype_value)); + MP_ERROR_TEXT("can't store '%q'"), vtype_to_qstr(vtype_value)); } switch (vtype_base) { case VTYPE_PTR8: { @@ -1819,7 +1819,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) { } default: EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't store to '%q'", vtype_to_qstr(vtype_base)); + MP_ERROR_TEXT("can't store to '%q'"), vtype_to_qstr(vtype_base)); } } else { // index is not an immediate @@ -1830,7 +1830,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) { emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) { EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't store with '%q' index", vtype_to_qstr(vtype_index)); + MP_ERROR_TEXT("can't store with '%q' index"), vtype_to_qstr(vtype_index)); } #if N_X86 // special case: x86 needs byte stores to be from lower 4 regs (REG_ARG_3 is EDX) @@ -1840,7 +1840,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) { #endif if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) { EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't store '%q'", vtype_to_qstr(vtype_value)); + MP_ERROR_TEXT("can't store '%q'"), vtype_to_qstr(vtype_value)); } switch (vtype_base) { case VTYPE_PTR8: { @@ -1880,7 +1880,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) { } default: EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't store to '%q'", vtype_to_qstr(vtype_base)); + MP_ERROR_TEXT("can't store to '%q'"), vtype_to_qstr(vtype_base)); } } @@ -2002,7 +2002,7 @@ STATIC void emit_native_jump_helper(emit_t *emit, bool cond, mp_uint_t label, bo } if (!(vtype == VTYPE_BOOL || vtype == VTYPE_INT || vtype == VTYPE_UINT)) { EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't implicitly convert '%q' to 'bool'", vtype_to_qstr(vtype)); + MP_ERROR_TEXT("can't implicitly convert '%q' to 'bool'"), vtype_to_qstr(vtype)); } } // For non-pop need to save the vtype so that emit_native_adjust_stack_size @@ -2281,7 +2281,7 @@ STATIC void emit_native_unary_op(emit_t *emit, mp_unary_op_t op) { } else { adjust_stack(emit, 1); EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "unary op %q not implemented", mp_unary_op_method_name[op]); + MP_ERROR_TEXT("unary op %q not implemented"), mp_unary_op_method_name[op]); } } @@ -2440,7 +2440,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) { // TODO other ops not yet implemented adjust_stack(emit, 1); EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "binary op %q not implemented", mp_binary_op_method_name[op]); + MP_ERROR_TEXT("binary op %q not implemented"), mp_binary_op_method_name[op]); } } else if (vtype_lhs == VTYPE_PYOBJ && vtype_rhs == VTYPE_PYOBJ) { emit_pre_pop_reg_reg(emit, &vtype_rhs, REG_ARG_3, &vtype_lhs, REG_ARG_2); @@ -2461,7 +2461,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) { } else { adjust_stack(emit, -1); EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "can't do binary op between '%q' and '%q'", + MP_ERROR_TEXT("can't do binary op between '%q' and '%q'"), vtype_to_qstr(vtype_lhs), vtype_to_qstr(vtype_rhs)); } } @@ -2639,7 +2639,7 @@ STATIC void emit_native_call_function(emit_t *emit, mp_uint_t n_positional, mp_u break; default: // this can happen when casting a cast: int(int) - mp_raise_NotImplementedError("casting"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("casting")); } } else { assert(vtype_fun == VTYPE_PYOBJ); @@ -2703,7 +2703,7 @@ STATIC void emit_native_return_value(emit_t *emit) { emit_pre_pop_reg(emit, &vtype, return_vtype == VTYPE_PYOBJ ? REG_PARENT_RET : REG_ARG_1); if (vtype != return_vtype) { EMIT_NATIVE_VIPER_TYPE_ERROR(emit, - "return expected '%q' but got '%q'", + MP_ERROR_TEXT("return expected '%q' but got '%q'"), vtype_to_qstr(return_vtype), vtype_to_qstr(vtype)); } } @@ -2732,7 +2732,7 @@ STATIC void emit_native_raise_varargs(emit_t *emit, mp_uint_t n_args) { vtype_kind_t vtype_exc; emit_pre_pop_reg(emit, &vtype_exc, REG_ARG_1); // arg1 = object to raise if (vtype_exc != VTYPE_PYOBJ) { - EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "must raise an object"); + EMIT_NATIVE_VIPER_TYPE_ERROR(emit, MP_ERROR_TEXT("must raise an object")); } // TODO probably make this 1 call to the runtime (which could even call convert, native_raise(obj, type)) emit_call(emit, MP_F_NATIVE_RAISE); @@ -2742,7 +2742,7 @@ STATIC void emit_native_yield(emit_t *emit, int kind) { // Note: 1 (yield) or 3 (yield from) labels are reserved for this function, starting at *emit->label_slot if (emit->do_viper_types) { - mp_raise_NotImplementedError("native yield"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("native yield")); } emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR; diff --git a/py/lexer.c b/py/lexer.c index 73ff5ecad..10bb999af 100644 --- a/py/lexer.c +++ b/py/lexer.c @@ -360,7 +360,7 @@ STATIC void parse_string_literal(mp_lexer_t *lex, bool is_raw) { // 3MB of text; even gzip-compressed and with minimal structure, it'll take // roughly half a meg of storage. This form of Unicode escape may be added // later on, but it's definitely not a priority right now. -- CJA 20140607 - mp_raise_NotImplementedError("unicode name escapes"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("unicode name escapes")); break; default: if (c >= '0' && c <= '7') { diff --git a/py/modbuiltins.c b/py/modbuiltins.c index e94ec3ba6..c1f3f771f 100644 --- a/py/modbuiltins.c +++ b/py/modbuiltins.c @@ -158,7 +158,7 @@ STATIC mp_obj_t mp_builtin_chr(mp_obj_t o_in) { str[3] = (c & 0x3F) | 0x80; len = 4; } else { - mp_raise_ValueError("chr() arg not in range(0x110000)"); + mp_raise_ValueError(MP_ERROR_TEXT("chr() arg not in range(0x110000)")); } return mp_obj_new_str_via_qstr((char *)str, len); #else @@ -167,7 +167,7 @@ STATIC mp_obj_t mp_builtin_chr(mp_obj_t o_in) { uint8_t str[1] = {ord}; return mp_obj_new_str_via_qstr((char *)str, 1); } else { - mp_raise_ValueError("chr() arg not in range(256)"); + mp_raise_ValueError(MP_ERROR_TEXT("chr() arg not in range(256)")); } #endif } @@ -286,7 +286,7 @@ STATIC mp_obj_t mp_builtin_min_max(size_t n_args, const mp_obj_t *args, mp_map_t if (default_elem != NULL) { best_obj = default_elem->value; } else { - mp_raise_ValueError("arg is an empty sequence"); + mp_raise_ValueError(MP_ERROR_TEXT("arg is an empty sequence")); } } return best_obj; @@ -373,10 +373,10 @@ STATIC mp_obj_t mp_builtin_ord(mp_obj_t o_in) { } #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("ord expects a character"); + mp_raise_TypeError(MP_ERROR_TEXT("ord expects a character")); #else mp_raise_msg_varg(&mp_type_TypeError, - "ord() expected a character, but string of length %d found", (int)len); + MP_ERROR_TEXT("ord() expected a character, but string of length %d found"), (int)len); #endif } MP_DEFINE_CONST_FUN_OBJ_1(mp_builtin_ord_obj, mp_builtin_ord); @@ -387,7 +387,7 @@ STATIC mp_obj_t mp_builtin_pow(size_t n_args, const mp_obj_t *args) { return mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]); default: #if !MICROPY_PY_BUILTINS_POW3 - mp_raise_NotImplementedError("3-arg pow() not supported"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("3-arg pow() not supported")); #elif MICROPY_LONGINT_IMPL != MICROPY_LONGINT_IMPL_MPZ return mp_binary_op(MP_BINARY_OP_MODULO, mp_binary_op(MP_BINARY_OP_POWER, args[0], args[1]), args[2]); #else @@ -545,7 +545,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin_sum_obj, 1, 2, mp_builtin_sum); STATIC mp_obj_t mp_builtin_sorted(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) { if (n_args > 1) { - mp_raise_TypeError("must use keyword argument for key function"); + mp_raise_TypeError(MP_ERROR_TEXT("must use keyword argument for key function")); } mp_obj_t self = mp_type_list.make_new(&mp_type_list, 1, 0, args); mp_obj_list_sort(1, &self, kwargs); diff --git a/py/modmath.c b/py/modmath.c index 52ad0b000..f6f43b4ad 100644 --- a/py/modmath.c +++ b/py/modmath.c @@ -36,7 +36,7 @@ #define MP_PI MICROPY_FLOAT_CONST(3.14159265358979323846) STATIC NORETURN void math_error(void) { - mp_raise_ValueError("math domain error"); + mp_raise_ValueError(MP_ERROR_TEXT("math domain error")); } STATIC mp_obj_t math_generic_1(mp_obj_t x_obj, mp_float_t (*f)(mp_float_t)) { @@ -223,7 +223,7 @@ STATIC mp_obj_t mp_math_log(size_t n_args, const mp_obj_t *args) { if (base <= (mp_float_t)0.0) { math_error(); } else if (base == (mp_float_t)1.0) { - mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero")); } return mp_obj_new_float(l / MICROPY_FLOAT_C_FUN(log)(base)); } @@ -294,7 +294,7 @@ STATIC mp_obj_t mp_math_factorial_inner(mp_uint_t start, mp_uint_t end) { STATIC mp_obj_t mp_math_factorial(mp_obj_t x_obj) { mp_int_t max = mp_obj_get_int(x_obj); if (max < 0) { - mp_raise_ValueError("negative factorial"); + mp_raise_ValueError(MP_ERROR_TEXT("negative factorial")); } else if (max == 0) { return MP_OBJ_NEW_SMALL_INT(1); } @@ -308,7 +308,7 @@ STATIC mp_obj_t mp_math_factorial(mp_obj_t x_obj) { STATIC mp_obj_t mp_math_factorial(mp_obj_t x_obj) { mp_int_t max = mp_obj_get_int(x_obj); if (max < 0) { - mp_raise_ValueError("negative factorial"); + mp_raise_ValueError(MP_ERROR_TEXT("negative factorial")); } else if (max <= 1) { return MP_OBJ_NEW_SMALL_INT(1); } diff --git a/py/modmicropython.c b/py/modmicropython.c index ff2faba66..f7eadf79b 100644 --- a/py/modmicropython.c +++ b/py/modmicropython.c @@ -157,7 +157,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_micropython_kbd_intr_obj, mp_micropython_kbd #if MICROPY_ENABLE_SCHEDULER STATIC mp_obj_t mp_micropython_schedule(mp_obj_t function, mp_obj_t arg) { if (!mp_sched_schedule(function, arg)) { - mp_raise_msg(&mp_type_RuntimeError, "schedule queue full"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("schedule queue full")); } return mp_const_none; } diff --git a/py/modstruct.c b/py/modstruct.c index caf0ad9a3..4cbcad6d4 100644 --- a/py/modstruct.c +++ b/py/modstruct.c @@ -141,7 +141,7 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) { // negative offsets are relative to the end of the buffer offset = bufinfo.len + offset; if (offset < 0) { - mp_raise_ValueError("buffer too small"); + mp_raise_ValueError(MP_ERROR_TEXT("buffer too small")); } } p += offset; @@ -150,7 +150,7 @@ STATIC mp_obj_t struct_unpack_from(size_t n_args, const mp_obj_t *args) { // Check that the input buffer is big enough to unpack all the values if (p + total_sz > end_p) { - mp_raise_ValueError("buffer too small"); + mp_raise_ValueError(MP_ERROR_TEXT("buffer too small")); } for (size_t i = 0; i < num_items;) { @@ -232,7 +232,7 @@ STATIC mp_obj_t struct_pack_into(size_t n_args, const mp_obj_t *args) { // negative offsets are relative to the end of the buffer offset = (mp_int_t)bufinfo.len + offset; if (offset < 0) { - mp_raise_ValueError("buffer too small"); + mp_raise_ValueError(MP_ERROR_TEXT("buffer too small")); } } byte *p = (byte *)bufinfo.buf; @@ -242,7 +242,7 @@ STATIC mp_obj_t struct_pack_into(size_t n_args, const mp_obj_t *args) { // Check that the output buffer is big enough to hold all the values mp_int_t sz = MP_OBJ_SMALL_INT_VALUE(struct_calcsize(args[0])); if (p + sz > end_p) { - mp_raise_ValueError("buffer too small"); + mp_raise_ValueError(MP_ERROR_TEXT("buffer too small")); } struct_pack_into_internal(args[0], p, n_args - 3, &args[3]); diff --git a/py/modthread.c b/py/modthread.c index 35e7d509d..1306dc642 100644 --- a/py/modthread.c +++ b/py/modthread.c @@ -235,7 +235,7 @@ STATIC mp_obj_t mod_thread_start_new_thread(size_t n_args, const mp_obj_t *args) } else { // positional and keyword arguments if (mp_obj_get_type(args[2]) != &mp_type_dict) { - mp_raise_TypeError("expecting a dict for keyword args"); + mp_raise_TypeError(MP_ERROR_TEXT("expecting a dict for keyword args")); } mp_map_t *map = &((mp_obj_dict_t *)MP_OBJ_TO_PTR(args[2]))->map; th_args = m_new_obj_var(thread_entry_args_t, mp_obj_t, pos_args_len + 2 * map->used); diff --git a/py/nativeglue.c b/py/nativeglue.c index ee38e4dbb..eebbe18bb 100644 --- a/py/nativeglue.c +++ b/py/nativeglue.c @@ -118,13 +118,13 @@ mp_obj_t mp_native_to_obj(mp_uint_t val, mp_uint_t type) { mp_obj_t mp_obj_new_set(size_t n_args, mp_obj_t *items) { (void)n_args; (void)items; - mp_raise_msg(&mp_type_RuntimeError, "set unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("set unsupported")); } void mp_obj_set_store(mp_obj_t self_in, mp_obj_t item) { (void)self_in; (void)item; - mp_raise_msg(&mp_type_RuntimeError, "set unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("set unsupported")); } #endif @@ -133,7 +133,7 @@ mp_obj_t mp_obj_new_slice(mp_obj_t ostart, mp_obj_t ostop, mp_obj_t ostep) { (void)ostart; (void)ostop; (void)ostep; - mp_raise_msg(&mp_type_RuntimeError, "slice unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("slice unsupported")); } #endif @@ -249,22 +249,22 @@ STATIC double mp_obj_get_float_to_d(mp_obj_t o) { STATIC mp_obj_t mp_obj_new_float_from_f(float f) { (void)f; - mp_raise_msg(&mp_type_RuntimeError, "float unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported")); } STATIC mp_obj_t mp_obj_new_float_from_d(double d) { (void)d; - mp_raise_msg(&mp_type_RuntimeError, "float unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported")); } STATIC float mp_obj_get_float_to_f(mp_obj_t o) { (void)o; - mp_raise_msg(&mp_type_RuntimeError, "float unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported")); } STATIC double mp_obj_get_float_to_d(mp_obj_t o) { (void)o; - mp_raise_msg(&mp_type_RuntimeError, "float unsupported"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("float unsupported")); } #endif @@ -360,10 +360,10 @@ mp_float_t mp_obj_get_float(mp_obj_t arg) { if (!mp_obj_get_float_maybe(arg, &val)) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("can't convert to float"); + mp_raise_TypeError(MP_ERROR_TEXT("can't convert to float")); #else mp_raise_msg_varg(&mp_type_TypeError, - "can't convert %s to float", mp_obj_get_type_str(arg)); + MP_ERROR_TEXT("can't convert %s to float"), mp_obj_get_type_str(arg)); #endif } @@ -393,10 +393,10 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) { mp_obj_complex_get(arg, real, imag); } else { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("can't convert to complex"); + mp_raise_TypeError(MP_ERROR_TEXT("can't convert to complex")); #else mp_raise_msg_varg(&mp_type_TypeError, - "can't convert %s to complex", mp_obj_get_type_str(arg)); + MP_ERROR_TEXT("can't convert %s to complex"), mp_obj_get_type_str(arg)); #endif } } @@ -411,10 +411,10 @@ void mp_obj_get_array(mp_obj_t o, size_t *len, mp_obj_t **items) { mp_obj_list_get(o, len, items); } else { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("expected tuple/list"); + mp_raise_TypeError(MP_ERROR_TEXT("expected tuple/list")); #else mp_raise_msg_varg(&mp_type_TypeError, - "object '%s' isn't a tuple or list", mp_obj_get_type_str(o)); + MP_ERROR_TEXT("object '%s' isn't a tuple or list"), mp_obj_get_type_str(o)); #endif } } @@ -425,10 +425,10 @@ void mp_obj_get_array_fixed_n(mp_obj_t o, size_t len, mp_obj_t **items) { mp_obj_get_array(o, &seq_len, items); if (seq_len != len) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_ValueError("tuple/list has wrong length"); + mp_raise_ValueError(MP_ERROR_TEXT("tuple/list has wrong length")); #else mp_raise_msg_varg(&mp_type_ValueError, - "requested length %d but object has length %d", (int)len, (int)seq_len); + MP_ERROR_TEXT("requested length %d but object has length %d"), (int)len, (int)seq_len); #endif } } @@ -440,10 +440,10 @@ size_t mp_get_index(const mp_obj_type_t *type, size_t len, mp_obj_t index, bool i = MP_OBJ_SMALL_INT_VALUE(index); } else if (!mp_obj_get_int_maybe(index, &i)) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("indices must be integers"); + mp_raise_TypeError(MP_ERROR_TEXT("indices must be integers")); #else mp_raise_msg_varg(&mp_type_TypeError, - "%q indices must be integers, not %s", + MP_ERROR_TEXT("%q indices must be integers, not %s"), type->name, mp_obj_get_type_str(index)); #endif } @@ -460,9 +460,9 @@ size_t mp_get_index(const mp_obj_type_t *type, size_t len, mp_obj_t index, bool } else { if (i < 0 || (mp_uint_t)i >= len) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_msg(&mp_type_IndexError, "index out of range"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("index out of range")); #else - mp_raise_msg_varg(&mp_type_IndexError, "%q index out of range", type->name); + mp_raise_msg_varg(&mp_type_IndexError, MP_ERROR_TEXT("%q index out of range"), type->name); #endif } } @@ -494,10 +494,10 @@ mp_obj_t mp_obj_len(mp_obj_t o_in) { mp_obj_t len = mp_obj_len_maybe(o_in); if (len == MP_OBJ_NULL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object has no len"); + mp_raise_TypeError(MP_ERROR_TEXT("object has no len")); #else mp_raise_msg_varg(&mp_type_TypeError, - "object of type '%s' has no len()", mp_obj_get_type_str(o_in)); + MP_ERROR_TEXT("object of type '%s' has no len()"), mp_obj_get_type_str(o_in)); #endif } else { return len; @@ -535,24 +535,24 @@ mp_obj_t mp_obj_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) { } if (value == MP_OBJ_NULL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object doesn't support item deletion"); + mp_raise_TypeError(MP_ERROR_TEXT("object doesn't support item deletion")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object doesn't support item deletion", mp_obj_get_type_str(base)); + MP_ERROR_TEXT("'%s' object doesn't support item deletion"), mp_obj_get_type_str(base)); #endif } else if (value == MP_OBJ_SENTINEL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object isn't subscriptable"); + mp_raise_TypeError(MP_ERROR_TEXT("object isn't subscriptable")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object isn't subscriptable", mp_obj_get_type_str(base)); + MP_ERROR_TEXT("'%s' object isn't subscriptable"), mp_obj_get_type_str(base)); #endif } else { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object doesn't support item assignment"); + mp_raise_TypeError(MP_ERROR_TEXT("object doesn't support item assignment")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object doesn't support item assignment", mp_obj_get_type_str(base)); + MP_ERROR_TEXT("'%s' object doesn't support item assignment"), mp_obj_get_type_str(base)); #endif } } @@ -583,7 +583,7 @@ bool mp_get_buffer(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags) { void mp_get_buffer_raise(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags) { if (!mp_get_buffer(obj, bufinfo, flags)) { - mp_raise_TypeError("object with buffer protocol required"); + mp_raise_TypeError(MP_ERROR_TEXT("object with buffer protocol required")); } } diff --git a/py/objarray.c b/py/objarray.c index f56d60570..4947f7590 100644 --- a/py/objarray.c +++ b/py/objarray.c @@ -395,7 +395,7 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value if (mp_obj_is_type(index_in, &mp_type_slice)) { mp_bound_slice_t slice; if (!mp_seq_get_fast_slice_indexes(o->len, index_in, &slice)) { - mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported")); } if (value != MP_OBJ_SENTINEL) { #if MICROPY_PY_ARRAY_SLICE_ASSIGN @@ -408,7 +408,7 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value mp_obj_array_t *src_slice = MP_OBJ_TO_PTR(value); if (item_sz != mp_binary_get_size('@', src_slice->typecode & TYPECODE_MASK, NULL)) { compat_error: - mp_raise_ValueError("lhs and rhs should be compatible"); + mp_raise_ValueError(MP_ERROR_TEXT("lhs and rhs should be compatible")); } src_len = src_slice->len; src_items = src_slice->items; @@ -426,7 +426,7 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value src_len = bufinfo.len; src_items = bufinfo.buf; } else { - mp_raise_NotImplementedError("array/bytes required on right side"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("array/bytes required on right side")); } // TODO: check src/dst compat diff --git a/py/objcomplex.c b/py/objcomplex.c index b7af1b16b..91e440230 100644 --- a/py/objcomplex.c +++ b/py/objcomplex.c @@ -201,13 +201,13 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo } case MP_BINARY_OP_FLOOR_DIVIDE: case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: - mp_raise_TypeError("can't truncate-divide a complex number"); + mp_raise_TypeError(MP_ERROR_TEXT("can't truncate-divide a complex number")); case MP_BINARY_OP_TRUE_DIVIDE: case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: if (rhs_imag == 0) { if (rhs_real == 0) { - mp_raise_msg(&mp_type_ZeroDivisionError, "complex divide by zero"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("complex divide by zero")); } lhs_real /= rhs_real; lhs_imag /= rhs_real; @@ -235,7 +235,7 @@ mp_obj_t mp_obj_complex_binary_op(mp_binary_op_t op, mp_float_t lhs_real, mp_flo if (rhs_imag == 0 && rhs_real >= 0) { lhs_real = (rhs_real == 0); } else { - mp_raise_msg(&mp_type_ZeroDivisionError, "0.0 to a complex power"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("0.0 to a complex power")); } } else { mp_float_t ln1 = MICROPY_FLOAT_C_FUN(log)(abs1); diff --git a/py/objdeque.c b/py/objdeque.c index 0eb666591..c95bdeee9 100644 --- a/py/objdeque.c +++ b/py/objdeque.c @@ -102,7 +102,7 @@ STATIC mp_obj_t mp_obj_deque_append(mp_obj_t self_in, mp_obj_t arg) { } if (self->flags & FLAG_CHECK_OVERFLOW && new_i_put == self->i_get) { - mp_raise_msg(&mp_type_IndexError, "full"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("full")); } self->items[self->i_put] = arg; @@ -122,7 +122,7 @@ STATIC mp_obj_t deque_popleft(mp_obj_t self_in) { mp_obj_deque_t *self = MP_OBJ_TO_PTR(self_in); if (self->i_get == self->i_put) { - mp_raise_msg(&mp_type_IndexError, "empty"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("empty")); } mp_obj_t ret = self->items[self->i_get]; diff --git a/py/objdict.c b/py/objdict.c index 5447826a4..2a72c6252 100644 --- a/py/objdict.c +++ b/py/objdict.c @@ -324,7 +324,7 @@ STATIC mp_obj_t dict_popitem(mp_obj_t self_in) { size_t cur = 0; mp_map_elem_t *next = dict_iter_next(self, &cur); if (next == NULL) { - mp_raise_msg(&mp_type_KeyError, "popitem(): dictionary is empty"); + mp_raise_msg(&mp_type_KeyError, MP_ERROR_TEXT("popitem(): dictionary is empty")); } self->map.used--; mp_obj_t items[] = {next->key, next->value}; @@ -367,7 +367,7 @@ STATIC mp_obj_t dict_update(size_t n_args, const mp_obj_t *args, mp_map_t *kwarg if (key == MP_OBJ_STOP_ITERATION || value == MP_OBJ_STOP_ITERATION || stop != MP_OBJ_STOP_ITERATION) { - mp_raise_ValueError("dict update sequence has wrong length"); + mp_raise_ValueError(MP_ERROR_TEXT("dict update sequence has wrong length")); } else { mp_map_lookup(&self->map, key, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value; } diff --git a/py/objfloat.c b/py/objfloat.c index 40619d71c..c7cf049fb 100644 --- a/py/objfloat.c +++ b/py/objfloat.c @@ -257,7 +257,7 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: if (rhs_val == 0) { zero_division_error: - mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero")); } // Python specs require that x == (x//y)*y + (x%y) so we must // call divmod to compute the correct floor division, which @@ -295,7 +295,7 @@ mp_obj_t mp_obj_float_binary_op(mp_binary_op_t op, mp_float_t lhs_val, mp_obj_t #if MICROPY_PY_BUILTINS_COMPLEX return mp_obj_complex_binary_op(MP_BINARY_OP_POWER, lhs_val, 0, rhs_in); #else - mp_raise_ValueError("complex values not supported"); + mp_raise_ValueError(MP_ERROR_TEXT("complex values not supported")); #endif } lhs_val = MICROPY_FLOAT_C_FUN(pow)(lhs_val, rhs_val); diff --git a/py/objgenerator.c b/py/objgenerator.c index cd88e96b5..5e140ba23 100644 --- a/py/objgenerator.c +++ b/py/objgenerator.c @@ -157,7 +157,7 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_ // Ensure the generator cannot be reentered during execution if (self->pend_exc == MP_OBJ_NULL) { - mp_raise_ValueError("generator already executing"); + mp_raise_ValueError(MP_ERROR_TEXT("generator already executing")); } #if MICROPY_PY_GENERATOR_PEND_THROW @@ -170,7 +170,7 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_ // If the generator is started, allow sending a value. if (self->code_state.sp == self->code_state.state - 1) { if (send_value != mp_const_none) { - mp_raise_TypeError("can't send non-None value to a just-started generator"); + mp_raise_TypeError(MP_ERROR_TEXT("can't send non-None value to a just-started generator")); } } else { *self->code_state.sp = send_value; @@ -225,7 +225,7 @@ mp_vm_return_kind_t mp_obj_gen_resume(mp_obj_t self_in, mp_obj_t send_value, mp_ *ret_val = self->code_state.state[0]; // PEP479: if StopIteration is raised inside a generator it is replaced with RuntimeError if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(mp_obj_get_type(*ret_val)), MP_OBJ_FROM_PTR(&mp_type_StopIteration))) { - *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, "generator raised StopIteration"); + *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator raised StopIteration")); } break; } @@ -299,7 +299,7 @@ STATIC mp_obj_t gen_instance_close(mp_obj_t self_in) { mp_obj_t ret; switch (mp_obj_gen_resume(self_in, mp_const_none, MP_OBJ_FROM_PTR(&mp_const_GeneratorExit_obj), &ret)) { case MP_VM_RETURN_YIELD: - mp_raise_msg(&mp_type_RuntimeError, "generator ignored GeneratorExit"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator ignored GeneratorExit")); // Swallow GeneratorExit (== successful close), and re-raise any other case MP_VM_RETURN_EXCEPTION: @@ -320,7 +320,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(gen_instance_close_obj, gen_instance_close); STATIC mp_obj_t gen_instance_pend_throw(mp_obj_t self_in, mp_obj_t exc_in) { mp_obj_gen_instance_t *self = MP_OBJ_TO_PTR(self_in); if (self->pend_exc == MP_OBJ_NULL) { - mp_raise_ValueError("generator already executing"); + mp_raise_ValueError(MP_ERROR_TEXT("generator already executing")); } mp_obj_t prev = self->pend_exc; self->pend_exc = exc_in; diff --git a/py/objint.c b/py/objint.c index da51e5afe..93cd2778e 100644 --- a/py/objint.c +++ b/py/objint.c @@ -137,9 +137,9 @@ STATIC mp_fp_as_int_class_t mp_classify_fp_as_int(mp_float_t val) { mp_obj_t mp_obj_new_int_from_float(mp_float_t val) { int cl = fpclassify(val); if (cl == FP_INFINITE) { - mp_raise_msg(&mp_type_OverflowError, "can't convert inf to int"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("can't convert inf to int")); } else if (cl == FP_NAN) { - mp_raise_ValueError("can't convert NaN to int"); + mp_raise_ValueError(MP_ERROR_TEXT("can't convert NaN to int")); } else { mp_fp_as_int_class_t icl = mp_classify_fp_as_int(val); if (icl == MP_FP_CLASS_FIT_SMALLINT) { @@ -156,7 +156,7 @@ mp_obj_t mp_obj_new_int_from_float(mp_float_t val) { return mp_obj_new_int_from_ll((long long)val); #endif } else { - mp_raise_ValueError("float too big"); + mp_raise_ValueError(MP_ERROR_TEXT("float too big")); } #endif } @@ -321,19 +321,19 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i // This is called only with strings whose value doesn't fit in SMALL_INT mp_obj_t mp_obj_new_int_from_str_len(const char **str, size_t len, bool neg, unsigned int base) { - mp_raise_msg(&mp_type_OverflowError, "long int not supported in this build"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("long int not supported in this build")); return mp_const_none; } // This is called when an integer larger than a SMALL_INT is needed (although val might still fit in a SMALL_INT) mp_obj_t mp_obj_new_int_from_ll(long long val) { - mp_raise_msg(&mp_type_OverflowError, "small int overflow"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow")); return mp_const_none; } // This is called when an integer larger than a SMALL_INT is needed (although val might still fit in a SMALL_INT) mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) { - mp_raise_msg(&mp_type_OverflowError, "small int overflow"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow")); return mp_const_none; } @@ -343,7 +343,7 @@ mp_obj_t mp_obj_new_int_from_uint(mp_uint_t value) { if ((value & ~MP_SMALL_INT_POSITIVE_MASK) == 0) { return MP_OBJ_NEW_SMALL_INT(value); } - mp_raise_msg(&mp_type_OverflowError, "small int overflow"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow")); return mp_const_none; } @@ -351,7 +351,7 @@ mp_obj_t mp_obj_new_int(mp_int_t value) { if (MP_SMALL_INT_FITS(value)) { return MP_OBJ_NEW_SMALL_INT(value); } - mp_raise_msg(&mp_type_OverflowError, "small int overflow"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("small int overflow")); return mp_const_none; } diff --git a/py/objint_longlong.c b/py/objint_longlong.c index c34415a93..619b4d2b5 100644 --- a/py/objint_longlong.c +++ b/py/objint_longlong.c @@ -190,7 +190,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i #if MICROPY_PY_BUILTINS_FLOAT return mp_obj_float_binary_op(op, lhs_val, rhs_in); #else - mp_raise_ValueError("negative power with no float support"); + mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support")); #endif } long long ans = 1; @@ -223,7 +223,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i } zero_division: - mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero")); } mp_obj_t mp_obj_new_int(mp_int_t value) { @@ -252,7 +252,7 @@ mp_obj_t mp_obj_new_int_from_ll(long long val) { mp_obj_t mp_obj_new_int_from_ull(unsigned long long val) { // TODO raise an exception if the unsigned long long won't fit if (val >> (sizeof(unsigned long long) * 8 - 1) != 0) { - mp_raise_msg(&mp_type_OverflowError, "ulonglong too large"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("ulonglong too large")); } mp_obj_int_t *o = m_new_obj(mp_obj_int_t); o->base.type = &mp_type_int; diff --git a/py/objint_mpz.c b/py/objint_mpz.c index 0455a58ec..f2f0dbc3a 100644 --- a/py/objint_mpz.c +++ b/py/objint_mpz.c @@ -237,7 +237,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: { if (mpz_is_zero(zrhs)) { zero_division_error: - mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero")); } mpz_t rem; mpz_init_zero(&rem); @@ -276,7 +276,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i case MP_BINARY_OP_INPLACE_RSHIFT: { mp_int_t irhs = mp_obj_int_get_checked(rhs_in); if (irhs < 0) { - mp_raise_ValueError("negative shift count"); + mp_raise_ValueError(MP_ERROR_TEXT("negative shift count")); } if (op == MP_BINARY_OP_LSHIFT || op == MP_BINARY_OP_INPLACE_LSHIFT) { mpz_shl_inpl(&res->mpz, zlhs, irhs); @@ -292,7 +292,7 @@ mp_obj_t mp_obj_int_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_i #if MICROPY_PY_BUILTINS_FLOAT return mp_obj_float_binary_op(op, mpz_as_float(zlhs), rhs_in); #else - mp_raise_ValueError("negative power with no float support"); + mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support")); #endif } mpz_pow_inpl(&res->mpz, zlhs, zrhs); @@ -345,7 +345,7 @@ STATIC mpz_t *mp_mpz_for_int(mp_obj_t arg, mpz_t *temp) { mp_obj_t mp_obj_int_pow3(mp_obj_t base, mp_obj_t exponent, mp_obj_t modulus) { if (!mp_obj_is_int(base) || !mp_obj_is_int(exponent) || !mp_obj_is_int(modulus)) { - mp_raise_TypeError("pow() with 3 arguments requires integers"); + mp_raise_TypeError(MP_ERROR_TEXT("pow() with 3 arguments requires integers")); } else { mp_obj_t result = mp_obj_new_int_from_ull(0); // Use the _from_ull version as this forces an mpz int mp_obj_int_t *res_p = (mp_obj_int_t *)MP_OBJ_TO_PTR(result); @@ -426,7 +426,7 @@ mp_int_t mp_obj_int_get_checked(mp_const_obj_t self_in) { return value; } else { // overflow - mp_raise_msg(&mp_type_OverflowError, "overflow converting long int to machine word"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("overflow converting long int to machine word")); } } } @@ -444,7 +444,7 @@ mp_uint_t mp_obj_int_get_uint_checked(mp_const_obj_t self_in) { } } - mp_raise_msg(&mp_type_OverflowError, "overflow converting long int to machine word"); + mp_raise_msg(&mp_type_OverflowError, MP_ERROR_TEXT("overflow converting long int to machine word")); } #if MICROPY_PY_BUILTINS_FLOAT diff --git a/py/objlist.c b/py/objlist.c index 38329e0e6..8c989facc 100644 --- a/py/objlist.c +++ b/py/objlist.c @@ -270,7 +270,7 @@ STATIC mp_obj_t list_pop(size_t n_args, const mp_obj_t *args) { mp_check_self(mp_obj_is_type(args[0], &mp_type_list)); mp_obj_list_t *self = MP_OBJ_TO_PTR(args[0]); if (self->len == 0) { - mp_raise_msg(&mp_type_IndexError, "pop from empty list"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("pop from empty list")); } size_t index = mp_get_index(self->base.type, self->len, n_args == 1 ? MP_OBJ_NEW_SMALL_INT(-1) : args[1], false); mp_obj_t ret = self->items[index]; diff --git a/py/objnamedtuple.c b/py/objnamedtuple.c index dacf5d64c..48111b0b4 100644 --- a/py/objnamedtuple.c +++ b/py/objnamedtuple.c @@ -87,7 +87,7 @@ STATIC void namedtuple_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { } else { // delete/store attribute // provide more detailed error message than we'd get by just returning - mp_raise_msg(&mp_type_AttributeError, "can't set attribute"); + mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("can't set attribute")); } } @@ -99,11 +99,11 @@ STATIC mp_obj_t namedtuple_make_new(const mp_obj_type_t *type_in, size_t n_args, mp_arg_error_terse_mismatch(); #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL mp_raise_msg_varg(&mp_type_TypeError, - "function takes %d positional arguments but %d were given", + MP_ERROR_TEXT("function takes %d positional arguments but %d were given"), num_fields, n_args + n_kw); #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED mp_raise_msg_varg(&mp_type_TypeError, - "%q() takes %d positional arguments but %d were given", + MP_ERROR_TEXT("%q() takes %d positional arguments but %d were given"), type->base.name, num_fields, n_args + n_kw); #endif } @@ -124,7 +124,7 @@ STATIC mp_obj_t namedtuple_make_new(const mp_obj_type_t *type_in, size_t n_args, #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE mp_arg_error_terse_mismatch(); #else - mp_raise_msg_varg(&mp_type_TypeError, "unexpected keyword argument '%q'", kw); + mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("unexpected keyword argument '%q'"), kw); #endif } if (tuple->items[id] != MP_OBJ_NULL) { @@ -132,7 +132,7 @@ STATIC mp_obj_t namedtuple_make_new(const mp_obj_type_t *type_in, size_t n_args, mp_arg_error_terse_mismatch(); #else mp_raise_msg_varg(&mp_type_TypeError, - "function got multiple values for argument '%q'", kw); + MP_ERROR_TEXT("function got multiple values for argument '%q'"), kw); #endif } tuple->items[id] = args[i + 1]; diff --git a/py/objobject.c b/py/objobject.c index 62a3366b5..00082dfe0 100644 --- a/py/objobject.c +++ b/py/objobject.c @@ -50,7 +50,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(object___init___obj, object___init__); STATIC mp_obj_t object___new__(mp_obj_t cls) { if (!mp_obj_is_type(cls, &mp_type_type) || !mp_obj_is_instance_type((mp_obj_type_t *)MP_OBJ_TO_PTR(cls))) { - mp_raise_TypeError("arg must be user-type"); + mp_raise_TypeError(MP_ERROR_TEXT("arg must be user-type")); } // This executes only "__new__" part of instance creation. // TODO: This won't work well for classes with native bases. @@ -65,7 +65,7 @@ STATIC MP_DEFINE_CONST_STATICMETHOD_OBJ(object___new___obj, MP_ROM_PTR(&object__ #if MICROPY_PY_DELATTR_SETATTR STATIC mp_obj_t object___setattr__(mp_obj_t self_in, mp_obj_t attr, mp_obj_t value) { if (!mp_obj_is_instance_type(mp_obj_get_type(self_in))) { - mp_raise_TypeError("arg must be user-type"); + mp_raise_TypeError(MP_ERROR_TEXT("arg must be user-type")); } if (!mp_obj_is_str(attr)) { @@ -80,7 +80,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(object___setattr___obj, object___setattr__); STATIC mp_obj_t object___delattr__(mp_obj_t self_in, mp_obj_t attr) { if (!mp_obj_is_instance_type(mp_obj_get_type(self_in))) { - mp_raise_TypeError("arg must be user-type"); + mp_raise_TypeError(MP_ERROR_TEXT("arg must be user-type")); } if (!mp_obj_is_str(attr)) { @@ -89,7 +89,7 @@ STATIC mp_obj_t object___delattr__(mp_obj_t self_in, mp_obj_t attr) { mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in); if (mp_map_lookup(&self->members, attr, MP_MAP_LOOKUP_REMOVE_IF_FOUND) == NULL) { - mp_raise_msg(&mp_type_AttributeError, "no such attribute"); + mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute")); } return mp_const_none; } diff --git a/py/objrange.c b/py/objrange.c index 9727d4864..4eed4b941 100644 --- a/py/objrange.c +++ b/py/objrange.c @@ -105,7 +105,7 @@ STATIC mp_obj_t range_make_new(const mp_obj_type_t *type, size_t n_args, size_t if (n_args == 3) { o->step = mp_obj_get_int(args[2]); if (o->step == 0) { - mp_raise_ValueError("zero step"); + mp_raise_ValueError(MP_ERROR_TEXT("zero step")); } } } diff --git a/py/objset.c b/py/objset.c index da56f9a75..f31a901a7 100644 --- a/py/objset.c +++ b/py/objset.c @@ -362,7 +362,7 @@ STATIC mp_obj_t set_pop(mp_obj_t self_in) { mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in); mp_obj_t obj = mp_set_remove_first(&self->set); if (obj == MP_OBJ_NULL) { - mp_raise_msg(&mp_type_KeyError, "pop from an empty set"); + mp_raise_msg(&mp_type_KeyError, MP_ERROR_TEXT("pop from an empty set")); } return obj; } diff --git a/py/objslice.c b/py/objslice.c index d1c23cbf2..290c29150 100644 --- a/py/objslice.c +++ b/py/objslice.c @@ -124,7 +124,7 @@ void mp_obj_slice_indices(mp_obj_t self_in, mp_int_t length, mp_bound_slice_t *r } else { step = mp_obj_get_int(self->step); if (step == 0) { - mp_raise_ValueError("slice step cannot be zero"); + mp_raise_ValueError(MP_ERROR_TEXT("slice step cannot be zero")); } } diff --git a/py/objstr.c b/py/objstr.c index d731f2359..548fa1bb3 100644 --- a/py/objstr.c +++ b/py/objstr.c @@ -258,7 +258,7 @@ STATIC mp_obj_t bytes_make_new(const mp_obj_type_t *type_in, size_t n_args, size mp_int_t val = mp_obj_get_int(item); #if MICROPY_FULL_CHECKS if (val < 0 || val > 255) { - mp_raise_ValueError("bytes value out of range"); + mp_raise_ValueError(MP_ERROR_TEXT("bytes value out of range")); } #endif vstr_add_byte(&vstr, val); @@ -267,7 +267,7 @@ STATIC mp_obj_t bytes_make_new(const mp_obj_type_t *type_in, size_t n_args, size return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); wrong_args: - mp_raise_TypeError("wrong number of arguments"); + mp_raise_TypeError(MP_ERROR_TEXT("wrong number of arguments")); } // like strstr but with specified length and allows \0 bytes @@ -428,7 +428,7 @@ STATIC mp_obj_t bytes_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { if (mp_obj_is_type(index, &mp_type_slice)) { mp_bound_slice_t slice; if (!mp_seq_get_fast_slice_indexes(self_len, index, &slice)) { - mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported")); } return mp_obj_new_str_of_type(type, self_data + slice.start, slice.stop - slice.start); } @@ -468,7 +468,7 @@ STATIC mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) { for (size_t i = 0; i < seq_len; i++) { if (mp_obj_get_type(seq_items[i]) != self_type) { mp_raise_TypeError( - "join expects a list of str/bytes objects consistent with self object"); + MP_ERROR_TEXT("join expects a list of str/bytes objects consistent with self object")); } if (i > 0) { required_len += sep_len; @@ -549,7 +549,7 @@ mp_obj_t mp_obj_str_split(size_t n_args, const mp_obj_t *args) { const char *sep_str = mp_obj_str_get_data(sep, &sep_len); if (sep_len == 0) { - mp_raise_ValueError("empty separator"); + mp_raise_ValueError(MP_ERROR_TEXT("empty separator")); } for (;;) { @@ -648,13 +648,13 @@ STATIC mp_obj_t str_rsplit(size_t n_args, const mp_obj_t *args) { mp_int_t idx = splits; if (sep == mp_const_none) { - mp_raise_NotImplementedError("rsplit(None,n)"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("rsplit(None,n)")); } else { size_t sep_len; const char *sep_str = mp_obj_str_get_data(sep, &sep_len); if (sep_len == 0) { - mp_raise_ValueError("empty separator"); + mp_raise_ValueError(MP_ERROR_TEXT("empty separator")); } const byte *beg = s; @@ -720,7 +720,7 @@ STATIC mp_obj_t str_finder(size_t n_args, const mp_obj_t *args, int direction, b out_error: // not found if (is_index) { - mp_raise_ValueError("substring not found"); + mp_raise_ValueError(MP_ERROR_TEXT("substring not found")); } else { return MP_OBJ_NEW_SMALL_INT(-1); } @@ -777,7 +777,7 @@ STATIC mp_obj_t str_endswith(size_t n_args, const mp_obj_t *args) { size_t suffix_len; const char *suffix = mp_obj_str_get_data(args[1], &suffix_len); if (n_args > 2) { - mp_raise_NotImplementedError("start/end indices"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("start/end indices")); } if (suffix_len > str_len) { @@ -940,7 +940,7 @@ STATIC mp_obj_t arg_as_int(mp_obj_t arg) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE STATIC NORETURN void terse_str_format_value_error(void) { - mp_raise_ValueError("bad format string"); + mp_raise_ValueError(MP_ERROR_TEXT("bad format string")); } #else // define to nothing to improve coverage @@ -962,7 +962,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("single '}' encountered in format string"); + mp_raise_ValueError(MP_ERROR_TEXT("single '}' encountered in format string")); #endif } if (*str != '{') { @@ -1001,14 +1001,14 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL - mp_raise_ValueError("bad conversion specifier"); + mp_raise_ValueError(MP_ERROR_TEXT("bad conversion specifier")); #else if (str >= top) { mp_raise_ValueError( - "end of format while looking for conversion specifier"); + MP_ERROR_TEXT("end of format while looking for conversion specifier")); } else { mp_raise_msg_varg(&mp_type_ValueError, - "unknown conversion specifier %c", *str); + MP_ERROR_TEXT("unknown conversion specifier %c"), *str); } #endif } @@ -1039,14 +1039,14 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("unmatched '{' in format"); + mp_raise_ValueError(MP_ERROR_TEXT("unmatched '{' in format")); #endif } if (*str != '}') { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("expected ':' after format specifier"); + mp_raise_ValueError(MP_ERROR_TEXT("expected ':' after format specifier")); #endif } @@ -1060,12 +1060,12 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_ValueError( - "can't switch from automatic field numbering to manual field specification"); + MP_ERROR_TEXT("can't switch from automatic field numbering to manual field specification")); #endif } field_name = str_to_int(field_name, field_name_top, &index); if ((uint)index >= n_args - 1) { - mp_raise_msg(&mp_type_IndexError, "tuple index out of range"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("tuple index out of range")); } arg = args[index + 1]; *arg_i = -1; @@ -1082,7 +1082,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar arg = key_elem->value; } if (field_name < field_name_top) { - mp_raise_NotImplementedError("attributes not supported yet"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("attributes not supported yet")); } } else { if (*arg_i < 0) { @@ -1090,11 +1090,11 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_ValueError( - "can't switch from manual field specification to automatic field numbering"); + MP_ERROR_TEXT("can't switch from manual field specification to automatic field numbering")); #endif } if ((uint)*arg_i >= n_args - 1) { - mp_raise_msg(&mp_type_IndexError, "tuple index out of range"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("tuple index out of range")); } arg = args[(*arg_i) + 1]; (*arg_i)++; @@ -1182,7 +1182,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("invalid format specifier"); + mp_raise_ValueError(MP_ERROR_TEXT("invalid format specifier")); #endif } vstr_clear(&format_spec_vstr); @@ -1203,7 +1203,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("sign not allowed in string format specifier"); + mp_raise_ValueError(MP_ERROR_TEXT("sign not allowed in string format specifier")); #endif } if (type == 'c') { @@ -1211,7 +1211,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_ValueError( - "sign not allowed with integer format specifier 'c'"); + MP_ERROR_TEXT("sign not allowed with integer format specifier 'c'")); #endif } } @@ -1275,7 +1275,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_msg_varg(&mp_type_ValueError, - "unknown format code '%c' for object of type '%s'", + MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"), type, mp_obj_get_type_str(arg)); #endif } @@ -1347,7 +1347,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_msg_varg(&mp_type_ValueError, - "unknown format code '%c' for object of type '%s'", + MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"), type, mp_obj_get_type_str(arg)); #endif } @@ -1359,7 +1359,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_ValueError( - "'=' alignment not allowed in string format specifier"); + MP_ERROR_TEXT("'=' alignment not allowed in string format specifier")); #endif } @@ -1383,7 +1383,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar terse_str_format_value_error(); #else mp_raise_msg_varg(&mp_type_ValueError, - "unknown format code '%c' for object of type '%s'", + MP_ERROR_TEXT("unknown format code '%c' for object of type '%s'"), type, mp_obj_get_type_str(arg)); #endif } @@ -1434,7 +1434,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_ // Dictionary value lookup if (*str == '(') { if (dict == MP_OBJ_NULL) { - mp_raise_TypeError("format needs a dict"); + mp_raise_TypeError(MP_ERROR_TEXT("format needs a dict")); } arg_i = 1; // we used up the single dict argument const byte *key = ++str; @@ -1443,7 +1443,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_ #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("incomplete format key"); + mp_raise_ValueError(MP_ERROR_TEXT("incomplete format key")); #endif } ++str; @@ -1507,7 +1507,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_ #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE terse_str_format_value_error(); #else - mp_raise_ValueError("incomplete format"); + mp_raise_ValueError(MP_ERROR_TEXT("incomplete format")); #endif } @@ -1515,7 +1515,7 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_ if (arg == MP_OBJ_NULL) { if (arg_i >= n_args) { not_enough_args: - mp_raise_TypeError("format string needs more arguments"); + mp_raise_TypeError(MP_ERROR_TEXT("format string needs more arguments")); } arg = args[arg_i++]; } @@ -1525,14 +1525,14 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_ size_t slen; const char *s = mp_obj_str_get_data(arg, &slen); if (slen != 1) { - mp_raise_TypeError("%c needs int or char"); + mp_raise_TypeError(MP_ERROR_TEXT("%c needs int or char")); } mp_print_strn(&print, s, 1, flags, ' ', width); } else if (arg_looks_integer(arg)) { char ch = mp_obj_get_int(arg); mp_print_strn(&print, &ch, 1, flags, ' ', width); } else { - mp_raise_TypeError("integer needed"); + mp_raise_TypeError(MP_ERROR_TEXT("integer needed")); } break; @@ -1594,14 +1594,14 @@ STATIC mp_obj_t str_modulo_format(mp_obj_t pattern, size_t n_args, const mp_obj_ terse_str_format_value_error(); #else mp_raise_msg_varg(&mp_type_ValueError, - "unsupported format character '%c' (0x%x) at index %d", + MP_ERROR_TEXT("unsupported format character '%c' (0x%x) at index %d"), *str, *str, str - start_str); #endif } } if (arg_i != n_args) { - mp_raise_TypeError("format string didn't convert all arguments"); + mp_raise_TypeError(MP_ERROR_TEXT("format string didn't convert all arguments")); } return mp_obj_new_str_from_vstr(is_bytes ? &mp_type_bytes : &mp_type_str, &vstr); @@ -1771,7 +1771,7 @@ STATIC mp_obj_t str_partitioner(mp_obj_t self_in, mp_obj_t arg, int direction) { GET_STR_DATA_LEN(arg, sep, sep_len); if (sep_len == 0) { - mp_raise_ValueError("empty separator"); + mp_raise_ValueError(MP_ERROR_TEXT("empty separator")); } mp_obj_t result[3]; @@ -2128,11 +2128,11 @@ bool mp_obj_str_equal(mp_obj_t s1, mp_obj_t s2) { STATIC NORETURN void bad_implicit_conversion(mp_obj_t self_in) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("can't convert to str implicitly"); + mp_raise_TypeError(MP_ERROR_TEXT("can't convert to str implicitly")); #else const qstr src_name = mp_obj_get_type(self_in)->name; mp_raise_msg_varg(&mp_type_TypeError, - "can't convert '%q' object to %q implicitly", + MP_ERROR_TEXT("can't convert '%q' object to %q implicitly"), src_name, src_name == MP_QSTR_str ? MP_QSTR_bytes : MP_QSTR_str); #endif } diff --git a/py/objstringio.c b/py/objstringio.c index 176691387..ef942e74e 100644 --- a/py/objstringio.c +++ b/py/objstringio.c @@ -38,7 +38,7 @@ #if MICROPY_CPYTHON_COMPAT STATIC void check_stringio_is_open(const mp_obj_stringio_t *o) { if (o->vstr == NULL) { - mp_raise_ValueError("I/O operation on closed file"); + mp_raise_ValueError(MP_ERROR_TEXT("I/O operation on closed file")); } } #else diff --git a/py/objstrunicode.c b/py/objstrunicode.c index defcbe4ce..b21df22a3 100644 --- a/py/objstrunicode.c +++ b/py/objstrunicode.c @@ -129,7 +129,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s if (mp_obj_is_small_int(index)) { i = MP_OBJ_SMALL_INT_VALUE(index); } else if (!mp_obj_get_int_maybe(index, &i)) { - mp_raise_msg_varg(&mp_type_TypeError, "string indices must be integers, not %s", mp_obj_get_type_str(index)); + mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("string indices must be integers, not %s"), mp_obj_get_type_str(index)); } const byte *s, *top = self_data + self_len; if (i < 0) { @@ -139,7 +139,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s if (is_slice) { return self_data; } - mp_raise_msg(&mp_type_IndexError, "string index out of range"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("string index out of range")); } if (!UTF8_IS_CONT(*s)) { ++i; @@ -158,7 +158,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s if (is_slice) { return top; } - mp_raise_msg(&mp_type_IndexError, "string index out of range"); + mp_raise_msg(&mp_type_IndexError, MP_ERROR_TEXT("string index out of range")); } // Then check completion if (i-- == 0) { @@ -189,7 +189,7 @@ STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { ostep = slice->step; if (ostep != mp_const_none && ostep != MP_OBJ_NEW_SMALL_INT(1)) { - mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported")); } const byte *pstart, *pstop; diff --git a/py/objtuple.c b/py/objtuple.c index 77e70a194..07a560ac0 100644 --- a/py/objtuple.c +++ b/py/objtuple.c @@ -185,7 +185,7 @@ mp_obj_t mp_obj_tuple_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) { if (mp_obj_is_type(index, &mp_type_slice)) { mp_bound_slice_t slice; if (!mp_seq_get_fast_slice_indexes(self->len, index, &slice)) { - mp_raise_NotImplementedError("only slices with step=1 (aka None) are supported"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("only slices with step=1 (aka None) are supported")); } mp_obj_tuple_t *res = MP_OBJ_TO_PTR(mp_obj_new_tuple(slice.stop - slice.start, NULL)); mp_seq_copy(res->items, self->items + slice.start, res->len, mp_obj_t); diff --git a/py/objtype.c b/py/objtype.c index 3a5a3403b..3f32cd601 100644 --- a/py/objtype.c +++ b/py/objtype.c @@ -349,10 +349,10 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size } if (init_ret != mp_const_none) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("__init__() should return None"); + mp_raise_TypeError(MP_ERROR_TEXT("__init__() should return None")); #else mp_raise_msg_varg(&mp_type_TypeError, - "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)); + MP_ERROR_TEXT("__init__() should return None, not '%s'"), mp_obj_get_type_str(init_ret)); #endif } } @@ -627,7 +627,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des // the code. const mp_obj_t *proxy = mp_obj_property_get(member); if (proxy[0] == mp_const_none) { - mp_raise_msg(&mp_type_AttributeError, "unreadable attribute"); + mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("unreadable attribute")); } else { dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in); } @@ -864,10 +864,10 @@ mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons mp_obj_t call = mp_obj_instance_get_call(self_in, member); if (call == MP_OBJ_NULL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object not callable"); + mp_raise_TypeError(MP_ERROR_TEXT("object not callable")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object isn't callable", mp_obj_get_type_str(self_in)); + MP_ERROR_TEXT("'%s' object isn't callable"), mp_obj_get_type_str(self_in)); #endif } mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in); @@ -978,7 +978,7 @@ STATIC mp_obj_t type_make_new(const mp_obj_type_t *type_in, size_t n_args, size_ return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]); default: - mp_raise_TypeError("type takes 1 or 3 arguments"); + mp_raise_TypeError(MP_ERROR_TEXT("type takes 1 or 3 arguments")); } } @@ -989,9 +989,9 @@ STATIC mp_obj_t type_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp if (self->make_new == NULL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("cannot create instance"); + mp_raise_TypeError(MP_ERROR_TEXT("cannot create instance")); #else - mp_raise_msg_varg(&mp_type_TypeError, "cannot create '%q' instances", self->name); + mp_raise_msg_varg(&mp_type_TypeError, MP_ERROR_TEXT("cannot create '%q' instances"), self->name); #endif } @@ -1060,7 +1060,7 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) { if (check_for_special_accessors(MP_OBJ_NEW_QSTR(attr), dest[1])) { if (self->flags & MP_TYPE_FLAG_IS_SUBCLASSED) { // This class is already subclassed so can't have special accessors added - mp_raise_msg(&mp_type_AttributeError, "can't add special method to already-subclassed class"); + mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("can't add special method to already-subclassed class")); } self->flags |= MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS; } @@ -1111,10 +1111,10 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) // TODO: Verify with CPy, tested on function type if (t->make_new == NULL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("type isn't an acceptable base type"); + mp_raise_TypeError(MP_ERROR_TEXT("type isn't an acceptable base type")); #else mp_raise_msg_varg(&mp_type_TypeError, - "type '%q' isn't an acceptable base type", t->name); + MP_ERROR_TEXT("type '%q' isn't an acceptable base type"), t->name); #endif } #if ENABLE_SPECIAL_ACCESSORS @@ -1151,7 +1151,7 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) #if MICROPY_MULTIPLE_INHERITANCE o->parent = MP_OBJ_TO_PTR(bases_tuple); #else - mp_raise_NotImplementedError("multiple inheritance not supported"); + mp_raise_NotImplementedError(MP_ERROR_TEXT("multiple inheritance not supported")); #endif } else { o->parent = MP_OBJ_TO_PTR(bases_items[0]); @@ -1178,7 +1178,7 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) const mp_obj_type_t *native_base; size_t num_native_bases = instance_count_native_bases(o, &native_base); if (num_native_bases > 1) { - mp_raise_TypeError("multiple bases have instance lay-out conflict"); + mp_raise_TypeError(MP_ERROR_TEXT("multiple bases have instance lay-out conflict")); } mp_map_t *locals_map = &o->locals_dict->map; @@ -1361,7 +1361,7 @@ STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) { } else if (mp_obj_is_type(classinfo, &mp_type_tuple)) { mp_obj_tuple_get(classinfo, &len, &items); } else { - mp_raise_TypeError("issubclass() arg 2 must be a class or a tuple of classes"); + mp_raise_TypeError(MP_ERROR_TEXT("issubclass() arg 2 must be a class or a tuple of classes")); } for (size_t i = 0; i < len; i++) { @@ -1375,7 +1375,7 @@ STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) { STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) { if (!mp_obj_is_type(object, &mp_type_type)) { - mp_raise_TypeError("issubclass() arg 1 must be a class"); + mp_raise_TypeError(MP_ERROR_TEXT("issubclass() arg 1 must be a class")); } return mp_obj_is_subclass(object, classinfo); } diff --git a/py/parse.c b/py/parse.c index 8b68fd35e..6ac544733 100644 --- a/py/parse.c +++ b/py/parse.c @@ -714,7 +714,7 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) { mp_obj_t value; if (!mp_parse_node_get_int_maybe(pn_value, &value)) { mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_SyntaxError, - "constant must be an integer"); + MP_ERROR_TEXT("constant must be an integer")); mp_obj_exception_add_traceback(exc, parser->lexer->source_name, ((mp_parse_node_struct_t *)pn1)->source_line, MP_QSTRnull); nlr_raise(exc); @@ -1144,13 +1144,13 @@ mp_parse_tree_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) { mp_obj_t exc; if (lex->tok_kind == MP_TOKEN_INDENT) { exc = mp_obj_new_exception_msg(&mp_type_IndentationError, - "unexpected indent"); + MP_ERROR_TEXT("unexpected indent")); } else if (lex->tok_kind == MP_TOKEN_DEDENT_MISMATCH) { exc = mp_obj_new_exception_msg(&mp_type_IndentationError, - "unindent doesn't match any outer indent level"); + MP_ERROR_TEXT("unindent doesn't match any outer indent level")); } else { exc = mp_obj_new_exception_msg(&mp_type_SyntaxError, - "invalid syntax"); + MP_ERROR_TEXT("invalid syntax")); } // add traceback to give info about file name and location // we don't have a 'block' name, so just pass the NULL qstr to indicate this diff --git a/py/parsenum.c b/py/parsenum.c index d3fa918b7..e665da7d8 100644 --- a/py/parsenum.c +++ b/py/parsenum.c @@ -55,7 +55,7 @@ mp_obj_t mp_parse_num_integer(const char *restrict str_, size_t len, int base, m // check radix base if ((base != 0 && base < 2) || base > 36) { // this won't be reached if lex!=NULL - mp_raise_ValueError("int() arg 2 must be >= 2 and <= 36"); + mp_raise_ValueError(MP_ERROR_TEXT("int() arg 2 must be >= 2 and <= 36")); } // skip leading space @@ -147,11 +147,11 @@ value_error: { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_ValueError, - "invalid syntax for integer"); + MP_ERROR_TEXT("invalid syntax for integer")); raise_exc(exc, lex); #elif MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL mp_obj_t exc = mp_obj_new_exception_msg_varg(&mp_type_ValueError, - "invalid syntax for integer with base %d", base); + MP_ERROR_TEXT("invalid syntax for integer with base %d"), base); raise_exc(exc, lex); #else vstr_t vstr; @@ -344,7 +344,7 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool } #else if (imag || force_complex) { - raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, "complex values not supported"), lex); + raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, MP_ERROR_TEXT("complex values not supported")), lex); } #endif else { @@ -352,9 +352,9 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool } value_error: - raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, "invalid syntax for number"), lex); + raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, MP_ERROR_TEXT("invalid syntax for number")), lex); #else - raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, "decimal numbers not supported"), lex); + raise_exc(mp_obj_new_exception_msg(&mp_type_ValueError, MP_ERROR_TEXT("decimal numbers not supported")), lex); #endif } diff --git a/py/persistentcode.c b/py/persistentcode.c index 19cfb02aa..386ea4947 100644 --- a/py/persistentcode.c +++ b/py/persistentcode.c @@ -357,7 +357,7 @@ STATIC mp_raw_code_t *load_raw_code(mp_reader_t *reader, qstr_window_t *qw) { #if !MICROPY_EMIT_MACHINE_CODE if (kind != MP_CODE_BYTECODE) { - mp_raise_ValueError("incompatible .mpy file"); + mp_raise_ValueError(MP_ERROR_TEXT("incompatible .mpy file")); } #endif @@ -542,12 +542,12 @@ mp_raw_code_t *mp_raw_code_load(mp_reader_t *reader) { || MPY_FEATURE_DECODE_FLAGS(header[2]) != MPY_FEATURE_FLAGS || header[3] > mp_small_int_bits() || read_uint(reader, NULL) > QSTR_WINDOW_SIZE) { - mp_raise_ValueError("incompatible .mpy file"); + mp_raise_ValueError(MP_ERROR_TEXT("incompatible .mpy file")); } if (MPY_FEATURE_DECODE_ARCH(header[2]) != MP_NATIVE_ARCH_NONE) { byte arch = MPY_FEATURE_DECODE_ARCH(header[2]); if (!MPY_FEATURE_ARCH_TEST(arch)) { - mp_raise_ValueError("incompatible .mpy arch"); + mp_raise_ValueError(MP_ERROR_TEXT("incompatible .mpy arch")); } } qstr_window_t qw; @@ -201,7 +201,7 @@ qstr qstr_from_strn(const char *str, size_t len) { // check that len is not too big if (len >= (1 << (8 * MICROPY_QSTR_BYTES_IN_LEN))) { QSTR_EXIT(); - mp_raise_msg(&mp_type_RuntimeError, "name too long"); + mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("name too long")); } // compute number of bytes needed to intern this string diff --git a/py/runtime.c b/py/runtime.c index 49863631a..cad2fc256 100644 --- a/py/runtime.c +++ b/py/runtime.c @@ -186,9 +186,9 @@ mp_obj_t mp_load_global(qstr qst) { elem = mp_map_lookup((mp_map_t *)&mp_module_builtins_globals.map, MP_OBJ_NEW_QSTR(qst), MP_MAP_LOOKUP); if (elem == NULL) { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_msg(&mp_type_NameError, "name not defined"); + mp_raise_msg(&mp_type_NameError, MP_ERROR_TEXT("name not defined")); #else - mp_raise_msg_varg(&mp_type_NameError, "name '%q' isn't defined", qst); + mp_raise_msg_varg(&mp_type_NameError, MP_ERROR_TEXT("name '%q' isn't defined"), qst); #endif } } @@ -287,17 +287,17 @@ mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) { // In this case provide a more focused error message to not confuse, e.g. chr(1.0) #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE if (op == MP_UNARY_OP_INT) { - mp_raise_TypeError("can't convert to int"); + mp_raise_TypeError(MP_ERROR_TEXT("can't convert to int")); } else { - mp_raise_TypeError("unsupported type for operator"); + mp_raise_TypeError(MP_ERROR_TEXT("unsupported type for operator")); } #else if (op == MP_UNARY_OP_INT) { mp_raise_msg_varg(&mp_type_TypeError, - "can't convert %s to int", mp_obj_get_type_str(arg)); + MP_ERROR_TEXT("can't convert %s to int"), mp_obj_get_type_str(arg)); } else { mp_raise_msg_varg(&mp_type_TypeError, - "unsupported type for %q: '%s'", + MP_ERROR_TEXT("unsupported type for %q: '%s'"), mp_unary_op_method_name[op], mp_obj_get_type_str(arg)); } #endif @@ -382,7 +382,7 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { case MP_BINARY_OP_INPLACE_LSHIFT: { if (rhs_val < 0) { // negative shift not allowed - mp_raise_ValueError("negative shift count"); + mp_raise_ValueError(MP_ERROR_TEXT("negative shift count")); } else if (rhs_val >= (mp_int_t)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); @@ -397,7 +397,7 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { case MP_BINARY_OP_INPLACE_RSHIFT: if (rhs_val < 0) { // negative shift not allowed - mp_raise_ValueError("negative shift count"); + mp_raise_ValueError(MP_ERROR_TEXT("negative shift count")); } else { // standard precision is enough for right-shift if (rhs_val >= (mp_int_t)BITS_PER_WORD) { @@ -475,7 +475,7 @@ mp_obj_t mp_binary_op(mp_binary_op_t op, mp_obj_t lhs, mp_obj_t rhs) { #if MICROPY_PY_BUILTINS_FLOAT return mp_obj_float_binary_op(op, lhs_val, rhs); #else - mp_raise_ValueError("negative power with no float support"); + mp_raise_ValueError(MP_ERROR_TEXT("negative power with no float support")); #endif } else { mp_int_t ans = 1; @@ -605,15 +605,15 @@ generic_binary_op: unsupported_op: #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("unsupported type for operator"); + mp_raise_TypeError(MP_ERROR_TEXT("unsupported type for operator")); #else mp_raise_msg_varg(&mp_type_TypeError, - "unsupported types for %q: '%s', '%s'", + MP_ERROR_TEXT("unsupported types for %q: '%s', '%s'"), mp_binary_op_method_name[op], mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs)); #endif zero_division: - mp_raise_msg(&mp_type_ZeroDivisionError, "divide by zero"); + mp_raise_msg(&mp_type_ZeroDivisionError, MP_ERROR_TEXT("divide by zero")); } mp_obj_t mp_call_function_0(mp_obj_t fun) { @@ -647,10 +647,10 @@ mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, size_t n_args, size_t n_kw, cons } #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object not callable"); + mp_raise_TypeError(MP_ERROR_TEXT("object not callable")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object isn't callable", mp_obj_get_type_str(fun_in)); + MP_ERROR_TEXT("'%s' object isn't callable"), mp_obj_get_type_str(fun_in)); #endif } @@ -876,15 +876,15 @@ void mp_unpack_sequence(mp_obj_t seq_in, size_t num, mp_obj_t *items) { too_short: #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_ValueError("wrong number of values to unpack"); + mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack")); #else - mp_raise_msg_varg(&mp_type_ValueError, "need more than %d values to unpack", (int)seq_len); + mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("need more than %d values to unpack"), (int)seq_len); #endif too_long: #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_ValueError("wrong number of values to unpack"); + mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack")); #else - mp_raise_msg_varg(&mp_type_ValueError, "too many values to unpack (expected %d)", (int)num); + mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("too many values to unpack (expected %d)"), (int)num); #endif } @@ -943,9 +943,9 @@ void mp_unpack_ex(mp_obj_t seq_in, size_t num_in, mp_obj_t *items) { too_short: #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_ValueError("wrong number of values to unpack"); + mp_raise_ValueError(MP_ERROR_TEXT("wrong number of values to unpack")); #else - mp_raise_msg_varg(&mp_type_ValueError, "need more than %d values to unpack", (int)seq_len); + mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("need more than %d values to unpack"), (int)seq_len); #endif } @@ -981,10 +981,10 @@ STATIC mp_obj_t checked_fun_call(mp_obj_t self_in, size_t n_args, size_t n_kw, c const mp_obj_type_t *arg0_type = mp_obj_get_type(args[0]); if (arg0_type != self->type) { #if MICROPY_ERROR_REPORTING != MICROPY_ERROR_REPORTING_DETAILED - mp_raise_TypeError("argument has wrong type"); + mp_raise_TypeError(MP_ERROR_TEXT("argument has wrong type")); #else mp_raise_msg_varg(&mp_type_TypeError, - "argument should be a '%q' not a '%q'", self->type->name, arg0_type->name); + MP_ERROR_TEXT("argument should be a '%q' not a '%q'"), self->type->name, arg0_type->name); #endif } } @@ -1106,16 +1106,16 @@ void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) { if (dest[0] == MP_OBJ_NULL) { // no attribute/method called attr #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_msg(&mp_type_AttributeError, "no such attribute"); + mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute")); #else // following CPython, we give a more detailed error message for type objects if (mp_obj_is_type(base, &mp_type_type)) { mp_raise_msg_varg(&mp_type_AttributeError, - "type object '%q' has no attribute '%q'", + MP_ERROR_TEXT("type object '%q' has no attribute '%q'"), ((mp_obj_type_t *)MP_OBJ_TO_PTR(base))->name, attr); } else { mp_raise_msg_varg(&mp_type_AttributeError, - "'%s' object has no attribute '%q'", + MP_ERROR_TEXT("'%s' object has no attribute '%q'"), mp_obj_get_type_str(base), attr); } #endif @@ -1150,10 +1150,10 @@ void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) { } } #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_msg(&mp_type_AttributeError, "no such attribute"); + mp_raise_msg(&mp_type_AttributeError, MP_ERROR_TEXT("no such attribute")); #else mp_raise_msg_varg(&mp_type_AttributeError, - "'%s' object has no attribute '%q'", + MP_ERROR_TEXT("'%s' object has no attribute '%q'"), mp_obj_get_type_str(base), attr); #endif } @@ -1195,10 +1195,10 @@ mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) { // object not iterable #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object not iterable"); + mp_raise_TypeError(MP_ERROR_TEXT("object not iterable")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object isn't iterable", mp_obj_get_type_str(o_in)); + MP_ERROR_TEXT("'%s' object isn't iterable"), mp_obj_get_type_str(o_in)); #endif } @@ -1218,10 +1218,10 @@ mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) { return mp_call_method_n_kw(0, 0, dest); } else { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object not an iterator"); + mp_raise_TypeError(MP_ERROR_TEXT("object not an iterator")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object isn't an iterator", mp_obj_get_type_str(o_in)); + MP_ERROR_TEXT("'%s' object isn't an iterator"), mp_obj_get_type_str(o_in)); #endif } } @@ -1254,10 +1254,10 @@ mp_obj_t mp_iternext(mp_obj_t o_in) { } } else { #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE - mp_raise_TypeError("object not an iterator"); + mp_raise_TypeError(MP_ERROR_TEXT("object not an iterator")); #else mp_raise_msg_varg(&mp_type_TypeError, - "'%s' object isn't an iterator", mp_obj_get_type_str(o_in)); + MP_ERROR_TEXT("'%s' object isn't an iterator"), mp_obj_get_type_str(o_in)); #endif } } @@ -1332,7 +1332,7 @@ mp_vm_return_kind_t mp_resume(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t th // test_delegating_throw_to_non_generator() if (mp_obj_exception_match(throw_value, MP_OBJ_FROM_PTR(&mp_type_StopIteration))) { // PEP479: if StopIteration is raised inside a generator it is replaced with RuntimeError - *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, "generator raised StopIteration"); + *ret_val = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("generator raised StopIteration")); } else { *ret_val = mp_make_raise_obj(throw_value); } @@ -1353,7 +1353,7 @@ mp_obj_t mp_make_raise_obj(mp_obj_t o) { 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"); + return mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("exceptions must derive from BaseException")); } } @@ -1392,7 +1392,7 @@ mp_obj_t mp_import_from(mp_obj_t module, qstr name) { if (dest[1] != MP_OBJ_NULL) { // Hopefully we can't import bound method from an object import_error: - mp_raise_msg_varg(&mp_type_ImportError, "cannot import name %q", name); + mp_raise_msg_varg(&mp_type_ImportError, MP_ERROR_TEXT("cannot import name %q"), name); } if (dest[0] != MP_OBJ_NULL) { @@ -1493,11 +1493,11 @@ NORETURN void m_malloc_fail(size_t num_bytes) { DEBUG_printf("memory allocation failed, allocating %u bytes\n", (uint)num_bytes); #if MICROPY_ENABLE_GC if (gc_is_locked()) { - mp_raise_msg(&mp_type_MemoryError, "memory allocation failed, heap is locked"); + mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("memory allocation failed, heap is locked")); } #endif mp_raise_msg_varg(&mp_type_MemoryError, - "memory allocation failed, allocating %u bytes", (uint)num_bytes); + MP_ERROR_TEXT("memory allocation failed, allocating %u bytes"), (uint)num_bytes); } NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, mp_rom_error_text_t msg) { diff --git a/py/sequence.c b/py/sequence.c index c9cb04178..fa660a338 100644 --- a/py/sequence.c +++ b/py/sequence.c @@ -202,7 +202,7 @@ mp_obj_t mp_seq_index_obj(const mp_obj_t *items, size_t len, size_t n_args, cons } } - mp_raise_ValueError("object not in sequence"); + mp_raise_ValueError(MP_ERROR_TEXT("object not in sequence")); } mp_obj_t mp_seq_count_obj(const mp_obj_t *items, size_t len, mp_obj_t value) { diff --git a/py/stream.c b/py/stream.c index 9d87eb1ac..e6ffd3e2b 100644 --- a/py/stream.c +++ b/py/stream.c @@ -92,7 +92,7 @@ const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags) { || ((flags & MP_STREAM_OP_WRITE) && stream_p->write == NULL) || ((flags & MP_STREAM_OP_IOCTL) && stream_p->ioctl == NULL)) { // CPython: io.UnsupportedOperation, OSError subclass - mp_raise_msg(&mp_type_OSError, "stream operation not supported"); + mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("stream operation not supported")); } return stream_p; } @@ -342,7 +342,7 @@ dispatch_loop: if (obj_shared == MP_OBJ_NULL) { local_name_error: { MARK_EXC_IP_SELECTIVE(); - mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, "local variable referenced before assignment"); + mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NameError, MP_ERROR_TEXT("local variable referenced before assignment")); RAISE(obj); } } @@ -1201,7 +1201,7 @@ unwind_return: } } if (obj == MP_OBJ_NULL) { - obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, "no active exception to reraise"); + obj = mp_obj_new_exception_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("no active exception to reraise")); } RAISE(obj); } @@ -1349,7 +1349,7 @@ yield: #endif { - mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, "opcode"); + mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, MP_ERROR_TEXT("opcode")); nlr_pop(); code_state->state[0] = obj; FRAME_LEAVE(); |