djsundog
/
circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #1121 from tannewt/huffman 

Compress all translated strings with Huffman coding.
This commit is contained in:
Scott Shawcroft 2018-08-16 19:22:45 -07:00 committed by GitHub
parent 92ed5d7bf2 e8cf6a9072
commit 5dd420f7ff
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
90 changed files with 2748 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@ -80,3 +80,6 @@
path = lib/tinyusb path = lib/tinyusb
url = https://github.com/hathach/tinyusb.git url = https://github.com/hathach/tinyusb.git
branch = develop branch = develop
[submodule "tools/huffman"]
path = tools/huffman
url = https://github.com/tannewt/huffman.git

12
extmod/machine_i2c.c
View File

@ -33,6 +33,8 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "extmod/machine_i2c.h" #include "extmod/machine_i2c.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_MACHINE_I2C #if MICROPY_PY_MACHINE_I2C
typedef mp_machine_soft_i2c_obj_t machine_i2c_obj_t; typedef mp_machine_soft_i2c_obj_t machine_i2c_obj_t;
@ -294,7 +296,7 @@ STATIC mp_obj_t machine_i2c_make_new(const mp_obj_type_t *type, size_t n_args, s
extern mp_obj_t MICROPY_PY_MACHINE_I2C_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args); extern mp_obj_t MICROPY_PY_MACHINE_I2C_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
return MICROPY_PY_MACHINE_I2C_MAKE_NEW(type, n_args, n_kw, args); return MICROPY_PY_MACHINE_I2C_MAKE_NEW(type, n_args, n_kw, args);
#else #else
mp_raise_ValueError("invalid I2C peripheral"); mp_raise_ValueError(translate("invalid I2C peripheral"));
#endif #endif
} }
--n_args; --n_args;
@ -335,7 +337,7 @@ STATIC mp_obj_t machine_i2c_start(mp_obj_t self_in) {
mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in); mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol; mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
if (i2c_p->start == NULL) { if (i2c_p->start == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported"); mp_raise_msg(&mp_type_OSError, translate("I2C operation not supported"));
} }
int ret = i2c_p->start(self); int ret = i2c_p->start(self);
if (ret != 0) { if (ret != 0) {
@ -349,7 +351,7 @@ STATIC mp_obj_t machine_i2c_stop(mp_obj_t self_in) {
mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in); mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol; mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
if (i2c_p->stop == NULL) { if (i2c_p->stop == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported"); mp_raise_msg(&mp_type_OSError, translate("I2C operation not supported"));
} }
int ret = i2c_p->stop(self); int ret = i2c_p->stop(self);
if (ret != 0) { if (ret != 0) {
@ -363,7 +365,7 @@ STATIC mp_obj_t machine_i2c_readinto(size_t n_args, const mp_obj_t *args) {
mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]); mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(args[0]);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol; mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
if (i2c_p->read == NULL) { if (i2c_p->read == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported"); mp_raise_msg(&mp_type_OSError, translate("I2C operation not supported"));
} }
// get the buffer to read into // get the buffer to read into
@ -387,7 +389,7 @@ STATIC mp_obj_t machine_i2c_write(mp_obj_t self_in, mp_obj_t buf_in) {
mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in); mp_obj_base_t *self = (mp_obj_base_t*)MP_OBJ_TO_PTR(self_in);
mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol; mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t*)self->type->protocol;
if (i2c_p->write == NULL) { if (i2c_p->write == NULL) {
mp_raise_msg(&mp_type_OSError, "I2C operation not supported"); mp_raise_msg(&mp_type_OSError, translate("I2C operation not supported"));
} }
// get the buffer to write from // get the buffer to write from

2
extmod/machine_mem.c
View File

@ -42,7 +42,7 @@
STATIC uintptr_t machine_mem_get_addr(mp_obj_t addr_o, uint align) { STATIC uintptr_t machine_mem_get_addr(mp_obj_t addr_o, uint align) {
uintptr_t addr = mp_obj_int_get_truncated(addr_o); uintptr_t addr = mp_obj_int_get_truncated(addr_o);
if ((addr & (align - 1)) != 0) { if ((addr & (align - 1)) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align)); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, translate("address %08x is not aligned to %d bytes"), addr, align));
} }
return addr; return addr;
} }

12
extmod/machine_spi.c
View File

@ -30,6 +30,8 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "extmod/machine_spi.h" #include "extmod/machine_spi.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_MACHINE_SPI #if MICROPY_PY_MACHINE_SPI
// if a port didn't define MSB/LSB constants then provide them // if a port didn't define MSB/LSB constants then provide them
@ -52,7 +54,7 @@ mp_obj_t mp_machine_spi_make_new(const mp_obj_type_t *type, size_t n_args, size_
extern mp_obj_t MICROPY_PY_MACHINE_SPI_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args); extern mp_obj_t MICROPY_PY_MACHINE_SPI_MAKE_NEW(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args);
return MICROPY_PY_MACHINE_SPI_MAKE_NEW(type, n_args, n_kw, args); return MICROPY_PY_MACHINE_SPI_MAKE_NEW(type, n_args, n_kw, args);
#else #else
mp_raise_ValueError("invalid SPI peripheral"); mp_raise_ValueError(translate("invalid SPI peripheral"));
#endif #endif
} }
--n_args; --n_args;
@ -119,7 +121,7 @@ STATIC mp_obj_t mp_machine_spi_write_readinto(mp_obj_t self, mp_obj_t wr_buf, mp
mp_buffer_info_t dest; mp_buffer_info_t dest;
mp_get_buffer_raise(rd_buf, &dest, MP_BUFFER_WRITE); mp_get_buffer_raise(rd_buf, &dest, MP_BUFFER_WRITE);
if (src.len != dest.len) { if (src.len != dest.len) {
mp_raise_ValueError("buffers must be the same length"); mp_raise_ValueError(translate("buffers must be the same length"));
} }
mp_machine_spi_transfer(self, src.len, src.buf, dest.buf); mp_machine_spi_transfer(self, src.len, src.buf, dest.buf);
return mp_const_none; return mp_const_none;
@ -202,15 +204,15 @@ STATIC mp_obj_t mp_machine_soft_spi_make_new(const mp_obj_type_t *type, size_t n
self->spi.polarity = args[ARG_polarity].u_int; self->spi.polarity = args[ARG_polarity].u_int;
self->spi.phase = args[ARG_phase].u_int; self->spi.phase = args[ARG_phase].u_int;
if (args[ARG_bits].u_int != 8) { if (args[ARG_bits].u_int != 8) {
mp_raise_ValueError("bits must be 8"); mp_raise_ValueError(translate("bits must be 8"));
} }
if (args[ARG_firstbit].u_int != MICROPY_PY_MACHINE_SPI_MSB) { if (args[ARG_firstbit].u_int != MICROPY_PY_MACHINE_SPI_MSB) {
mp_raise_ValueError("firstbit must be MSB"); mp_raise_ValueError(translate("firstbit must be MSB"));
} }
if (args[ARG_sck].u_obj == MP_OBJ_NULL if (args[ARG_sck].u_obj == MP_OBJ_NULL
|| args[ARG_mosi].u_obj == MP_OBJ_NULL || args[ARG_mosi].u_obj == MP_OBJ_NULL
|| args[ARG_miso].u_obj == MP_OBJ_NULL) { || args[ARG_miso].u_obj == MP_OBJ_NULL) {
mp_raise_ValueError("must specify all of sck/mosi/miso"); mp_raise_ValueError(translate("must specify all of sck/mosi/miso"));
} }
self->spi.sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj); self->spi.sck = mp_hal_get_pin_obj(args[ARG_sck].u_obj);
self->spi.mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj); self->spi.mosi = mp_hal_get_pin_obj(args[ARG_mosi].u_obj);

2
extmod/modframebuf.c
View File

@ -296,7 +296,7 @@ STATIC mp_obj_t framebuf_make_new(const mp_obj_type_t *type, size_t n_args, size
case FRAMEBUF_GS8: case FRAMEBUF_GS8:
break; break;
default: default:
mp_raise_ValueError("invalid format"); mp_raise_ValueError(translate("invalid format"));
} }
return MP_OBJ_FROM_PTR(o); return MP_OBJ_FROM_PTR(o);

8
extmod/modubinascii.c
View File

@ -35,7 +35,7 @@
static void check_not_unicode(const mp_obj_t arg) { static void check_not_unicode(const mp_obj_t arg) {
#if MICROPY_CPYTHON_COMPAT #if MICROPY_CPYTHON_COMPAT
if (MP_OBJ_IS_STR(arg)) { if (MP_OBJ_IS_STR(arg)) {
mp_raise_TypeError("a bytes-like object is required"); mp_raise_TypeError(translate("a bytes-like object is required"));
} }
#endif #endif
} }
@ -87,7 +87,7 @@ mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ); mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
if ((bufinfo.len & 1) != 0) { if ((bufinfo.len & 1) != 0) {
mp_raise_ValueError("odd-length string"); mp_raise_ValueError(translate("odd-length string"));
} }
vstr_t vstr; vstr_t vstr;
vstr_init_len(&vstr, bufinfo.len / 2); vstr_init_len(&vstr, bufinfo.len / 2);
@ -98,7 +98,7 @@ mp_obj_t mod_binascii_unhexlify(mp_obj_t data) {
if (unichar_isxdigit(hex_ch)) { if (unichar_isxdigit(hex_ch)) {
hex_byte += unichar_xdigit_value(hex_ch); hex_byte += unichar_xdigit_value(hex_ch);
} else { } else {
mp_raise_ValueError("non-hex digit found"); mp_raise_ValueError(translate("non-hex digit found"));
} }
if (i & 1) { if (i & 1) {
hex_byte <<= 4; hex_byte <<= 4;
@ -166,7 +166,7 @@ mp_obj_t mod_binascii_a2b_base64(mp_obj_t data) {
} }
if (nbits) { if (nbits) {
mp_raise_ValueError("incorrect padding"); mp_raise_ValueError(translate("incorrect padding"));
} }
return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr); return mp_obj_new_str_from_vstr(&mp_type_bytes, &vstr);

12
extmod/moductypes.c
View File

@ -32,6 +32,8 @@
#include "py/objtuple.h" #include "py/objtuple.h"
#include "py/binary.h" #include "py/binary.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UCTYPES #if MICROPY_PY_UCTYPES
/// \module uctypes - Access data structures in memory /// \module uctypes - Access data structures in memory
@ -117,7 +119,7 @@ typedef struct _mp_obj_uctypes_struct_t {
} mp_obj_uctypes_struct_t; } mp_obj_uctypes_struct_t;
STATIC NORETURN void syntax_error(void) { STATIC NORETURN void syntax_error(void) {
mp_raise_TypeError("syntax error in uctypes descriptor"); mp_raise_TypeError(translate("syntax error in uctypes descriptor"));
} }
STATIC mp_obj_t uctypes_struct_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) { STATIC mp_obj_t uctypes_struct_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
@ -214,7 +216,7 @@ STATIC mp_uint_t uctypes_struct_size(mp_obj_t desc_in, int layout_type, mp_uint_
// but scalar structure field is lowered into native Python int, so all // but scalar structure field is lowered into native Python int, so all
// type info is lost. So, we cannot say if it's scalar type description, // type info is lost. So, we cannot say if it's scalar type description,
// or such lowered scalar. // or such lowered scalar.
mp_raise_TypeError("Cannot unambiguously get sizeof scalar"); mp_raise_TypeError(translate("Cannot unambiguously get sizeof scalar"));
} }
syntax_error(); syntax_error();
} }
@ -392,7 +394,7 @@ STATIC mp_obj_t uctypes_struct_attr_op(mp_obj_t self_in, qstr attr, mp_obj_t set
// TODO: Support at least OrderedDict in addition // TODO: Support at least OrderedDict in addition
if (!MP_OBJ_IS_TYPE(self->desc, &mp_type_dict)) { if (!MP_OBJ_IS_TYPE(self->desc, &mp_type_dict)) {
mp_raise_TypeError("struct: no fields"); mp_raise_TypeError(translate("struct: no fields"));
} }
mp_obj_t deref = mp_obj_dict_get(self->desc, MP_OBJ_NEW_QSTR(attr)); mp_obj_t deref = mp_obj_dict_get(self->desc, MP_OBJ_NEW_QSTR(attr));
@ -525,7 +527,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
} else { } else {
// load / store // load / store
if (!MP_OBJ_IS_TYPE(self->desc, &mp_type_tuple)) { if (!MP_OBJ_IS_TYPE(self->desc, &mp_type_tuple)) {
mp_raise_TypeError("struct: cannot index"); mp_raise_TypeError(translate("struct: cannot index"));
} }
mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc); mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->desc);
@ -539,7 +541,7 @@ STATIC mp_obj_t uctypes_struct_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_ob
uint val_type = GET_TYPE(arr_sz, VAL_TYPE_BITS); uint val_type = GET_TYPE(arr_sz, VAL_TYPE_BITS);
arr_sz &= VALUE_MASK(VAL_TYPE_BITS); arr_sz &= VALUE_MASK(VAL_TYPE_BITS);
if (index >= arr_sz) { if (index >= arr_sz) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "struct: index out of range")); nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, translate("struct: index out of range")));
} }
if (t->len == 2) { if (t->len == 2) {

4
extmod/moduhashlib.c
View File

@ -29,6 +29,8 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UHASHLIB #if MICROPY_PY_UHASHLIB
#if MICROPY_PY_UHASHLIB_SHA256 #if MICROPY_PY_UHASHLIB_SHA256
@ -97,7 +99,7 @@ STATIC mp_obj_t uhashlib_sha256_digest(mp_obj_t self_in) {
static void check_not_unicode(const mp_obj_t arg) { static void check_not_unicode(const mp_obj_t arg) {
#if MICROPY_CPYTHON_COMPAT #if MICROPY_CPYTHON_COMPAT
if (MP_OBJ_IS_STR(arg)) { if (MP_OBJ_IS_STR(arg)) {
mp_raise_TypeError("a bytes-like object is required"); mp_raise_TypeError(translate("a bytes-like object is required"));
} }
#endif #endif
} }

6
extmod/moduheapq.c
View File

@ -27,13 +27,15 @@
#include "py/objlist.h" #include "py/objlist.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UHEAPQ #if MICROPY_PY_UHEAPQ
// the algorithm here is modelled on CPython's heapq.py // the algorithm here is modelled on CPython's heapq.py
STATIC mp_obj_list_t *get_heap(mp_obj_t heap_in) { STATIC mp_obj_list_t *get_heap(mp_obj_t heap_in) {
if (!MP_OBJ_IS_TYPE(heap_in, &mp_type_list)) { if (!MP_OBJ_IS_TYPE(heap_in, &mp_type_list)) {
mp_raise_TypeError("heap must be a list"); mp_raise_TypeError(translate("heap must be a list"));
} }
return MP_OBJ_TO_PTR(heap_in); return MP_OBJ_TO_PTR(heap_in);
} }
@ -81,7 +83,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_uheapq_heappush_obj, mod_uheapq_heappush);
STATIC mp_obj_t mod_uheapq_heappop(mp_obj_t heap_in) { STATIC mp_obj_t mod_uheapq_heappop(mp_obj_t heap_in) {
mp_obj_list_t *heap = get_heap(heap_in); mp_obj_list_t *heap = get_heap(heap_in);
if (heap->len == 0) { if (heap->len == 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "empty heap")); nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, translate("empty heap")));
} }
mp_obj_t item = heap->items[0]; mp_obj_t item = heap->items[0];
heap->len -= 1; heap->len -= 1;

4
extmod/modujson.c
View File

@ -32,6 +32,8 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/stream.h" #include "py/stream.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UJSON #if MICROPY_PY_UJSON
STATIC mp_obj_t mod_ujson_dump(mp_obj_t obj, mp_obj_t stream) { STATIC mp_obj_t mod_ujson_dump(mp_obj_t obj, mp_obj_t stream) {
@ -276,7 +278,7 @@ STATIC mp_obj_t mod_ujson_load(mp_obj_t stream_obj) {
return stack_top; return stack_top;
fail: fail:
mp_raise_ValueError("syntax error in JSON"); mp_raise_ValueError(translate("syntax error in JSON"));
} }
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_load_obj, mod_ujson_load); STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ujson_load_obj, mod_ujson_load);

4
extmod/modure.c
View File

@ -158,7 +158,7 @@ STATIC mp_obj_t re_split(size_t n_args, const mp_obj_t *args) {
mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte*)subj.begin, caps[0] - subj.begin); mp_obj_t s = mp_obj_new_str_of_type(str_type, (const byte*)subj.begin, caps[0] - subj.begin);
mp_obj_list_append(retval, s); mp_obj_list_append(retval, s);
if (self->re.sub > 0) { if (self->re.sub > 0) {
mp_raise_NotImplementedError("Splitting with sub-captures"); mp_raise_NotImplementedError(translate("Splitting with sub-captures"));
} }
subj.begin = caps[1]; subj.begin = caps[1];
if (maxsplit > 0 && --maxsplit == 0) { if (maxsplit > 0 && --maxsplit == 0) {
@ -204,7 +204,7 @@ STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
int error = re1_5_compilecode(&o->re, re_str); int error = re1_5_compilecode(&o->re, re_str);
if (error != 0) { if (error != 0) {
error: error:
mp_raise_ValueError("Error in regex"); mp_raise_ValueError(translate("Error in regex"));
} }
if (flags & FLAG_DEBUG) { if (flags & FLAG_DEBUG) {
re1_5_dumpcode(&o->re); re1_5_dumpcode(&o->re);

6
extmod/modussl_axtls.c
View File

@ -30,6 +30,8 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/stream.h" #include "py/stream.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_USSL && MICROPY_SSL_AXTLS #if MICROPY_PY_USSL && MICROPY_SSL_AXTLS
#include "ssl.h" #include "ssl.h"
@ -76,13 +78,13 @@ STATIC mp_obj_ssl_socket_t *socket_new(mp_obj_t sock, struct ssl_args *args) {
const byte *data = (const byte*)mp_obj_str_get_data(args->key.u_obj, &len); const byte *data = (const byte*)mp_obj_str_get_data(args->key.u_obj, &len);
int res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_RSA_KEY, data, len, NULL); int res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_RSA_KEY, data, len, NULL);
if (res != SSL_OK) { if (res != SSL_OK) {
mp_raise_ValueError("invalid key"); mp_raise_ValueError(translate("invalid key"));
} }
data = (const byte*)mp_obj_str_get_data(args->cert.u_obj, &len); data = (const byte*)mp_obj_str_get_data(args->cert.u_obj, &len);
res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_X509_CERT, data, len, NULL); res = ssl_obj_memory_load(o->ssl_ctx, SSL_OBJ_X509_CERT, data, len, NULL);
if (res != SSL_OK) { if (res != SSL_OK) {
mp_raise_ValueError("invalid cert"); mp_raise_ValueError(translate("invalid cert"));
} }
} }

8
extmod/modutimeq.c
View File

@ -31,6 +31,8 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/smallint.h" #include "py/smallint.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UTIMEQ #if MICROPY_PY_UTIMEQ
#define MODULO MICROPY_PY_UTIME_TICKS_PERIOD #define MODULO MICROPY_PY_UTIME_TICKS_PERIOD
@ -126,7 +128,7 @@ STATIC mp_obj_t mod_utimeq_heappush(size_t n_args, const mp_obj_t *args) {
mp_obj_t heap_in = args[0]; mp_obj_t heap_in = args[0];
mp_obj_utimeq_t *heap = get_heap(heap_in); mp_obj_utimeq_t *heap = get_heap(heap_in);
if (heap->len == heap->alloc) { if (heap->len == heap->alloc) {
mp_raise_IndexError("queue overflow"); mp_raise_IndexError(translate("queue overflow"));
} }
mp_uint_t l = heap->len; mp_uint_t l = heap->len;
heap->items[l].time = MP_OBJ_SMALL_INT_VALUE(args[1]); heap->items[l].time = MP_OBJ_SMALL_INT_VALUE(args[1]);
@ -142,7 +144,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_utimeq_heappush_obj, 4, 4, mod_ut
STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) { STATIC mp_obj_t mod_utimeq_heappop(mp_obj_t heap_in, mp_obj_t list_ref) {
mp_obj_utimeq_t *heap = get_heap(heap_in); mp_obj_utimeq_t *heap = get_heap(heap_in);
if (heap->len == 0) { if (heap->len == 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "empty heap")); mp_raise_IndexError(translate("empty heap"));
} }
mp_obj_list_t *ret = MP_OBJ_TO_PTR(list_ref); mp_obj_list_t *ret = MP_OBJ_TO_PTR(list_ref);
if (!MP_OBJ_IS_TYPE(list_ref, &mp_type_list) || ret->len < 3) { if (!MP_OBJ_IS_TYPE(list_ref, &mp_type_list) || ret->len < 3) {
@ -167,7 +169,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_utimeq_heappop_obj, mod_utimeq_heappop);
STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) { STATIC mp_obj_t mod_utimeq_peektime(mp_obj_t heap_in) {
mp_obj_utimeq_t *heap = get_heap(heap_in); mp_obj_utimeq_t *heap = get_heap(heap_in);
if (heap->len == 0) { if (heap->len == 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_IndexError, "empty heap")); mp_raise_IndexError(translate("empty heap"));
} }
struct qentry *item = &heap->items[0]; struct qentry *item = &heap->items[0];

4
extmod/moduzlib.c
View File

@ -31,6 +31,8 @@
#include "py/stream.h" #include "py/stream.h"
#include "py/mperrno.h" #include "py/mperrno.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UZLIB #if MICROPY_PY_UZLIB
#include "../../lib/uzlib/src/tinf.h" #include "../../lib/uzlib/src/tinf.h"
@ -92,7 +94,7 @@ STATIC mp_obj_t decompio_make_new(const mp_obj_type_t *type, size_t n_args, size
dict_opt = uzlib_zlib_parse_header(&o->decomp); dict_opt = uzlib_zlib_parse_header(&o->decomp);
if (dict_opt < 0) { if (dict_opt < 0) {
header_error: header_error:
mp_raise_ValueError("compression header"); mp_raise_ValueError(translate("compression header"));
} }
dict_sz = 1 << dict_opt; dict_sz = 1 << dict_opt;
} else { } else {

4
extmod/uos_dupterm.c
View File

@ -34,6 +34,8 @@
#include "py/stream.h" #include "py/stream.h"
#include "lib/utils/interrupt_char.h" #include "lib/utils/interrupt_char.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_OS_DUPTERM #if MICROPY_PY_OS_DUPTERM
void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc) { void mp_uos_deactivate(size_t dupterm_idx, const char *msg, mp_obj_t exc) {
@ -115,7 +117,7 @@ STATIC mp_obj_t mp_uos_dupterm(size_t n_args, const mp_obj_t *args) {
} }
if (idx < 0 || idx >= MICROPY_PY_OS_DUPTERM) { if (idx < 0 || idx >= MICROPY_PY_OS_DUPTERM) {
mp_raise_ValueError("invalid dupterm index"); mp_raise_ValueError(translate("invalid dupterm index"));
} }
mp_obj_t previous_obj = MP_STATE_VM(dupterm_objs[idx]); mp_obj_t previous_obj = MP_STATE_VM(dupterm_objs[idx]);

1
extmod/vfs_posix.c
View File

@ -31,6 +31,7 @@
#if defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX #if defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX
#include <stdio.h>
#include <string.h> #include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <dirent.h> #include <dirent.h>

3
extmod/vfs_posix_file.c
View File

@ -27,6 +27,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/stream.h" #include "py/stream.h"
#include "extmod/vfs_posix.h" #include "extmod/vfs_posix.h"
#include "supervisor/shared/translate.h"
#if defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX #if defined(MICROPY_VFS_POSIX) && MICROPY_VFS_POSIX
@ -44,7 +45,7 @@ typedef struct _mp_obj_vfs_posix_file_t {
#ifdef MICROPY_CPYTHON_COMPAT #ifdef MICROPY_CPYTHON_COMPAT
STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) { STATIC void check_fd_is_open(const mp_obj_vfs_posix_file_t *o) {
if (o->fd < 0) { if (o->fd < 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, "I/O operation on closed file")); nlr_raise(mp_obj_new_exception_msg(&mp_type_ValueError, translate("I/O operation on closed file")));
} }
} }
#else #else

3
lib/netutils/netutils.c
View File

@ -31,6 +31,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "lib/netutils/netutils.h" #include "lib/netutils/netutils.h"
#include "supervisor/shared/translate.h"
// Takes an array with a raw IPv4 address and returns something like '192.168.0.1'. // Takes an array with a raw IPv4 address and returns something like '192.168.0.1'.
mp_obj_t netutils_format_ipv4_addr(uint8_t *ip, netutils_endian_t endian) { mp_obj_t netutils_format_ipv4_addr(uint8_t *ip, netutils_endian_t endian) {
@ -79,7 +80,7 @@ void netutils_parse_ipv4_addr(mp_obj_t addr_in, uint8_t *out_ip, netutils_endian
} else if (i > 0 && s < s_top && *s == '.') { } else if (i > 0 && s < s_top && *s == '.') {
s++; s++;
} else { } else {
mp_raise_ValueError("invalid arguments"); mp_raise_ValueError(translate("invalid arguments"));
} }
} }
} }

765
locale/circuitpython.pot
View File

File diff suppressed because it is too large Load Diff

765
locale/en_US.po
View File

File diff suppressed because it is too large Load Diff

765
locale/es.po
View File

File diff suppressed because it is too large Load Diff

43
main.c
View File

@ -128,13 +128,22 @@ const char* first_existing_file_in_list(const char ** filenames) {
return NULL; return NULL;
} }
void write_compressed(const compressed_string_t* compressed) {
char decompressed[compressed->length];
decompress(compressed, decompressed);
serial_write(decompressed);
}
bool maybe_run_list(const char ** filenames, pyexec_result_t* exec_result) { bool maybe_run_list(const char ** filenames, pyexec_result_t* exec_result) {
const char* filename = first_existing_file_in_list(filenames); const char* filename = first_existing_file_in_list(filenames);
if (filename == NULL) { if (filename == NULL) {
return false; return false;
} }
mp_hal_stdout_tx_str(filename); mp_hal_stdout_tx_str(filename);
mp_hal_stdout_tx_str(translate(" output:\n")); const compressed_string_t* compressed = translate(" output:\n");
char decompressed[compressed->length];
decompress(compressed, decompressed);
mp_hal_stdout_tx_str(decompressed);
pyexec_file(filename, exec_result); pyexec_file(filename, exec_result);
return true; return true;
} }
@ -145,11 +154,11 @@ bool run_code_py(safe_mode_t safe_mode) {
if (serial_connected_at_start) { if (serial_connected_at_start) {
serial_write("\n"); serial_write("\n");
if (autoreload_is_enabled()) { if (autoreload_is_enabled()) {
serial_write(translate("Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.\n")); write_compressed(translate("Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.\n"));
} else if (safe_mode != NO_SAFE_MODE) { } else if (safe_mode != NO_SAFE_MODE) {
serial_write(translate("Running in safe mode! Auto-reload is off.\n")); write_compressed(translate("Running in safe mode! Auto-reload is off.\n"));
} else if (!autoreload_is_enabled()) { } else if (!autoreload_is_enabled()) {
serial_write(translate("Auto-reload is off.\n")); write_compressed(translate("Auto-reload is off.\n"));
} }
} }
#endif #endif
@ -163,7 +172,7 @@ bool run_code_py(safe_mode_t safe_mode) {
bool found_main = false; bool found_main = false;
if (safe_mode != NO_SAFE_MODE) { if (safe_mode != NO_SAFE_MODE) {
serial_write(translate("Running in safe mode! Not running saved code.\n")); write_compressed(translate("Running in safe mode! Not running saved code.\n"));
} else { } else {
new_status_color(MAIN_RUNNING); new_status_color(MAIN_RUNNING);
@ -179,7 +188,7 @@ bool run_code_py(safe_mode_t safe_mode) {
if (!found_main){ if (!found_main){
found_main = maybe_run_list(double_extension_filenames, &result); found_main = maybe_run_list(double_extension_filenames, &result);
if (found_main) { if (found_main) {
serial_write(translate("WARNING: Your code filename has two extensions\n")); write_compressed(translate("WARNING: Your code filename has two extensions\n"));
} }
} }
stop_mp(); stop_mp();
@ -218,37 +227,37 @@ bool run_code_py(safe_mode_t safe_mode) {
if (!serial_connected_at_start) { if (!serial_connected_at_start) {
if (autoreload_is_enabled()) { if (autoreload_is_enabled()) {
serial_write(translate("Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.\n")); write_compressed(translate("Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.\n"));
} else { } else {
serial_write(translate("Auto-reload is off.\n")); write_compressed(translate("Auto-reload is off.\n"));
} }
} }
// Output a user safe mode string if its set. // Output a user safe mode string if its set.
#ifdef BOARD_USER_SAFE_MODE #ifdef BOARD_USER_SAFE_MODE
if (safe_mode == USER_SAFE_MODE) { if (safe_mode == USER_SAFE_MODE) {
serial_write("\n"); serial_write("\n");
serial_write(translate("You requested starting safe mode by ")); write_compressed(translate("You requested starting safe mode by "));
serial_write(BOARD_USER_SAFE_MODE_ACTION); serial_write(BOARD_USER_SAFE_MODE_ACTION);
serial_write("\n"); serial_write("\n");
serial_write(translate("To exit, please reset the board without ")); write_compressed(translate("To exit, please reset the board without "));
serial_write(BOARD_USER_SAFE_MODE_ACTION); serial_write(BOARD_USER_SAFE_MODE_ACTION);
serial_write("\n"); serial_write("\n");
} else } else
#endif #endif
if (safe_mode != NO_SAFE_MODE) { if (safe_mode != NO_SAFE_MODE) {
serial_write("\n"); serial_write("\n");
serial_write(translate("You are running in safe mode which means something really bad happened.\n")); write_compressed(translate("You are running in safe mode which means something really bad happened.\n"));
if (safe_mode == HARD_CRASH) { if (safe_mode == HARD_CRASH) {
serial_write(translate("Looks like our core CircuitPython code crashed hard. Whoops!\n")); write_compressed(translate("Looks like our core CircuitPython code crashed hard. Whoops!\n"));
serial_write(translate("Please file an issue here with the contents of your CIRCUITPY drive:\n")); write_compressed(translate("Please file an issue here with the contents of your CIRCUITPY drive:\n"));
serial_write("https://github.com/adafruit/circuitpython/issues\n"); serial_write("https://github.com/adafruit/circuitpython/issues\n");
} else if (safe_mode == BROWNOUT) { } else if (safe_mode == BROWNOUT) {
serial_write(translate("The microcontroller's power dipped. Please make sure your power supply provides\n")); write_compressed(translate("The microcontroller's power dipped. Please make sure your power supply provides\n"));
serial_write(translate("enough power for the whole circuit and press reset (after ejecting CIRCUITPY).\n")); write_compressed(translate("enough power for the whole circuit and press reset (after ejecting CIRCUITPY).\n"));
} }
} }
serial_write("\n"); serial_write("\n");
serial_write(translate("Press any key to enter the REPL. Use CTRL-D to reload.")); write_compressed(translate("Press any key to enter the REPL. Use CTRL-D to reload."));
} }
if (serial_connected_before_animation && !serial_connected()) { if (serial_connected_before_animation && !serial_connected()) {
serial_connected_at_start = false; serial_connected_at_start = false;
@ -403,7 +412,7 @@ int __attribute__((used)) main(void) {
} }
if (exit_code == PYEXEC_FORCED_EXIT) { if (exit_code == PYEXEC_FORCED_EXIT) {
if (!first_run) { if (!first_run) {
serial_write(translate("soft reboot\n")); write_compressed(translate("soft reboot\n"));
} }
first_run = false; first_run = false;
skip_repl = run_code_py(safe_mode); skip_repl = run_code_py(safe_mode);

5
ports/atmel-samd/audio_dma.c
View File

@ -33,6 +33,7 @@
#include "shared-bindings/audioio/WaveFile.h" #include "shared-bindings/audioio/WaveFile.h"
#include "py/mpstate.h" #include "py/mpstate.h"
#include "py/runtime.h"
static audio_dma_t* audio_dma_state[AUDIO_DMA_CHANNEL_COUNT]; static audio_dma_t* audio_dma_state[AUDIO_DMA_CHANNEL_COUNT];
@ -279,6 +280,10 @@ audio_dma_result audio_dma_setup_playback(audio_dma_t* dma,
// We're likely double buffering so set up the block interrupts. // We're likely double buffering so set up the block interrupts.
turn_on_event_system(); turn_on_event_system();
dma->event_channel = find_sync_event_channel(); dma->event_channel = find_sync_event_channel();
if (dma->event_channel >= EVSYS_SYNCH_NUM) {
mp_raise_RuntimeError(translate("All sync event channels in use"));
}
init_event_channel_interrupt(dma->event_channel, CORE_GCLK, EVSYS_ID_GEN_DMAC_CH_0 + dma_channel); init_event_channel_interrupt(dma->event_channel, CORE_GCLK, EVSYS_ID_GEN_DMAC_CH_0 + dma_channel);
// We keep the audio_dma_t for internal use and the sample as a root pointer because it // We keep the audio_dma_t for internal use and the sample as a root pointer because it

4
ports/atmel-samd/bindings/samd/Clock.c
View File

@ -132,9 +132,9 @@ STATIC mp_obj_t samd_clock_set_calibration(mp_obj_t self_in, mp_obj_t calibratio
samd_clock_obj_t *self = MP_OBJ_TO_PTR(self_in); samd_clock_obj_t *self = MP_OBJ_TO_PTR(self_in);
int ret = clock_set_calibration(self->type, self->index, mp_obj_get_int(calibration)); int ret = clock_set_calibration(self->type, self->index, mp_obj_get_int(calibration));
if (ret == -2) if (ret == -2)
mp_raise_AttributeError("calibration is read only"); mp_raise_AttributeError(translate("calibration is read only"));
if (ret == -1) if (ret == -1)
mp_raise_ValueError("calibration is out of range"); mp_raise_ValueError(translate("calibration is out of range"));
return mp_const_none; return mp_const_none;
} }

7
ports/atmel-samd/board_busses.c
View File

@ -29,13 +29,14 @@
#include "shared-bindings/busio/UART.h" #include "shared-bindings/busio/UART.h"
#include "shared-bindings/microcontroller/Pin.h" #include "shared-bindings/microcontroller/Pin.h"
#include "supervisor/shared/translate.h"
#include "mpconfigboard.h" #include "mpconfigboard.h"
#include "samd/pins.h" #include "samd/pins.h"
#include "py/runtime.h" #include "py/runtime.h"
#if !defined(DEFAULT_I2C_BUS_SDA) || !defined(DEFAULT_I2C_BUS_SCL) #if !defined(DEFAULT_I2C_BUS_SDA) || !defined(DEFAULT_I2C_BUS_SCL)
STATIC mp_obj_t board_i2c(void) { STATIC mp_obj_t board_i2c(void) {
mp_raise_NotImplementedError("No default I2C bus"); mp_raise_NotImplementedError(translate("No default I2C bus"));
return NULL; return NULL;
} }
#else #else
@ -60,7 +61,7 @@ MP_DEFINE_CONST_FUN_OBJ_0(board_i2c_obj, board_i2c);
#if !defined(DEFAULT_SPI_BUS_SCK) || !defined(DEFAULT_SPI_BUS_MISO) || !defined(DEFAULT_SPI_BUS_MOSI) #if !defined(DEFAULT_SPI_BUS_SCK) || !defined(DEFAULT_SPI_BUS_MISO) || !defined(DEFAULT_SPI_BUS_MOSI)
STATIC mp_obj_t board_spi(void) { STATIC mp_obj_t board_spi(void) {
mp_raise_NotImplementedError("No default SPI bus"); mp_raise_NotImplementedError(translate("No default SPI bus"));
return NULL; return NULL;
} }
#else #else
@ -87,7 +88,7 @@ MP_DEFINE_CONST_FUN_OBJ_0(board_spi_obj, board_spi);
#if !defined(DEFAULT_UART_BUS_RX) || !defined(DEFAULT_UART_BUS_TX) #if !defined(DEFAULT_UART_BUS_RX) || !defined(DEFAULT_UART_BUS_TX)
STATIC mp_obj_t board_uart(void) { STATIC mp_obj_t board_uart(void) {
mp_raise_NotImplementedError("No default UART bus"); mp_raise_NotImplementedError(translate("No default UART bus"));
return NULL; return NULL;
} }
#else #else

2
ports/atmel-samd/common-hal/analogio/AnalogOut.c
View File

@ -46,7 +46,7 @@
void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self, void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self,
const mcu_pin_obj_t *pin) { const mcu_pin_obj_t *pin) {
#if defined(SAMD21) && !defined(PIN_PA02) #if defined(SAMD21) && !defined(PIN_PA02)
mp_raise_NotImplementedError("No DAC on chip"); mp_raise_NotImplementedError(translate("No DAC on chip"));
#else #else
if (pin->number != PIN_PA02 if (pin->number != PIN_PA02
#ifdef SAMD51 #ifdef SAMD51

3
ports/atmel-samd/common-hal/audiobusio/PDMIn.c
View File

@ -357,6 +357,9 @@ uint32_t common_hal_audiobusio_pdmin_record_to_buffer(audiobusio_pdmin_obj_t* se
uint16_t* output_buffer, uint32_t output_buffer_length) { uint16_t* output_buffer, uint32_t output_buffer_length) {
uint8_t dma_channel = find_free_audio_dma_channel(); uint8_t dma_channel = find_free_audio_dma_channel();
uint8_t event_channel = find_sync_event_channel(); uint8_t event_channel = find_sync_event_channel();
if (event_channel >= EVSYS_SYNCH_NUM) {
mp_raise_RuntimeError(translate("All sync event channels in use"));
}
// We allocate two buffers on the stack to use for double buffering. // We allocate two buffers on the stack to use for double buffering.
const uint8_t samples_per_buffer = SAMPLES_PER_BUFFER; const uint8_t samples_per_buffer = SAMPLES_PER_BUFFER;

4
ports/atmel-samd/common-hal/audioio/AudioOut.c
View File

@ -211,6 +211,10 @@ void common_hal_audioio_audioout_construct(audioio_audioout_obj_t* self,
// Find a free event channel. We start at the highest channels because we only need and async // Find a free event channel. We start at the highest channels because we only need and async
// path. // path.
uint8_t channel = find_async_event_channel(); uint8_t channel = find_async_event_channel();
if (channel >= EVSYS_CHANNELS) {
mp_raise_RuntimeError(translate("All event channels in use"));
}
#ifdef SAMD51 #ifdef SAMD51
connect_event_user_to_channel(EVSYS_ID_USER_DAC_START_1, channel); connect_event_user_to_channel(EVSYS_ID_USER_DAC_START_1, channel);
#define EVSYS_ID_USER_DAC_START EVSYS_ID_USER_DAC_START_0 #define EVSYS_ID_USER_DAC_START EVSYS_ID_USER_DAC_START_0

2
ports/atmel-samd/common-hal/busio/SPI.c
View File

@ -129,7 +129,7 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
} }
#endif #endif
if (sercom == NULL) { if (sercom == NULL) {
mp_raise_ValueError("Invalid pins"); mp_raise_ValueError(translate("Invalid pins"));
} }
// Set up SPI clocks on SERCOM. // Set up SPI clocks on SERCOM.

2
ports/atmel-samd/peripherals

@ -1 +1 @@
Subproject commit 1140ff6d7ed413aa1e2f34c5d847dcc41c924bb9 Subproject commit 156279784cb3d22f7f8a8d93b4bb55e2d912a5f8

3
ports/esp8266/common-hal/analogio/AnalogIn.c
View File

@ -33,13 +33,14 @@
#include "py/mphal.h" #include "py/mphal.h"
#include "common-hal/microcontroller/__init__.h" #include "common-hal/microcontroller/__init__.h"
#include "shared-bindings/analogio/AnalogIn.h" #include "shared-bindings/analogio/AnalogIn.h"
#include "supervisor/shared/translate.h"
#include "user_interface.h" #include "user_interface.h"
void common_hal_analogio_analogin_construct(analogio_analogin_obj_t* self, void common_hal_analogio_analogin_construct(analogio_analogin_obj_t* self,
const mcu_pin_obj_t *pin) { const mcu_pin_obj_t *pin) {
if (pin != &pin_TOUT) { if (pin != &pin_TOUT) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Pin %q does not have ADC capabilities", pin->name)); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, translate("Pin %q does not have ADC capabilities"), pin->name));
} }
claim_pin(pin); claim_pin(pin);
} }

7
ports/esp8266/common-hal/analogio/AnalogOut.c
View File

@ -24,18 +24,19 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "shared-bindings/analogio/AnalogOut.h"
#include <stdio.h> #include <stdio.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "shared-bindings/analogio/AnalogOut.h"
void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self, void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self,
const mcu_pin_obj_t *pin) { const mcu_pin_obj_t *pin) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"No hardware support for analog out.")); translate("No hardware support for analog out.")));
} }
bool common_hal_analogio_analogout_deinited(analogio_analogout_obj_t *self) { bool common_hal_analogio_analogout_deinited(analogio_analogout_obj_t *self) {

3
ports/esp8266/common-hal/busio/SPI.c
View File

@ -27,6 +27,7 @@
#include "shared-bindings/microcontroller/__init__.h" #include "shared-bindings/microcontroller/__init__.h"
#include "common-hal/busio/SPI.h" #include "common-hal/busio/SPI.h"
#include "py/nlr.h" #include "py/nlr.h"
#include "supervisor/shared/translate.h"
#include "eagle_soc.h" #include "eagle_soc.h"
#include "ets_alt_task.h" #include "ets_alt_task.h"
@ -68,7 +69,7 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
(mosi == MP_OBJ_TO_PTR(mp_const_none) && miso == &pin_MTDI) || (mosi == MP_OBJ_TO_PTR(mp_const_none) && miso == &pin_MTDI) ||
(mosi == &pin_MTCK && miso == &pin_MTDI))) { (mosi == &pin_MTCK && miso == &pin_MTDI))) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Pins not valid for SPI")); translate("Pins not valid for SPI")));
} }
busio_spi_init_gpio(SPI_CLK_USE_DIV, clock, mosi, miso); busio_spi_init_gpio(SPI_CLK_USE_DIV, clock, mosi, miso);

7
ports/esp8266/common-hal/busio/UART.c
View File

@ -27,6 +27,7 @@
#include "common-hal/microcontroller/__init__.h" #include "common-hal/microcontroller/__init__.h"
#include "shared-bindings/microcontroller/__init__.h" #include "shared-bindings/microcontroller/__init__.h"
#include "shared-bindings/busio/UART.h" #include "shared-bindings/busio/UART.h"
#include "supervisor/shared/translate.h"
#include "ets_sys.h" #include "ets_sys.h"
#include "uart.h" #include "uart.h"
@ -41,7 +42,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
uint8_t bits, uart_parity_t parity, uint8_t stop, uint32_t timeout, uint8_t bits, uart_parity_t parity, uint8_t stop, uint32_t timeout,
uint8_t receiver_buffer_size) { uint8_t receiver_buffer_size) {
if (rx != mp_const_none || tx != &pin_GPIO2) { if (rx != mp_const_none || tx != &pin_GPIO2) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "Only tx supported on UART1 (GPIO2).")); nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, translate("Only tx supported on UART1 (GPIO2).")));
} }
// set baudrate // set baudrate
@ -63,7 +64,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
UartDev.data_bits = UART_EIGHT_BITS; UartDev.data_bits = UART_EIGHT_BITS;
break; break;
default: default:
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid data bits")); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, translate("invalid data bits")));
break; break;
} }
@ -87,7 +88,7 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
UartDev.stop_bits = UART_TWO_STOP_BIT; UartDev.stop_bits = UART_TWO_STOP_BIT;
break; break;
default: default:
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "invalid stop bits")); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, translate("invalid stop bits")));
break; break;
} }

5
ports/esp8266/common-hal/digitalio/DigitalInOut.c
View File

@ -33,6 +33,7 @@
#include "py/mphal.h" #include "py/mphal.h"
#include "shared-bindings/digitalio/DigitalInOut.h" #include "shared-bindings/digitalio/DigitalInOut.h"
#include "supervisor/shared/translate.h"
#include "common-hal/microcontroller/Pin.h" #include "common-hal/microcontroller/Pin.h"
extern volatile bool gpio16_in_use; extern volatile bool gpio16_in_use;
@ -196,7 +197,7 @@ void common_hal_digitalio_digitalinout_set_pull(
digitalio_digitalinout_obj_t* self, digitalio_pull_t pull) { digitalio_digitalinout_obj_t* self, digitalio_pull_t pull) {
if (pull == PULL_DOWN) { if (pull == PULL_DOWN) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"ESP8266 does not support pull down.")); translate("ESP8266 does not support pull down.")));
return; return;
} }
if (self->pin->gpio_number == 16) { if (self->pin->gpio_number == 16) {
@ -206,7 +207,7 @@ void common_hal_digitalio_digitalinout_set_pull(
// raise the exception so the user knows PULL_UP is not available // raise the exception so the user knows PULL_UP is not available
if (pull != PULL_NONE){ if (pull != PULL_NONE){
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"GPIO16 does not support pull up.")); translate("GPIO16 does not support pull up.")));
} }
return; return;
} }

5
ports/esp8266/common-hal/microcontroller/__init__.c
View File

@ -32,6 +32,7 @@
#include "shared-bindings/microcontroller/__init__.h" #include "shared-bindings/microcontroller/__init__.h"
#include "shared-bindings/microcontroller/Pin.h" #include "shared-bindings/microcontroller/Pin.h"
#include "shared-bindings/microcontroller/Processor.h" #include "shared-bindings/microcontroller/Processor.h"
#include "supervisor/shared/translate.h"
#include "eagle_soc.h" #include "eagle_soc.h"
#include "ets_alt_task.h" #include "ets_alt_task.h"
@ -60,9 +61,9 @@ void common_hal_mcu_enable_interrupts() {
void common_hal_mcu_on_next_reset(mcu_runmode_t runmode) { void common_hal_mcu_on_next_reset(mcu_runmode_t runmode) {
if (runmode == RUNMODE_BOOTLOADER) { if (runmode == RUNMODE_BOOTLOADER) {
mp_raise_ValueError("Cannot reset into bootloader because no bootloader is present."); mp_raise_ValueError(translate("Cannot reset into bootloader because no bootloader is present."));
} else if (runmode == RUNMODE_SAFE_MODE) { } else if (runmode == RUNMODE_SAFE_MODE) {
mp_raise_ValueError("ESP8226 does not support safe mode."); mp_raise_ValueError(translate("ESP8226 does not support safe mode."));
} }
} }

13
ports/esp8266/common-hal/pulseio/PWMOut.c
View File

@ -31,6 +31,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "shared-bindings/pulseio/PWMOut.h" #include "shared-bindings/pulseio/PWMOut.h"
#include "supervisor/shared/translate.h"
#include "eagle_soc.h" #include "eagle_soc.h"
#include "c_types.h" #include "c_types.h"
@ -50,10 +51,10 @@ void common_hal_pulseio_pwmout_construct(pulseio_pwmout_obj_t* self, const mcu_p
bool variable_frequency) { bool variable_frequency) {
if (frequency > PWM_FREQ_MAX) { if (frequency > PWM_FREQ_MAX) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Maximum PWM frequency is %dhz.", PWM_FREQ_MAX)); translate("Maximum PWM frequency is %dhz."), PWM_FREQ_MAX));
} else if (frequency < 1) { } else if (frequency < 1) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"Minimum PWM frequency is 1hz.")); translate("Minimum PWM frequency is 1hz.")));
} }
// start the PWM subsystem if it's not already running // start the PWM subsystem if it's not already running
@ -64,7 +65,7 @@ void common_hal_pulseio_pwmout_construct(pulseio_pwmout_obj_t* self, const mcu_p
first_channel_variable = variable_frequency; first_channel_variable = variable_frequency;
} else if (first_channel_variable || pwm_get_freq(0) != frequency) { } else if (first_channel_variable || pwm_get_freq(0) != frequency) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Multiple PWM frequencies not supported. PWM already set to %dhz.", pwm_get_freq(0))); translate("Multiple PWM frequencies not supported. PWM already set to %dhz."), pwm_get_freq(0)));
} }
self->channel = pwm_add(pin->gpio_number, self->channel = pwm_add(pin->gpio_number,
@ -73,7 +74,7 @@ void common_hal_pulseio_pwmout_construct(pulseio_pwmout_obj_t* self, const mcu_p
self->pin = pin; self->pin = pin;
if (self->channel == -1) { if (self->channel == -1) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"PWM not supported on pin %d", pin->gpio_number)); translate("PWM not supported on pin %d"), pin->gpio_number));
} }
} }
@ -109,10 +110,10 @@ uint16_t common_hal_pulseio_pwmout_get_duty_cycle(pulseio_pwmout_obj_t* self) {
void common_hal_pulseio_pwmout_set_frequency(pulseio_pwmout_obj_t* self, uint32_t frequency) { void common_hal_pulseio_pwmout_set_frequency(pulseio_pwmout_obj_t* self, uint32_t frequency) {
if (frequency > PWM_FREQ_MAX) { if (frequency > PWM_FREQ_MAX) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Maximum PWM frequency is %dhz.", PWM_FREQ_MAX)); translate("Maximum PWM frequency is %dhz."), PWM_FREQ_MAX));
} else if (frequency < 1) { } else if (frequency < 1) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"Minimum PWM frequency is 1hz.")); translate("Minimum PWM frequency is 1hz.")));
} }
pwm_set_freq(frequency, 0); pwm_set_freq(frequency, 0);
} }

9
ports/esp8266/common-hal/pulseio/PulseIn.c
View File

@ -35,6 +35,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "shared-bindings/microcontroller/__init__.h" #include "shared-bindings/microcontroller/__init__.h"
#include "shared-bindings/pulseio/PulseIn.h" #include "shared-bindings/pulseio/PulseIn.h"
#include "supervisor/shared/translate.h"
#include "common-hal/microcontroller/__init__.h" #include "common-hal/microcontroller/__init__.h"
static void pulsein_set_interrupt(pulseio_pulsein_obj_t *self, bool rising, bool falling) { static void pulsein_set_interrupt(pulseio_pulsein_obj_t *self, bool rising, bool falling) {
@ -74,7 +75,7 @@ void pulseio_pulsein_interrupt_handler(void *data) {
void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self, void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self,
const mcu_pin_obj_t* pin, uint16_t maxlen, bool idle_state) { const mcu_pin_obj_t* pin, uint16_t maxlen, bool idle_state) {
if (pin->gpio_number == NO_GPIO || pin->gpio_function == SPECIAL_CASE) { if (pin->gpio_number == NO_GPIO || pin->gpio_function == SPECIAL_CASE) {
mp_raise_msg_varg(&mp_type_ValueError, "No PulseIn support for %q", pin->name ); mp_raise_msg_varg(&mp_type_ValueError, translate("No PulseIn support for %q"), pin->name );
} }
PIN_FUNC_SELECT(pin->peripheral, pin->gpio_function); PIN_FUNC_SELECT(pin->peripheral, pin->gpio_function);
PIN_PULLUP_DIS(pin->peripheral); PIN_PULLUP_DIS(pin->peripheral);
@ -82,7 +83,7 @@ void common_hal_pulseio_pulsein_construct(pulseio_pulsein_obj_t* self,
self->buffer = (uint16_t *) m_malloc(maxlen * sizeof(uint16_t), false); self->buffer = (uint16_t *) m_malloc(maxlen * sizeof(uint16_t), false);
if (self->buffer == NULL) { if (self->buffer == NULL) {
mp_raise_msg_varg(&mp_type_MemoryError, "Failed to allocate RX buffer of %d bytes", maxlen * sizeof(uint16_t)); mp_raise_msg_varg(&mp_type_MemoryError, translate("Failed to allocate RX buffer of %d bytes"), maxlen * sizeof(uint16_t));
} }
self->maxlen = maxlen; self->maxlen = maxlen;
@ -147,7 +148,7 @@ void common_hal_pulseio_pulsein_clear(pulseio_pulsein_obj_t* self) {
uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) { uint16_t common_hal_pulseio_pulsein_popleft(pulseio_pulsein_obj_t* self) {
if (self->len == 0) { if (self->len == 0) {
mp_raise_IndexError("pop from an empty PulseIn"); mp_raise_IndexError(translate("pop from an empty PulseIn"));
} }
common_hal_mcu_disable_interrupts(); common_hal_mcu_disable_interrupts();
uint16_t value = self->buffer[self->start]; uint16_t value = self->buffer[self->start];
@ -178,7 +179,7 @@ uint16_t common_hal_pulseio_pulsein_get_item(pulseio_pulsein_obj_t* self,
} }
if (index < 0 || index >= self->len) { if (index < 0 || index >= self->len) {
common_hal_mcu_enable_interrupts(); common_hal_mcu_enable_interrupts();
mp_raise_IndexError("index out of range"); mp_raise_IndexError(translate("index out of range"));
} }
uint16_t value = self->buffer[(self->start + index) % self->maxlen]; uint16_t value = self->buffer[(self->start + index) % self->maxlen];
common_hal_mcu_enable_interrupts(); common_hal_mcu_enable_interrupts();

5
ports/esp8266/common-hal/storage/__init__.c
View File

@ -28,11 +28,12 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "shared-bindings/storage/__init__.h" #include "shared-bindings/storage/__init__.h"
#include "supervisor/shared/translate.h"
void common_hal_storage_remount(const char* mount_path, bool readonly) { void common_hal_storage_remount(const char* mount_path, bool readonly) {
mp_raise_NotImplementedError(""); mp_raise_NotImplementedError(translate("Unable to remount filesystem"));
} }
void common_hal_storage_erase_filesystem() { void common_hal_storage_erase_filesystem() {
mp_raise_NotImplementedError("Use esptool to erase flash and re-upload Python instead"); mp_raise_NotImplementedError(translate("Use esptool to erase flash and re-upload Python instead"));
} }

2
ports/esp8266/esp8266.ld
View File

@ -5,7 +5,7 @@ MEMORY
dport0_0_seg : org = 0x3ff00000, len = 0x10 dport0_0_seg : org = 0x3ff00000, len = 0x10
dram0_0_seg : org = 0x3ffe8000, len = 0x14000 dram0_0_seg : org = 0x3ffe8000, len = 0x14000
iram1_0_seg : org = 0x40100000, len = 0x8000 iram1_0_seg : org = 0x40100000, len = 0x8000
irom0_0_seg : org = 0x40209000, len = 0x8f000 irom0_0_seg : org = 0x40209000, len = 0x91000
} }
/* define common sections and symbols */ /* define common sections and symbols */

3
ports/esp8266/esp_mphal.c
View File

@ -34,6 +34,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "extmod/misc.h" #include "extmod/misc.h"
#include "lib/utils/pyexec.h" #include "lib/utils/pyexec.h"
#include "supervisor/shared/translate.h"
STATIC byte input_buf_array[256]; STATIC byte input_buf_array[256];
ringbuf_t stdin_ringbuf = {input_buf_array, sizeof(input_buf_array)}; ringbuf_t stdin_ringbuf = {input_buf_array, sizeof(input_buf_array)};
@ -150,7 +151,7 @@ void ets_event_poll(void) {
void __assert_func(const char *file, int line, const char *func, const char *expr) { void __assert_func(const char *file, int line, const char *func, const char *expr) {
printf("assert:%s:%d:%s: %s\n", file, line, func, expr); printf("assert:%s:%d:%s: %s\n", file, line, func, expr);
nlr_raise(mp_obj_new_exception_msg(&mp_type_AssertionError, nlr_raise(mp_obj_new_exception_msg(&mp_type_AssertionError,
"C-level assert")); translate("C-level assert")));
} }
void mp_hal_signal_input(void) { void mp_hal_signal_input(void) {

3
ports/esp8266/machine_adc.c
View File

@ -28,6 +28,7 @@
#include <string.h> #include <string.h>
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "user_interface.h" #include "user_interface.h"
const mp_obj_type_t pyb_adc_type; const mp_obj_type_t pyb_adc_type;
@ -53,7 +54,7 @@ STATIC mp_obj_t pyb_adc_make_new(const mp_obj_type_t *type_in, size_t n_args, si
return &pyb_adc_vdd3; return &pyb_adc_vdd3;
default: default:
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"not a valid ADC Channel: %d", chn)); translate("not a valid ADC Channel: %d"), chn));
} }
} }

5
ports/esp8266/machine_hspi.c
View File

@ -37,6 +37,7 @@
#include "py/mphal.h" #include "py/mphal.h"
#include "extmod/machine_spi.h" #include "extmod/machine_spi.h"
#include "modmachine.h" #include "modmachine.h"
#include "supervisor/shared/translate.h"
#include "hspi.h" #include "hspi.h"
#if MICROPY_PY_MACHINE_SPI #if MICROPY_PY_MACHINE_SPI
@ -127,13 +128,13 @@ STATIC void machine_hspi_init(mp_obj_base_t *self_in, size_t n_args, const mp_ob
spi_init_gpio(HSPI, SPI_CLK_80MHZ_NODIV); spi_init_gpio(HSPI, SPI_CLK_80MHZ_NODIV);
spi_clock(HSPI, 0, 0); spi_clock(HSPI, 0, 0);
} else if (self->baudrate > 40000000L) { } else if (self->baudrate > 40000000L) {
mp_raise_ValueError("impossible baudrate"); mp_raise_ValueError(translate("impossible baudrate"));
} else { } else {
uint32_t divider = 40000000L / self->baudrate; uint32_t divider = 40000000L / self->baudrate;
uint16_t prediv = MIN(divider, SPI_CLKDIV_PRE + 1); uint16_t prediv = MIN(divider, SPI_CLKDIV_PRE + 1);
uint16_t cntdiv = (divider / prediv) * 2; // cntdiv has to be even uint16_t cntdiv = (divider / prediv) * 2; // cntdiv has to be even
if (cntdiv > SPI_CLKCNT_N + 1 || cntdiv == 0 || prediv == 0) { if (cntdiv > SPI_CLKCNT_N + 1 || cntdiv == 0 || prediv == 0) {
mp_raise_ValueError("impossible baudrate"); mp_raise_ValueError(translate("impossible baudrate"));
} }
self->baudrate = 80000000L / (prediv * cntdiv); self->baudrate = 80000000L / (prediv * cntdiv);
spi_init_gpio(HSPI, SPI_CLK_USE_DIV); spi_init_gpio(HSPI, SPI_CLK_USE_DIV);

10
ports/esp8266/machine_pin.c
View File

@ -39,6 +39,8 @@
#include "extmod/virtpin.h" #include "extmod/virtpin.h"
#include "modmachine.h" #include "modmachine.h"
#include "supervisor/shared/translate.h"
#define GET_TRIGGER(phys_port) \ #define GET_TRIGGER(phys_port) \
GPIO_PIN_INT_TYPE_GET(GPIO_REG_READ(GPIO_PIN_ADDR(phys_port))) GPIO_PIN_INT_TYPE_GET(GPIO_REG_READ(GPIO_PIN_ADDR(phys_port)))
#define SET_TRIGGER(phys_port, trig) \ #define SET_TRIGGER(phys_port, trig) \
@ -124,7 +126,7 @@ void pin_intr_handler(uint32_t status) {
pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in) { pyb_pin_obj_t *mp_obj_get_pin_obj(mp_obj_t pin_in) {
if (mp_obj_get_type(pin_in) != &pyb_pin_type) { if (mp_obj_get_type(pin_in) != &pyb_pin_type) {
mp_raise_ValueError("expecting a pin"); mp_raise_ValueError(translate("expecting a pin"));
} }
pyb_pin_obj_t *self = pin_in; pyb_pin_obj_t *self = pin_in;
return self; return self;
@ -279,7 +281,7 @@ STATIC mp_obj_t pyb_pin_obj_init_helper(pyb_pin_obj_t *self, size_t n_args, cons
// only pull-down seems to be supported by the hardware, and // only pull-down seems to be supported by the hardware, and
// we only expose pull-up behaviour in software // we only expose pull-up behaviour in software
if (pull != GPIO_PULL_NONE) { if (pull != GPIO_PULL_NONE) {
mp_raise_ValueError("Pin(16) doesn't support pull"); mp_raise_ValueError(translate("Pin(16) doesn't support pull"));
} }
} else { } else {
PIN_FUNC_SELECT(self->periph, self->func); PIN_FUNC_SELECT(self->periph, self->func);
@ -318,7 +320,7 @@ mp_obj_t mp_pin_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw,
pin = (pyb_pin_obj_t*)&pyb_pin_obj[wanted_pin]; pin = (pyb_pin_obj_t*)&pyb_pin_obj[wanted_pin];
} }
if (pin == NULL || pin->base.type == NULL) { if (pin == NULL || pin->base.type == NULL) {
mp_raise_ValueError("invalid pin"); mp_raise_ValueError(translate("invalid pin"));
} }
if (n_args > 1 || n_kw > 0) { if (n_args > 1 || n_kw > 0) {
@ -384,7 +386,7 @@ STATIC mp_obj_t pyb_pin_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args); mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
if (self->phys_port >= 16) { if (self->phys_port >= 16) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "pin does not have IRQ capabilities")); nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, translate("pin does not have IRQ capabilities")));
} }
if (n_args > 1 || kw_args->used != 0) { if (n_args > 1 || kw_args->used != 0) {

3
ports/esp8266/machine_pwm.c
View File

@ -31,6 +31,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "modmachine.h" #include "modmachine.h"
#include "supervisor/shared/translate.h"
typedef struct _pyb_pwm_obj_t { typedef struct _pyb_pwm_obj_t {
mp_obj_base_t base; mp_obj_base_t base;
@ -66,7 +67,7 @@ STATIC void pyb_pwm_init_helper(pyb_pwm_obj_t *self, size_t n_args, const mp_obj
int channel = pwm_add(self->pin->phys_port, self->pin->periph, self->pin->func); int channel = pwm_add(self->pin->phys_port, self->pin->periph, self->pin->func);
if (channel == -1) { if (channel == -1) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"PWM not supported on pin %d", self->pin->phys_port)); translate("PWM not supported on pin %d"), self->pin->phys_port));
} }
self->channel = channel; self->channel = channel;

9
ports/esp8266/machine_rtc.c
View File

@ -29,6 +29,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "lib/timeutils/timeutils.h" #include "lib/timeutils/timeutils.h"
#include "supervisor/shared/translate.h"
#include "user_interface.h" #include "user_interface.h"
#include "modmachine.h" #include "modmachine.h"
@ -181,7 +182,7 @@ STATIC mp_obj_t pyb_rtc_memory(size_t n_args, const mp_obj_t *args) {
mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ); mp_get_buffer_raise(args[1], &bufinfo, MP_BUFFER_READ);
if (bufinfo.len > MEM_USER_MAXLEN) { if (bufinfo.len > MEM_USER_MAXLEN) {
mp_raise_ValueError("buffer too long"); mp_raise_ValueError(translate("buffer too long"));
} }
len = bufinfo.len; len = bufinfo.len;
@ -205,7 +206,7 @@ STATIC mp_obj_t pyb_rtc_alarm(mp_obj_t self_in, mp_obj_t alarm_id, mp_obj_t time
// check we want alarm0 // check we want alarm0
if (mp_obj_get_int(alarm_id) != 0) { if (mp_obj_get_int(alarm_id) != 0) {
mp_raise_ValueError("invalid alarm"); mp_raise_ValueError(translate("invalid alarm"));
} }
// set expiry time (in microseconds) // set expiry time (in microseconds)
@ -219,7 +220,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_3(pyb_rtc_alarm_obj, pyb_rtc_alarm);
STATIC mp_obj_t pyb_rtc_alarm_left(size_t n_args, const mp_obj_t *args) { STATIC mp_obj_t pyb_rtc_alarm_left(size_t n_args, const mp_obj_t *args) {
// check we want alarm0 // check we want alarm0
if (n_args > 1 && mp_obj_get_int(args[1]) != 0) { if (n_args > 1 && mp_obj_get_int(args[1]) != 0) {
mp_raise_ValueError("invalid alarm"); mp_raise_ValueError(translate("invalid alarm"));
} }
uint64_t now = pyb_rtc_get_us_since_2000(); uint64_t now = pyb_rtc_get_us_since_2000();
@ -242,7 +243,7 @@ STATIC mp_obj_t pyb_rtc_irq(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
// check we want alarm0 // check we want alarm0
if (args[ARG_trigger].u_int != 0) { if (args[ARG_trigger].u_int != 0) {
mp_raise_ValueError("invalid alarm"); mp_raise_ValueError(translate("invalid alarm"));
} }
// set the wake value // set the wake value

9
ports/esp8266/machine_uart.c
View File

@ -34,6 +34,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/stream.h" #include "py/stream.h"
#include "py/mperrno.h" #include "py/mperrno.h"
#include "supervisor/shared/translate.h"
#include "modmachine.h" #include "modmachine.h"
// UartDev is defined and initialized in rom code. // UartDev is defined and initialized in rom code.
@ -104,7 +105,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
self->bits = 8; self->bits = 8;
break; break;
default: default:
mp_raise_ValueError("invalid data bits"); mp_raise_ValueError(translate("invalid data bits"));
break; break;
} }
@ -140,7 +141,7 @@ STATIC void pyb_uart_init_helper(pyb_uart_obj_t *self, size_t n_args, const mp_o
self->stop = 2; self->stop = 2;
break; break;
default: default:
mp_raise_ValueError("invalid stop bits"); mp_raise_ValueError(translate("invalid stop bits"));
break; break;
} }
@ -165,7 +166,7 @@ STATIC mp_obj_t pyb_uart_make_new(const mp_obj_type_t *type, size_t n_args, size
// get uart id // get uart id
mp_int_t uart_id = mp_obj_get_int(args[0]); mp_int_t uart_id = mp_obj_get_int(args[0]);
if (uart_id != 0 && uart_id != 1) { if (uart_id != 0 && uart_id != 1) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "UART(%d) does not exist", uart_id)); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, translate("UART(%d) does not exist"), uart_id));
} }
// create instance // create instance
@ -215,7 +216,7 @@ STATIC mp_uint_t pyb_uart_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, i
pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in); pyb_uart_obj_t *self = MP_OBJ_TO_PTR(self_in);
if (self->uart_id == 1) { if (self->uart_id == 1) {
mp_raise_msg(&mp_type_OSError, "UART(1) can't read"); mp_raise_msg(&mp_type_OSError, translate("UART(1) can't read"));
} }
// make sure we want at least 1 char // make sure we want at least 1 char

1
ports/esp8266/makeimg.py
View File

@ -21,6 +21,7 @@ with open(sys.argv[3], 'wb') as fout:
with open(sys.argv[2], 'rb') as f: with open(sys.argv[2], 'rb') as f:
data_rom = f.read() data_rom = f.read()
print(SEGS_MAX_SIZE, len(data_flash))
pad = b'\xff' * (SEGS_MAX_SIZE - len(data_flash)) pad = b'\xff' * (SEGS_MAX_SIZE - len(data_flash))
assert len(pad) >= 4 assert len(pad) >= 4
fout.write(pad[:-4]) fout.write(pad[:-4])

9
ports/esp8266/modesp.c
View File

@ -30,6 +30,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/mperrno.h" #include "py/mperrno.h"
#include "py/mphal.h" #include "py/mphal.h"
#include "supervisor/shared/translate.h"
#include "uart.h" #include "uart.h"
#include "user_interface.h" #include "user_interface.h"
#include "mem.h" #include "mem.h"
@ -37,7 +38,7 @@
#define MODESP_INCLUDE_CONSTANTS (1) #define MODESP_INCLUDE_CONSTANTS (1)
void error_check(bool status, const char *msg) { void error_check(bool status, const compressed_string_t *msg) {
if (!status) { if (!status) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, msg)); nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, msg));
} }
@ -115,7 +116,7 @@ STATIC mp_obj_t esp_flash_write(mp_obj_t offset_in, const mp_obj_t buf_in) {
mp_buffer_info_t bufinfo; mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ); mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len & 0x3) { if (bufinfo.len & 0x3) {
mp_raise_ValueError("len must be multiple of 4"); mp_raise_ValueError(translate("len must be multiple of 4"));
} }
SpiFlashOpResult res = spi_flash_write(offset, bufinfo.buf, bufinfo.len); SpiFlashOpResult res = spi_flash_write(offset, bufinfo.buf, bufinfo.len);
if (res == SPI_FLASH_RESULT_OK) { if (res == SPI_FLASH_RESULT_OK) {
@ -270,7 +271,7 @@ void *esp_native_code_commit(void *buf, size_t len) {
len = (len + 3) & ~3; len = (len + 3) & ~3;
if (esp_native_code_cur + len > esp_native_code_end) { if (esp_native_code_cur + len > esp_native_code_end) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_MemoryError,
"memory allocation failed, allocating %u bytes for native code", (uint)len)); translate("memory allocation failed, allocating %u bytes for native code"), (uint)len));
} }
void *dest; void *dest;
@ -313,7 +314,7 @@ STATIC mp_obj_t esp_set_native_code_location(mp_obj_t start_in, mp_obj_t len_in)
esp_native_code_erased = esp_native_code_start; esp_native_code_erased = esp_native_code_start;
// memory-mapped flash is limited in extents to 1MByte // memory-mapped flash is limited in extents to 1MByte
if (esp_native_code_end > FLASH_END - FLASH_START) { if (esp_native_code_end > FLASH_END - FLASH_START) {
mp_raise_ValueError("flash location must be below 1MByte"); mp_raise_ValueError(translate("flash location must be below 1MByte"));
} }
} }
return mp_const_none; return mp_const_none;

3
ports/esp8266/modmachine.c
View File

@ -35,6 +35,7 @@
#include "extmod/machine_pulse.h" #include "extmod/machine_pulse.h"
#include "extmod/machine_i2c.h" #include "extmod/machine_i2c.h"
#include "modmachine.h" #include "modmachine.h"
#include "supervisor/shared/translate.h"
#include "xtirq.h" #include "xtirq.h"
#include "os_type.h" #include "os_type.h"
@ -59,7 +60,7 @@ STATIC mp_obj_t machine_freq(size_t n_args, const mp_obj_t *args) {
// set // set
mp_int_t freq = mp_obj_get_int(args[0]) / 1000000; mp_int_t freq = mp_obj_get_int(args[0]) / 1000000;
if (freq != 80 && freq != 160) { if (freq != 80 && freq != 160) {
mp_raise_ValueError("frequency can only be either 80Mhz or 160MHz"); mp_raise_ValueError(translate("frequency can only be either 80Mhz or 160MHz"));
} }
system_update_cpu_freq(freq); system_update_cpu_freq(freq);
return mp_const_none; return mp_const_none;

37
ports/esp8266/modnetwork.c
View File

@ -32,6 +32,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/mphal.h" #include "py/mphal.h"
#include "lib/netutils/netutils.h" #include "lib/netutils/netutils.h"
#include "supervisor/shared/translate.h"
#include "queue.h" #include "queue.h"
#include "user_interface.h" #include "user_interface.h"
#include "espconn.h" #include "espconn.h"
@ -46,7 +47,7 @@ typedef struct _wlan_if_obj_t {
int if_id; int if_id;
} wlan_if_obj_t; } wlan_if_obj_t;
void error_check(bool status, const char *msg); void error_check(bool status, const compressed_string_t *msg);
const mp_obj_type_t wlan_if_type; const mp_obj_type_t wlan_if_type;
STATIC const wlan_if_obj_t wlan_objs[] = { STATIC const wlan_if_obj_t wlan_objs[] = {
@ -57,7 +58,7 @@ STATIC const wlan_if_obj_t wlan_objs[] = {
STATIC void require_if(mp_obj_t wlan_if, int if_no) { STATIC void require_if(mp_obj_t wlan_if, int if_no) {
wlan_if_obj_t *self = MP_OBJ_TO_PTR(wlan_if); wlan_if_obj_t *self = MP_OBJ_TO_PTR(wlan_if);
if (self->if_id != if_no) { if (self->if_id != if_no) {
error_check(false, if_no == STATION_IF ? "STA required" : "AP required"); error_check(false, if_no == STATION_IF ? translate("STA required") : translate("AP required"));
} }
} }
@ -83,7 +84,7 @@ STATIC mp_obj_t esp_active(size_t n_args, const mp_obj_t *args) {
} else { } else {
mode &= ~mask; mode &= ~mask;
} }
error_check(wifi_set_opmode(mode), "Cannot update i/f status"); error_check(wifi_set_opmode(mode), translate("Cannot update i/f status"));
return mp_const_none; return mp_const_none;
} }
@ -138,9 +139,9 @@ STATIC mp_obj_t esp_connect(size_t n_args, const mp_obj_t *pos_args, mp_map_t *k
} }
if (set_config) { if (set_config) {
error_check(wifi_station_set_config(&config), "Cannot set STA config"); error_check(wifi_station_set_config(&config), translate("Cannot set STA config"));
} }
error_check(wifi_station_connect(), "Cannot connect to AP"); error_check(wifi_station_connect(), translate("Cannot connect to AP"));
return mp_const_none; return mp_const_none;
} }
@ -148,7 +149,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_connect_obj, 1, esp_connect);
STATIC mp_obj_t esp_disconnect(mp_obj_t self_in) { STATIC mp_obj_t esp_disconnect(mp_obj_t self_in) {
require_if(self_in, STATION_IF); require_if(self_in, STATION_IF);
error_check(wifi_station_disconnect(), "Cannot disconnect from AP"); error_check(wifi_station_disconnect(), translate("Cannot disconnect from AP"));
return mp_const_none; return mp_const_none;
} }
STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_disconnect_obj, esp_disconnect); STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_disconnect_obj, esp_disconnect);
@ -169,7 +170,7 @@ STATIC mp_obj_t esp_status(size_t n_args, const mp_obj_t *args) {
return MP_OBJ_NEW_SMALL_INT(wifi_station_get_rssi()); return MP_OBJ_NEW_SMALL_INT(wifi_station_get_rssi());
} }
} }
mp_raise_ValueError("unknown status param"); mp_raise_ValueError(translate("unknown status param"));
} }
} }
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_status_obj, 1, 2, esp_status); STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_status_obj, 1, 2, esp_status);
@ -218,7 +219,7 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
require_if(self_in, STATION_IF); require_if(self_in, STATION_IF);
if ((wifi_get_opmode() & STATION_MODE) == 0) { if ((wifi_get_opmode() & STATION_MODE) == 0) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"STA must be active")); translate("STA must be active")));
} }
mp_obj_t list = mp_obj_new_list(0, NULL); mp_obj_t list = mp_obj_new_list(0, NULL);
esp_scan_list = &list; esp_scan_list = &list;
@ -235,7 +236,7 @@ STATIC mp_obj_t esp_scan(mp_obj_t self_in) {
ets_loop_iter(); ets_loop_iter();
} }
if (list == MP_OBJ_NULL) { if (list == MP_OBJ_NULL) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, "scan failed")); nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, translate("scan failed")));
} }
return list; return list;
} }
@ -302,7 +303,7 @@ STATIC mp_obj_t esp_ifconfig(size_t n_args, const mp_obj_t *args) {
} }
if (!wifi_set_ip_info(self->if_id, &info)) { if (!wifi_set_ip_info(self->if_id, &info)) {
nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
"wifi_set_ip_info() failed")); translate("wifi_set_ip_info() failed")));
} }
dns_setserver(0, &dns_addr); dns_setserver(0, &dns_addr);
if (restart_dhcp_server) { if (restart_dhcp_server) {
@ -315,7 +316,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(esp_ifconfig_obj, 1, 2, esp_ifconfig)
STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) { STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
if (n_args != 1 && kwargs->used != 0) { if (n_args != 1 && kwargs->used != 0) {
mp_raise_TypeError("either pos or kw args are allowed"); mp_raise_TypeError(translate("either pos or kw args are allowed"));
} }
wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]); wlan_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
@ -325,9 +326,9 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
} cfg; } cfg;
if (self->if_id == STATION_IF) { if (self->if_id == STATION_IF) {
error_check(wifi_station_get_config(&cfg.sta), "can't get STA config"); error_check(wifi_station_get_config(&cfg.sta), translate("can't get STA config"));
} else { } else {
error_check(wifi_softap_get_config(&cfg.ap), "can't get AP config"); error_check(wifi_softap_get_config(&cfg.ap), translate("can't get AP config"));
} }
int req_if = -1; int req_if = -1;
@ -342,7 +343,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
mp_buffer_info_t bufinfo; mp_buffer_info_t bufinfo;
mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ); mp_get_buffer_raise(kwargs->table[i].value, &bufinfo, MP_BUFFER_READ);
if (bufinfo.len != 6) { if (bufinfo.len != 6) {
mp_raise_ValueError("invalid buffer length"); mp_raise_ValueError(translate("invalid buffer length"));
} }
wifi_set_macaddr(self->if_id, bufinfo.buf); wifi_set_macaddr(self->if_id, bufinfo.buf);
break; break;
@ -401,9 +402,9 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
} }
if (self->if_id == STATION_IF) { if (self->if_id == STATION_IF) {
error_check(wifi_station_set_config(&cfg.sta), "can't set STA config"); error_check(wifi_station_set_config(&cfg.sta), translate("can't set STA config"));
} else { } else {
error_check(wifi_softap_set_config(&cfg.ap), "can't set AP config"); error_check(wifi_softap_set_config(&cfg.ap), translate("can't set AP config"));
} }
return mp_const_none; return mp_const_none;
@ -412,7 +413,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
// Get config // Get config
if (n_args != 2) { if (n_args != 2) {
mp_raise_TypeError("can query only one param"); mp_raise_TypeError(translate("can query only one param"));
} }
mp_obj_t val; mp_obj_t val;
@ -465,7 +466,7 @@ STATIC mp_obj_t esp_config(size_t n_args, const mp_obj_t *args, mp_map_t *kwargs
return val; return val;
unknown: unknown:
mp_raise_ValueError("unknown config param"); mp_raise_ValueError(translate("unknown config param"));
} }
STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config); STATIC MP_DEFINE_CONST_FUN_OBJ_KW(esp_config_obj, 1, esp_config);

3
ports/nrf/common-hal/analogio/AnalogIn.c
View File

@ -27,6 +27,7 @@
#include "common-hal/analogio/AnalogIn.h" #include "common-hal/analogio/AnalogIn.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "nrfx_saadc.h" #include "nrfx_saadc.h"
#include "nrf_gpio.h" #include "nrf_gpio.h"
@ -35,7 +36,7 @@
void common_hal_analogio_analogin_construct(analogio_analogin_obj_t *self, const mcu_pin_obj_t *pin) { void common_hal_analogio_analogin_construct(analogio_analogin_obj_t *self, const mcu_pin_obj_t *pin) {
if (pin->adc_channel == 0) if (pin->adc_channel == 0)
mp_raise_ValueError("Pin does not have ADC capabilities"); mp_raise_ValueError(translate("Pin does not have ADC capabilities"));
nrf_gpio_cfg_default(NRF_GPIO_PIN_MAP(pin->port, pin->pin)); nrf_gpio_cfg_default(NRF_GPIO_PIN_MAP(pin->port, pin->pin));

8
ports/nrf/common-hal/analogio/AnalogOut.c
View File

@ -24,17 +24,17 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "shared-bindings/analogio/AnalogOut.h"
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include "py/mperrno.h" #include "py/mperrno.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "shared-bindings/analogio/AnalogOut.h"
void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self, const mcu_pin_obj_t *pin) { void common_hal_analogio_analogout_construct(analogio_analogout_obj_t* self, const mcu_pin_obj_t *pin) {
mp_raise_RuntimeError("AnalogOut functionality not supported"); mp_raise_RuntimeError(translate("AnalogOut functionality not supported"));
} }
bool common_hal_analogio_analogout_deinited(analogio_analogout_obj_t *self) { bool common_hal_analogio_analogout_deinited(analogio_analogout_obj_t *self) {

3
ports/nrf/common-hal/busio/I2C.c
View File

@ -29,6 +29,7 @@
#include "shared-bindings/busio/I2C.h" #include "shared-bindings/busio/I2C.h"
#include "py/mperrno.h" #include "py/mperrno.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "nrfx_twim.h" #include "nrfx_twim.h"
#include "nrf_gpio.h" #include "nrf_gpio.h"
@ -54,7 +55,7 @@ static uint8_t twi_error_to_mp(const nrfx_err_t err) {
void common_hal_busio_i2c_construct(busio_i2c_obj_t *self, const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda, uint32_t frequency, uint32_t timeout) { void common_hal_busio_i2c_construct(busio_i2c_obj_t *self, const mcu_pin_obj_t *scl, const mcu_pin_obj_t *sda, uint32_t frequency, uint32_t timeout) {
if (scl->pin == sda->pin) if (scl->pin == sda->pin)
mp_raise_ValueError("Invalid pins"); mp_raise_ValueError(translate("Invalid pins"));
const nrfx_twim_t instance = NRFX_TWIM_INSTANCE(INST_NO); const nrfx_twim_t instance = NRFX_TWIM_INSTANCE(INST_NO);
self->twim = instance; self->twim = instance;

19
ports/nrf/common-hal/busio/UART.c
View File

@ -32,6 +32,7 @@
#include "py/mperrno.h" #include "py/mperrno.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "py/stream.h" #include "py/stream.h"
#include "supervisor/shared/translate.h"
#include "tick.h" #include "tick.h"
@ -41,15 +42,15 @@ void common_hal_busio_uart_construct(busio_uart_obj_t *self,
const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx, uint32_t baudrate, const mcu_pin_obj_t * tx, const mcu_pin_obj_t * rx, uint32_t baudrate,
uint8_t bits, uart_parity_t parity, uint8_t stop, uint32_t timeout, uint8_t bits, uart_parity_t parity, uint8_t stop, uint32_t timeout,
uint8_t receiver_buffer_size) { uint8_t receiver_buffer_size) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
} }
bool common_hal_busio_uart_deinited(busio_uart_obj_t *self) { bool common_hal_busio_uart_deinited(busio_uart_obj_t *self) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
} }
void common_hal_busio_uart_deinit(busio_uart_obj_t *self) { void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
if (common_hal_busio_uart_deinited(self)) { if (common_hal_busio_uart_deinited(self)) {
return; return;
} }
@ -58,32 +59,32 @@ void common_hal_busio_uart_deinit(busio_uart_obj_t *self) {
// Read characters. // Read characters.
size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t len, int *errcode) { size_t common_hal_busio_uart_read(busio_uart_obj_t *self, uint8_t *data, size_t len, int *errcode) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
return 0; return 0;
} }
// Write characters. // Write characters.
size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data, size_t len, int *errcode) { size_t common_hal_busio_uart_write(busio_uart_obj_t *self, const uint8_t *data, size_t len, int *errcode) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
return 0; return 0;
} }
uint32_t common_hal_busio_uart_get_baudrate(busio_uart_obj_t *self) { uint32_t common_hal_busio_uart_get_baudrate(busio_uart_obj_t *self) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
return self->baudrate; return self->baudrate;
} }
void common_hal_busio_uart_set_baudrate(busio_uart_obj_t *self, uint32_t baudrate) { void common_hal_busio_uart_set_baudrate(busio_uart_obj_t *self, uint32_t baudrate) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
self->baudrate = baudrate; self->baudrate = baudrate;
} }
uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *self) { uint32_t common_hal_busio_uart_rx_characters_available(busio_uart_obj_t *self) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
return 0; return 0;
} }
bool common_hal_busio_uart_ready_to_tx(busio_uart_obj_t *self) { bool common_hal_busio_uart_ready_to_tx(busio_uart_obj_t *self) {
mp_raise_NotImplementedError("busio.UART not yet implemented"); mp_raise_NotImplementedError(translate("busio.UART not yet implemented"));
return false; return false;
} }

3
ports/nrf/common-hal/digitalio/DigitalInOut.c
View File

@ -26,6 +26,7 @@
#include "shared-bindings/digitalio/DigitalInOut.h" #include "shared-bindings/digitalio/DigitalInOut.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "nrf_gpio.h" #include "nrf_gpio.h"
@ -154,7 +155,7 @@ digitalio_pull_t common_hal_digitalio_digitalinout_get_pull(
NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin); NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
if (nrf_gpio_pin_dir_get(pin) == NRF_GPIO_PIN_DIR_OUTPUT) { if (nrf_gpio_pin_dir_get(pin) == NRF_GPIO_PIN_DIR_OUTPUT) {
mp_raise_AttributeError("Cannot get pull while in output mode"); mp_raise_AttributeError(translate("Cannot get pull while in output mode"));
return PULL_NONE; return PULL_NONE;
} }

3
ports/nrf/common-hal/microcontroller/Processor.c
View File

@ -26,6 +26,7 @@
#include "common-hal/microcontroller/Processor.h" #include "common-hal/microcontroller/Processor.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#ifdef BLUETOOTH_SD #ifdef BLUETOOTH_SD
#include "nrf_sdm.h" #include "nrf_sdm.h"
@ -45,7 +46,7 @@ float common_hal_mcu_processor_get_temperature(void) {
uint32_t err_code = sd_temp_get(&temp); uint32_t err_code = sd_temp_get(&temp);
if (err_code != NRF_SUCCESS) { if (err_code != NRF_SUCCESS) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not get temperature. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not get temperature. status: 0x%02x"), (uint16_t)err_code));
return 0; return 0;
} }

4
ports/nrf/common-hal/pulseio/PWMOut.c
View File

@ -32,6 +32,7 @@
#include "common-hal/pulseio/PWMOut.h" #include "common-hal/pulseio/PWMOut.h"
#include "nrf_gpio.h" #include "nrf_gpio.h"
#include "shared-bindings/pulseio/PWMOut.h" #include "shared-bindings/pulseio/PWMOut.h"
#include "supervisor/shared/translate.h"
#define PWM_MAX_MODULE 3 #define PWM_MAX_MODULE 3
#define PWM_MAX_CHANNEL 4 #define PWM_MAX_CHANNEL 4
@ -223,7 +224,7 @@ uint16_t common_hal_pulseio_pwmout_get_duty_cycle(pulseio_pwmout_obj_t* self) {
void common_hal_pulseio_pwmout_set_frequency(pulseio_pwmout_obj_t* self, uint32_t frequency) { void common_hal_pulseio_pwmout_set_frequency(pulseio_pwmout_obj_t* self, uint32_t frequency) {
if (frequency == 0 || frequency > 16000000) { if (frequency == 0 || frequency > 16000000) {
mp_raise_ValueError("Invalid PWM frequency"); mp_raise_ValueError(translate("Invalid PWM frequency"));
} }
self->freq = frequency; self->freq = frequency;
@ -238,4 +239,3 @@ uint32_t common_hal_pulseio_pwmout_get_frequency(pulseio_pwmout_obj_t* self) {
bool common_hal_pulseio_pwmout_get_variable_frequency(pulseio_pwmout_obj_t* self) { bool common_hal_pulseio_pwmout_get_variable_frequency(pulseio_pwmout_obj_t* self) {
return self->variable_freq; return self->variable_freq;
} }

8
ports/nrf/common-hal/usb_hid/Device.c
View File

@ -29,6 +29,7 @@
#include "common-hal/usb_hid/Device.h" #include "common-hal/usb_hid/Device.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "shared-bindings/usb_hid/Device.h" #include "shared-bindings/usb_hid/Device.h"
#include "supervisor/shared/translate.h"
#include "tusb.h" #include "tusb.h"
uint8_t common_hal_usb_hid_device_get_usage_page(usb_hid_device_obj_t *self) { uint8_t common_hal_usb_hid_device_get_usage_page(usb_hid_device_obj_t *self) {
@ -41,7 +42,7 @@ uint8_t common_hal_usb_hid_device_get_usage(usb_hid_device_obj_t *self) {
void common_hal_usb_hid_device_send_report(usb_hid_device_obj_t *self, uint8_t* report, uint8_t len) { void common_hal_usb_hid_device_send_report(usb_hid_device_obj_t *self, uint8_t* report, uint8_t len) {
if (len != self->report_length) { if (len != self->report_length) {
mp_raise_ValueError_varg("Buffer incorrect size. Should be %d bytes.", self->report_length); mp_raise_ValueError_varg(translate("Buffer incorrect size. Should be %d bytes."), self->report_length);
} }
// Wait until interface is ready, timeout = 2 seconds // Wait until interface is ready, timeout = 2 seconds
@ -49,13 +50,13 @@ void common_hal_usb_hid_device_send_report(usb_hid_device_obj_t *self, uint8_t*
while ( (ticks_ms < end_ticks) && !tud_hid_generic_ready() ) { } while ( (ticks_ms < end_ticks) && !tud_hid_generic_ready() ) { }
if ( !tud_hid_generic_ready() ) { if ( !tud_hid_generic_ready() ) {
mp_raise_msg(&mp_type_OSError, "USB Busy"); mp_raise_msg(&mp_type_OSError, translate("USB Busy"));
} }
memcpy(self->report_buffer, report, len); memcpy(self->report_buffer, report, len);
if ( !tud_hid_generic_report(self->report_id, self->report_buffer, len) ) { if ( !tud_hid_generic_report(self->report_id, self->report_buffer, len) ) {
mp_raise_msg(&mp_type_OSError, "USB Error"); mp_raise_msg(&mp_type_OSError, translate("USB Error"));
} }
} }
@ -85,4 +86,3 @@ void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_t
} }
} }
} }

49
ports/nrf/drivers/bluetooth/ble_drv.c
View File

@ -35,6 +35,7 @@
#endif #endif
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#include "ble_drv.h" #include "ble_drv.h"
#include "mpconfigport.h" #include "mpconfigport.h"
#include "nrf_sdm.h" #include "nrf_sdm.h"
@ -195,7 +196,7 @@ uint32_t ble_drv_stack_enable(void) {
(const uint8_t *)device_name, (const uint8_t *)device_name,
strlen(device_name))) != 0) { strlen(device_name))) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Cannot apply GAP parameters.")); translate("Cannot apply GAP parameters.")));
} }
// set connection parameters // set connection parameters
@ -209,7 +210,7 @@ uint32_t ble_drv_stack_enable(void) {
if (sd_ble_gap_ppcp_set(&gap_conn_params) != 0) { if (sd_ble_gap_ppcp_set(&gap_conn_params) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Cannot set PPCP parameters.")); translate("Cannot set PPCP parameters.")));
} }
return err_code; return err_code;
@ -241,7 +242,7 @@ void ble_drv_address_get(ble_drv_addr_t * p_addr) {
if (err_code != 0) { if (err_code != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not query for the device address.")); translate("Can not query for the device address.")));
} }
BLE_DRIVER_LOG("ble address, type: " HEX2_FMT ", " \ BLE_DRIVER_LOG("ble address, type: " HEX2_FMT ", " \
@ -260,7 +261,7 @@ bool ble_drv_uuid_add_vs(uint8_t * p_uuid, uint8_t * idx) {
if (sd_ble_uuid_vs_add((ble_uuid128_t const *)p_uuid, idx) != 0) { if (sd_ble_uuid_vs_add((ble_uuid128_t const *)p_uuid, idx) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not add Vendor Specific 128-bit UUID.")); translate("Can not add Vendor Specific 128-bit UUID.")));
} }
return true; return true;
@ -280,7 +281,7 @@ bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
&uuid, &uuid,
&p_service_obj->handle) != 0) { &p_service_obj->handle) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not add Service.")); translate("Can not add Service.")));
} }
} else if (p_service_obj->p_uuid->type == BLE_UUID_TYPE_BLE) { } else if (p_service_obj->p_uuid->type == BLE_UUID_TYPE_BLE) {
BLE_DRIVER_LOG("adding service\n"); BLE_DRIVER_LOG("adding service\n");
@ -294,7 +295,7 @@ bool ble_drv_service_add(ubluepy_service_obj_t * p_service_obj) {
&uuid, &uuid,
&p_service_obj->handle) != 0) { &p_service_obj->handle) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not add Service.")); translate("Can not add Service.")));
} }
} }
return true; return true;
@ -369,7 +370,7 @@ bool ble_drv_characteristic_add(ubluepy_characteristic_obj_t * p_char_obj) {
&attr_char_value, &attr_char_value,
&handles) != 0) { &handles) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not add Characteristic.")); translate("Can not add Characteristic.")));
} }
// apply handles to object instance // apply handles to object instance
@ -396,7 +397,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
p_adv_params->p_device_name, p_adv_params->p_device_name,
p_adv_params->device_name_len) != 0) { p_adv_params->device_name_len) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not apply device name in the stack.")); translate("Can not apply device name in the stack.")));
} }
BLE_DRIVER_LOG("Device name applied\n"); BLE_DRIVER_LOG("Device name applied\n");
@ -460,13 +461,13 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
// calculate total size of uuids // calculate total size of uuids
if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) { if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not encode UUID, to check length.")); translate("Can not encode UUID, to check length.")));
} }
// do encoding into the adv buffer // do encoding into the adv buffer
if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) { if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can encode UUID into the advertisment packet.")); translate("Can encode UUID into the advertisment packet.")));
} }
BLE_DRIVER_LOG("encoded uuid for service %u: ", 0); BLE_DRIVER_LOG("encoded uuid for service %u: ", 0);
@ -510,13 +511,13 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
// calculate total size of uuids // calculate total size of uuids
if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) { if (sd_ble_uuid_encode(&uuid, &encoded_size, NULL) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not encode UUID, to check length.")); translate("Can not encode UUID, to check length.")));
} }
// do encoding into the adv buffer // do encoding into the adv buffer
if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) { if (sd_ble_uuid_encode(&uuid, &encoded_size, &adv_data[byte_pos]) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can encode UUID into the advertisment packet.")); translate("Can encode UUID into the advertisment packet.")));
} }
BLE_DRIVER_LOG("encoded uuid for service %u: ", 0); BLE_DRIVER_LOG("encoded uuid for service %u: ", 0);
@ -541,7 +542,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
if ((p_adv_params->data_len > 0) && (p_adv_params->p_data != NULL)) { if ((p_adv_params->data_len > 0) && (p_adv_params->p_data != NULL)) {
if (p_adv_params->data_len + byte_pos > BLE_GAP_ADV_MAX_SIZE) { if (p_adv_params->data_len + byte_pos > BLE_GAP_ADV_MAX_SIZE) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not fit data into the advertisment packet.")); translate("Can not fit data into the advertisment packet.")));
} }
memcpy(adv_data, p_adv_params->p_data, p_adv_params->data_len); memcpy(adv_data, p_adv_params->p_data, p_adv_params->data_len);
@ -554,7 +555,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
if ((err_code = sd_ble_gap_adv_data_set(adv_data, byte_pos, NULL, 0)) != 0) { if ((err_code = sd_ble_gap_adv_data_set(adv_data, byte_pos, NULL, 0)) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not apply advertisment data. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not apply advertisment data. status: 0x%02x"), (uint16_t)err_code));
} }
BLE_DRIVER_LOG("Set Adv data size: " UINT_FMT "\n", byte_pos); BLE_DRIVER_LOG("Set Adv data size: " UINT_FMT "\n", byte_pos);
#endif #endif
@ -600,7 +601,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
if ((err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &ble_gap_adv_data, &m_adv_params)) != 0) { if ((err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &ble_gap_adv_data, &m_adv_params)) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not apply advertisment data. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not apply advertisment data. status: 0x%02x"), (uint16_t)err_code));
} }
err_code = sd_ble_gap_adv_start(m_adv_handle, BLE_CONN_CFG_TAG_DEFAULT); err_code = sd_ble_gap_adv_start(m_adv_handle, BLE_CONN_CFG_TAG_DEFAULT);
#elif (BLUETOOTH_SD == 132 && BLE_API_VERSION == 4) #elif (BLUETOOTH_SD == 132 && BLE_API_VERSION == 4)
@ -610,7 +611,7 @@ bool ble_drv_advertise_data(ubluepy_advertise_data_t * p_adv_params) {
#endif #endif
if (err_code != 0) { if (err_code != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not start advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not start advertisment. status: 0x%02x"), (uint16_t)err_code));
} }
m_adv_in_progress = true; m_adv_in_progress = true;
@ -627,7 +628,7 @@ void ble_drv_advertise_stop(void) {
if ((err_code = sd_ble_gap_adv_stop()) != 0) { if ((err_code = sd_ble_gap_adv_stop()) != 0) {
#endif #endif
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not stop advertisment. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not stop advertisment. status: 0x%02x"), (uint16_t)err_code));
} }
} }
m_adv_in_progress = false; m_adv_in_progress = false;
@ -646,7 +647,7 @@ void ble_drv_attr_s_read(uint16_t conn_handle, uint16_t handle, uint16_t len, ui
&gatts_value); &gatts_value);
if (err_code != 0) { if (err_code != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not read attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not read attribute value. status: 0x%02x"), (uint16_t)err_code));
} }
} }
@ -663,7 +664,7 @@ void ble_drv_attr_s_write(uint16_t conn_handle, uint16_t handle, uint16_t len, u
if (err_code != 0) { if (err_code != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not write attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not write attribute value. status: 0x%02x"), (uint16_t)err_code));
} }
} }
@ -687,7 +688,7 @@ void ble_drv_attr_s_notify(uint16_t conn_handle, uint16_t handle, uint16_t len,
uint32_t err_code; uint32_t err_code;
if ((err_code = sd_ble_gatts_hvx(conn_handle, &hvx_params)) != 0) { if ((err_code = sd_ble_gatts_hvx(conn_handle, &hvx_params)) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not notify attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not notify attribute value. status: 0x%02x"), (uint16_t)err_code));
} }
} }
@ -722,7 +723,7 @@ void ble_drv_attr_c_read(uint16_t conn_handle, uint16_t handle, mp_obj_t obj, bl
0); 0);
if (err_code != 0) { if (err_code != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not read attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not read attribute value. status: 0x%02x"), (uint16_t)err_code));
} }
while (gattc_char_data_handle != NULL) { while (gattc_char_data_handle != NULL) {
@ -752,7 +753,7 @@ void ble_drv_attr_c_write(uint16_t conn_handle, uint16_t handle, uint16_t len, u
if (err_code != 0) { if (err_code != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not write attribute value. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not write attribute value. status: 0x%02x"), (uint16_t)err_code));
} }
while (m_write_done != true) { while (m_write_done != true) {
@ -780,7 +781,7 @@ void ble_drv_scan_start(void) {
if ((err_code = sd_ble_gap_scan_start(&scan_params)) != 0) { if ((err_code = sd_ble_gap_scan_start(&scan_params)) != 0) {
#endif #endif
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not start scanning. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not start scanning. status: 0x%02x"), (uint16_t)err_code));
} }
} }
@ -825,7 +826,7 @@ void ble_drv_connect(uint8_t * p_addr, uint8_t addr_type) {
if ((err_code = sd_ble_gap_connect(&addr, &scan_params, &conn_params, BLE_CONN_CFG_TAG_DEFAULT)) != 0) { if ((err_code = sd_ble_gap_connect(&addr, &scan_params, &conn_params, BLE_CONN_CFG_TAG_DEFAULT)) != 0) {
#endif #endif
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError,
"Can not connect. status: 0x" HEX2_FMT, (uint16_t)err_code)); translate("Can not connect. status: 0x%02x"), (uint16_t)err_code));
} }
} }

3
ports/nrf/modules/ubluepy/ubluepy_characteristic.c
View File

@ -26,6 +26,7 @@
#include "py/obj.h" #include "py/obj.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL #if MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL
@ -64,7 +65,7 @@ STATIC mp_obj_t ubluepy_characteristic_make_new(const mp_obj_type_t *type, size_
// (void)sd_characterstic_add(s); // (void)sd_characterstic_add(s);
} else { } else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid UUID parameter")); translate("Invalid UUID parameter")));
} }
if (args[1].u_int > 0) { if (args[1].u_int > 0) {

7
ports/nrf/modules/ubluepy/ubluepy_service.c
View File

@ -27,6 +27,7 @@
#include "py/obj.h" #include "py/obj.h"
#include "py/runtime.h" #include "py/runtime.h"
#include "py/objlist.h" #include "py/objlist.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL #if MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL
@ -69,14 +70,14 @@ STATIC mp_obj_t ubluepy_service_make_new(const mp_obj_type_t *type, size_t n_arg
s->type = type; s->type = type;
} else { } else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid Service type")); translate("Invalid Service type")));
} }
(void)ble_drv_service_add(s); (void)ble_drv_service_add(s);
} else { } else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid UUID parameter")); translate("Invalid UUID parameter")));
} }
// clear reference to peripheral // clear reference to peripheral
@ -128,7 +129,7 @@ STATIC mp_obj_t service_get_characteristic(mp_obj_t self_in, mp_obj_t uuid) {
// validate that there is an UUID object passed in as parameter // validate that there is an UUID object passed in as parameter
if (!(MP_OBJ_IS_TYPE(uuid, &ubluepy_uuid_type))) { if (!(MP_OBJ_IS_TYPE(uuid, &ubluepy_uuid_type))) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid UUID parameter")); translate("Invalid UUID parameter")));
} }
mp_obj_t * chars = NULL; mp_obj_t * chars = NULL;

5
ports/nrf/modules/ubluepy/ubluepy_uuid.c
View File

@ -28,6 +28,7 @@
#include "py/runtime.h" #include "py/runtime.h"
#include "py/objstr.h" #include "py/objstr.h"
#include "py/misc.h" #include "py/misc.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PY_UBLUEPY #if MICROPY_PY_UBLUEPY
@ -123,7 +124,7 @@ STATIC mp_obj_t ubluepy_uuid_make_new(const mp_obj_type_t *type, size_t n_args,
ble_drv_uuid_add_vs(buffer, &s->uuid_vs_idx); ble_drv_uuid_add_vs(buffer, &s->uuid_vs_idx);
} else { } else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid UUID string length")); translate("Invalid UUID string length")));
} }
} else if (MP_OBJ_IS_TYPE(uuid_obj, &ubluepy_uuid_type)) { } else if (MP_OBJ_IS_TYPE(uuid_obj, &ubluepy_uuid_type)) {
// deep copy instance // deep copy instance
@ -133,7 +134,7 @@ STATIC mp_obj_t ubluepy_uuid_make_new(const mp_obj_type_t *type, size_t n_args,
s->value[1] = p_old->value[1]; s->value[1] = p_old->value[1];
} else { } else {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"Invalid UUID parameter")); translate("Invalid UUID parameter")));
} }
return MP_OBJ_FROM_PTR(s); return MP_OBJ_FROM_PTR(s);

2
ports/unix/Makefile
View File

@ -242,7 +242,7 @@ freedos:
# build an interpreter for coverage testing and do the testing # build an interpreter for coverage testing and do the testing
coverage: coverage:
$(MAKE) V=2 \ $(MAKE) \
COPT="-O0" CFLAGS_EXTRA='$(CFLAGS_EXTRA) -DMP_CONFIGFILE="<mpconfigport_coverage.h>" \ COPT="-O0" CFLAGS_EXTRA='$(CFLAGS_EXTRA) -DMP_CONFIGFILE="<mpconfigport_coverage.h>" \
-fprofile-arcs -ftest-coverage \ -fprofile-arcs -ftest-coverage \
-Wdouble-promotion -Wformat -Wmissing-declarations -Wmissing-prototypes -Wsign-compare \ -Wdouble-promotion -Wformat -Wmissing-declarations -Wmissing-prototypes -Wsign-compare \

3
ports/unix/file.c
View File

@ -35,6 +35,7 @@
#include "py/stream.h" #include "py/stream.h"
#include "py/builtin.h" #include "py/builtin.h"
#include "py/mphal.h" #include "py/mphal.h"
#include "supervisor/shared/translate.h"
#include "fdfile.h" #include "fdfile.h"
#if MICROPY_PY_IO && !MICROPY_VFS #if MICROPY_PY_IO && !MICROPY_VFS
@ -46,7 +47,7 @@
#ifdef MICROPY_CPYTHON_COMPAT #ifdef MICROPY_CPYTHON_COMPAT
STATIC void check_fd_is_open(const mp_obj_fdfile_t *o) { STATIC void check_fd_is_open(const mp_obj_fdfile_t *o) {
if (o->fd < 0) { if (o->fd < 0) {
mp_raise_ValueError("I/O operation on closed file"); mp_raise_ValueError(translate("I/O operation on closed file"));
} }
} }
#else #else

12
ports/unix/modffi.c
View File

@ -36,6 +36,8 @@
#include "py/binary.h" #include "py/binary.h"
#include "py/mperrno.h" #include "py/mperrno.h"
#include "supervisor/shared/translate.h"
/* /*
* modffi uses character codes to encode a value type, based on "struct" * modffi uses character codes to encode a value type, based on "struct"
* module type codes, with some extensions and overridings. * module type codes, with some extensions and overridings.
@ -133,7 +135,7 @@ STATIC ffi_type *get_ffi_type(mp_obj_t o_in)
} }
// TODO: Support actual libffi type objects // TODO: Support actual libffi type objects
mp_raise_TypeError("Unknown type"); mp_raise_TypeError(translate("Unknown type"));
} }
STATIC mp_obj_t return_ffi_value(ffi_arg val, char type) STATIC mp_obj_t return_ffi_value(ffi_arg val, char type)
@ -202,7 +204,7 @@ STATIC mp_obj_t make_func(mp_obj_t rettype_in, void *func, mp_obj_t argtypes_in)
int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params); int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params);
if (res != FFI_OK) { if (res != FFI_OK) {
mp_raise_ValueError("Error in ffi_prep_cif"); mp_raise_ValueError(translate("Error in ffi_prep_cif"));
} }
return MP_OBJ_FROM_PTR(o); return MP_OBJ_FROM_PTR(o);
@ -260,12 +262,12 @@ STATIC mp_obj_t mod_ffi_callback(mp_obj_t rettype_in, mp_obj_t func_in, mp_obj_t
int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params); int res = ffi_prep_cif(&o->cif, FFI_DEFAULT_ABI, nparams, char2ffi_type(*rettype), o->params);
if (res != FFI_OK) { if (res != FFI_OK) {
mp_raise_ValueError("Error in ffi_prep_cif"); mp_raise_ValueError(translate("Error in ffi_prep_cif"));
} }
res = ffi_prep_closure_loc(o->clo, &o->cif, call_py_func, MP_OBJ_TO_PTR(func_in), o->func); res = ffi_prep_closure_loc(o->clo, &o->cif, call_py_func, MP_OBJ_TO_PTR(func_in), o->func);
if (res != FFI_OK) { if (res != FFI_OK) {
mp_raise_ValueError("ffi_prep_closure_loc"); mp_raise_ValueError(translate("ffi_prep_closure_loc"));
} }
return MP_OBJ_FROM_PTR(o); return MP_OBJ_FROM_PTR(o);
@ -408,7 +410,7 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
} }
error: error:
mp_raise_TypeError("Don't know how to pass object to native function"); mp_raise_TypeError(translate("Don't know how to pass object to native function"));
} }
STATIC const mp_obj_type_t ffifunc_type = { STATIC const mp_obj_type_t ffifunc_type = {

4
ports/unix/modmachine.c
View File

@ -35,6 +35,8 @@
#include "extmod/machine_signal.h" #include "extmod/machine_signal.h"
#include "extmod/machine_pulse.h" #include "extmod/machine_pulse.h"
#include "supervisor/shared/translate.h"
#if MICROPY_PLAT_DEV_MEM #if MICROPY_PLAT_DEV_MEM
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
@ -48,7 +50,7 @@
uintptr_t mod_machine_mem_get_addr(mp_obj_t addr_o, uint align) { uintptr_t mod_machine_mem_get_addr(mp_obj_t addr_o, uint align) {
uintptr_t addr = mp_obj_int_get_truncated(addr_o); uintptr_t addr = mp_obj_int_get_truncated(addr_o);
if ((addr & (align - 1)) != 0) { if ((addr & (align - 1)) != 0) {
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "address %08x is not aligned to %d bytes", addr, align)); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, translate("address %08x is not aligned to %d bytes"), addr, align));
} }
#if MICROPY_PLAT_DEV_MEM #if MICROPY_PLAT_DEV_MEM
{ {

4
ports/unix/modusocket.c
View File

@ -45,6 +45,8 @@
#include "py/builtin.h" #include "py/builtin.h"
#include "py/mphal.h" #include "py/mphal.h"
#include "supervisor/shared/translate.h"
/* /*
The idea of this module is to implement reasonable minimum of The idea of this module is to implement reasonable minimum of
socket-related functions to write typical clients and servers. socket-related functions to write typical clients and servers.
@ -469,7 +471,7 @@ STATIC mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
if (res != 0) { if (res != 0) {
// CPython: socket.gaierror // CPython: socket.gaierror
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, "[addrinfo error %d]", res)); nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_OSError, translate("[addrinfo error %d]"), res));
} }
assert(addr_list); assert(addr_list);

4
py/compile.c
View File

@ -156,7 +156,7 @@ STATIC void compile_error_set_line(compiler_t *comp, mp_parse_node_t pn) {
} }
} }
STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const char *msg) { STATIC void compile_syntax_error(compiler_t *comp, mp_parse_node_t pn, const compressed_string_t *msg) {
// only register the error if there has been no other error // only register the error if there has been no other error
if (comp->compile_error == MP_OBJ_NULL) { if (comp->compile_error == MP_OBJ_NULL) {
comp->compile_error = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg); comp->compile_error = mp_obj_new_exception_msg(&mp_type_SyntaxError, msg);
@ -949,7 +949,7 @@ STATIC void compile_del_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) { STATIC void compile_break_cont_stmt(compiler_t *comp, mp_parse_node_struct_t *pns) {
uint16_t label; uint16_t label;
const char *error_msg; const compressed_string_t *error_msg;
if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_break_stmt) { if (MP_PARSE_NODE_STRUCT_KIND(pns) == PN_break_stmt) {
label = comp->break_label; label = comp->break_label;
error_msg = translate("'break' outside loop"); error_msg = translate("'break' outside loop");

22
py/emitinlinextensa.c
View File

@ -43,7 +43,7 @@ struct _emit_inline_asm_t {
qstr *label_lookup; 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, const compressed_string_t *msg) {
*emit->error_slot = mp_obj_new_exception_msg(&mp_type_SyntaxError, 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) { 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) { 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, translate("can only have up to 4 parameters to Xtensa assembly"));
return 0; return 0;
} }
for (mp_uint_t i = 0; i < n_params; i++) { for (mp_uint_t i = 0; i < n_params; i++) {
if (!MP_PARSE_NODE_IS_ID(pn_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, translate("parameters must be registers in sequence a2 to a5"));
return 0; return 0;
} }
const char *p = qstr_str(MP_PARSE_NODE_LEAF_ARG(pn_params[i])); const char *p = qstr_str(MP_PARSE_NODE_LEAF_ARG(pn_params[i]));
if (!(strlen(p) == 2 && p[0] == 'a' && p[1] == '2' + 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, translate("parameters must be registers in sequence a2 to a5"));
return 0; return 0;
} }
} }
@ -159,19 +159,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, emit_inline_xtensa_error_exc(emit,
mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError,
"'%s' expects a register", op)); translate("'%s' expects a register"), op));
return 0; 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) { 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; mp_obj_t o;
if (!mp_parse_node_get_int_maybe(pn, &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, translate("'%s' expects an integer"), op));
return 0; return 0;
} }
uint32_t i = mp_obj_get_int_truncated(o); uint32_t i = mp_obj_get_int_truncated(o);
if (min != max && ((int)i < min || (int)i > max)) { 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 is not within range %d..%d", op, i, min, max)); emit_inline_xtensa_error_exc(emit, mp_obj_new_exception_msg_varg(&mp_type_SyntaxError, translate("'%s' integer %d is not within range %d..%d"), op, i, min, max));
return 0; return 0;
} }
return i; return i;
@ -179,7 +179,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) { 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)) { 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, translate("'%s' expects a label"), op));
return 0; return 0;
} }
qstr label_qstr = MP_PARSE_NODE_LEAF_ARG(pn); qstr label_qstr = MP_PARSE_NODE_LEAF_ARG(pn);
@ -190,7 +190,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 // only need to have the labels on the last pass
if (emit->pass == MP_PASS_EMIT) { 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, translate("label '%q' not defined"), label_qstr));
} }
return 0; return 0;
} }
@ -324,12 +324,12 @@ STATIC void emit_inline_xtensa_op(emit_inline_asm_t *emit, qstr op, mp_uint_t n_
return; return;
unknown_op: 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, translate("unsupported Xtensa instruction '%s' with %d arguments"), op_str, n_args));
return; return;
/* /*
branch_not_in_range: branch_not_in_range:
emit_inline_xtensa_error_msg(emit, "branch not in range"); emit_inline_xtensa_error_msg(emit, translate("branch not in range"));
return; return;
*/ */
} }

36
py/emitnative.c
View File

@ -180,7 +180,7 @@ STATIC void emit_native_set_native_type(emit_t *emit, mp_uint_t op, mp_uint_t ar
case MP_QSTR_ptr8: type = VTYPE_PTR8; break; case MP_QSTR_ptr8: type = VTYPE_PTR8; break;
case MP_QSTR_ptr16: type = VTYPE_PTR16; break; case MP_QSTR_ptr16: type = VTYPE_PTR16; break;
case MP_QSTR_ptr32: type = VTYPE_PTR32; break; case MP_QSTR_ptr32: type = VTYPE_PTR32; break;
default: EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "unknown type '%q'", arg2); return; default: EMIT_NATIVE_VIPER_TYPE_ERROR(emit, translate("unknown type '%q'"), arg2); return;
} }
if (op == MP_EMIT_NATIVE_TYPE_RETURN) { if (op == MP_EMIT_NATIVE_TYPE_RETURN) {
emit->return_vtype = type; emit->return_vtype = type;
@ -257,7 +257,7 @@ STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scop
// right now we have a restriction of maximum of 4 arguments // right now we have a restriction of maximum of 4 arguments
if (scope->num_pos_args >= 5) { if (scope->num_pos_args >= 5) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "Viper functions don't currently support more than 4 arguments"); EMIT_NATIVE_VIPER_TYPE_ERROR(emit, translate("Viper functions don't currently support more than 4 arguments"));
return; return;
} }
@ -918,7 +918,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); DEBUG_printf("load_fast(%s, " UINT_FMT ")\n", qstr_str(qst), local_num);
vtype_kind_t vtype = emit->local_vtype[local_num]; vtype_kind_t vtype = emit->local_vtype[local_num];
if (vtype == VTYPE_UNBOUND) { if (vtype == VTYPE_UNBOUND) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "local '%q' used before type known", qst); EMIT_NATIVE_VIPER_TYPE_ERROR(emit, translate("local '%q' used before type known"), qst);
} }
emit_native_pre(emit); emit_native_pre(emit);
if (local_num == 0) { if (local_num == 0) {
@ -1115,7 +1115,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) {
} }
default: default:
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't load from '%q'", vtype_to_qstr(vtype_base)); translate("can't load from '%q'"), vtype_to_qstr(vtype_base));
} }
} else { } else {
// index is not an immediate // index is not an immediate
@ -1125,7 +1125,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) {
emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1);
if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) { if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't load with '%q' index", vtype_to_qstr(vtype_index)); translate("can't load with '%q' index"), vtype_to_qstr(vtype_index));
} }
switch (vtype_base) { switch (vtype_base) {
case VTYPE_PTR8: { case VTYPE_PTR8: {
@ -1153,7 +1153,7 @@ STATIC void emit_native_load_subscr(emit_t *emit) {
} }
default: default:
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't load from '%q'", vtype_to_qstr(vtype_base)); translate("can't load from '%q'"), vtype_to_qstr(vtype_base));
} }
} }
emit_post_push_reg(emit, VTYPE_INT, REG_RET); emit_post_push_reg(emit, VTYPE_INT, REG_RET);
@ -1185,7 +1185,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) { } else if (emit->local_vtype[local_num] != vtype) {
// type of local is not the same as object stored in it // type of local is not the same as object stored in it
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"local '%q' has type '%q' but source is '%q'", translate("local '%q' has type '%q' but source is '%q'"),
qst, vtype_to_qstr(emit->local_vtype[local_num]), vtype_to_qstr(vtype)); qst, vtype_to_qstr(emit->local_vtype[local_num]), vtype_to_qstr(vtype));
} }
} }
@ -1286,7 +1286,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
#endif #endif
if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) { if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't store '%q'", vtype_to_qstr(vtype_value)); translate("can't store '%q'"), vtype_to_qstr(vtype_value));
} }
switch (vtype_base) { switch (vtype_base) {
case VTYPE_PTR8: { case VTYPE_PTR8: {
@ -1355,7 +1355,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
} }
default: default:
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't store to '%q'", vtype_to_qstr(vtype_base)); translate("can't store to '%q'"), vtype_to_qstr(vtype_base));
} }
} else { } else {
// index is not an immediate // index is not an immediate
@ -1366,7 +1366,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1);
if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) { if (vtype_index != VTYPE_INT && vtype_index != VTYPE_UINT) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't store with '%q' index", vtype_to_qstr(vtype_index)); translate("can't store with '%q' index"), vtype_to_qstr(vtype_index));
} }
#if N_X86 #if N_X86
// special case: x86 needs byte stores to be from lower 4 regs (REG_ARG_3 is EDX) // special case: x86 needs byte stores to be from lower 4 regs (REG_ARG_3 is EDX)
@ -1376,7 +1376,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
#endif #endif
if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) { if (vtype_value != VTYPE_BOOL && vtype_value != VTYPE_INT && vtype_value != VTYPE_UINT) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't store '%q'", vtype_to_qstr(vtype_value)); translate("can't store '%q'"), vtype_to_qstr(vtype_value));
} }
switch (vtype_base) { switch (vtype_base) {
case VTYPE_PTR8: { case VTYPE_PTR8: {
@ -1416,7 +1416,7 @@ STATIC void emit_native_store_subscr(emit_t *emit) {
} }
default: default:
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't store to '%q'", vtype_to_qstr(vtype_base)); translate("can't store to '%q'"), vtype_to_qstr(vtype_base));
} }
} }
@ -1537,7 +1537,7 @@ STATIC void emit_native_jump_helper(emit_t *emit, bool pop) {
} }
if (!(vtype == VTYPE_BOOL || vtype == VTYPE_INT || vtype == VTYPE_UINT)) { if (!(vtype == VTYPE_BOOL || vtype == VTYPE_INT || vtype == VTYPE_UINT)) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't implicitly convert '%q' to 'bool'", vtype_to_qstr(vtype)); translate("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 // For non-pop need to save the vtype so that emit_native_adjust_stack_size
@ -1771,7 +1771,7 @@ STATIC void emit_native_unary_op(emit_t *emit, mp_unary_op_t op) {
} else { } else {
adjust_stack(emit, 1); adjust_stack(emit, 1);
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"unary op %q not implemented", mp_unary_op_method_name[op]); translate("unary op %q not implemented"), mp_unary_op_method_name[op]);
} }
} }
@ -1927,7 +1927,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
// TODO other ops not yet implemented // TODO other ops not yet implemented
adjust_stack(emit, 1); adjust_stack(emit, 1);
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"binary op %q not implemented", mp_binary_op_method_name[op]); translate("binary op %q not implemented"), mp_binary_op_method_name[op]);
} }
} else if (vtype_lhs == VTYPE_PYOBJ && vtype_rhs == VTYPE_PYOBJ) { } 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); emit_pre_pop_reg_reg(emit, &vtype_rhs, REG_ARG_3, &vtype_lhs, REG_ARG_2);
@ -1948,7 +1948,7 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
} else { } else {
adjust_stack(emit, -1); adjust_stack(emit, -1);
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"can't do binary op between '%q' and '%q'", translate("can't do binary op between '%q' and '%q'"),
vtype_to_qstr(vtype_lhs), vtype_to_qstr(vtype_rhs)); vtype_to_qstr(vtype_lhs), vtype_to_qstr(vtype_rhs));
} }
} }
@ -2170,7 +2170,7 @@ STATIC void emit_native_return_value(emit_t *emit) {
emit_pre_pop_reg(emit, &vtype, REG_RET); emit_pre_pop_reg(emit, &vtype, REG_RET);
if (vtype != emit->return_vtype) { if (vtype != emit->return_vtype) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, EMIT_NATIVE_VIPER_TYPE_ERROR(emit,
"return expected '%q' but got '%q'", translate("return expected '%q' but got '%q'"),
vtype_to_qstr(emit->return_vtype), vtype_to_qstr(vtype)); vtype_to_qstr(emit->return_vtype), vtype_to_qstr(vtype));
} }
} }
@ -2188,7 +2188,7 @@ STATIC void emit_native_raise_varargs(emit_t *emit, mp_uint_t n_args) {
vtype_kind_t vtype_exc; vtype_kind_t vtype_exc;
emit_pre_pop_reg(emit, &vtype_exc, REG_ARG_1); // arg1 = object to raise emit_pre_pop_reg(emit, &vtype_exc, REG_ARG_1); // arg1 = object to raise
if (vtype_exc != VTYPE_PYOBJ) { if (vtype_exc != VTYPE_PYOBJ) {
EMIT_NATIVE_VIPER_TYPE_ERROR(emit, "must raise an object"); EMIT_NATIVE_VIPER_TYPE_ERROR(emit, translate("must raise an object"));
} }
// TODO probably make this 1 call to the runtime (which could even call convert, native_raise(obj, type)) // 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); emit_call(emit, MP_F_NATIVE_RAISE);

171
py/makeqstrdata.py
View File

@ -11,6 +11,14 @@ import sys
import collections import collections
import gettext import gettext
import os.path
py = os.path.dirname(sys.argv[0])
top = os.path.dirname(py)
sys.path.append(os.path.join(top, "tools/huffman"))
import huffman
# Python 2/3 compatibility: # Python 2/3 compatibility:
# - iterating through bytes is different # - iterating through bytes is different
@ -83,9 +91,144 @@ def translate(translation_file, i18ns):
unescaped = original unescaped = original
for s in C_ESCAPES: for s in C_ESCAPES:
unescaped = unescaped.replace(C_ESCAPES[s], s) unescaped = unescaped.replace(C_ESCAPES[s], s)
translations.append((original, table.gettext(unescaped))) translation = table.gettext(unescaped)
# Add in carriage returns to work in terminals
translation = translation.replace("\n", "\r\n")
translations.append((original, translation))
return translations return translations
def compute_huffman_coding(translations, qstrs, compression_filename):
all_strings = [x[1] for x in translations]
# go through each qstr and print it out
for _, _, qstr in qstrs.values():
all_strings.append(qstr)
all_strings_concat = "".join(all_strings).encode("utf-8")
counts = collections.Counter(all_strings_concat)
# add other values
for i in range(256):
if i not in counts:
counts[i] = 0
cb = huffman.codebook(counts.items())
values = bytearray()
length_count = {}
renumbered = 0
last_l = None
canonical = {}
for ch, code in sorted(cb.items(), key=lambda x: (len(x[1]), x[0])):
values.append(ch)
l = len(code)
if l not in length_count:
length_count[l] = 0
length_count[l] += 1
if last_l:
renumbered <<= (l - last_l)
canonical[ch] = '{0:0{width}b}'.format(renumbered, width=l)
if chr(ch) in C_ESCAPES:
s = C_ESCAPES[chr(ch)]
else:
s = chr(ch)
print("//", ch, s, counts[ch], canonical[ch], renumbered)
renumbered += 1
last_l = l
lengths = bytearray()
for i in range(1, max(length_count) + 1):
lengths.append(length_count.get(i, 0))
print("//", values, lengths)
with open(compression_filename, "w") as f:
f.write("const uint8_t lengths[] = {{ {} }};\n".format(", ".join(map(str, lengths))))
f.write("const uint8_t values[256] = {{ {} }};\n".format(", ".join(map(str, values))))
return values, lengths
def decompress(encoding_table, length, encoded):
values, lengths = encoding_table
#print(l, encoded)
dec = bytearray(length)
this_byte = 0
this_bit = 7
b = encoded[this_byte]
for i in range(length):
bits = 0
bit_length = 0
max_code = lengths[0]
searched_length = lengths[0]
while True:
bits <<= 1
if 0x80 & b:
bits |= 1
b <<= 1
bit_length += 1
if this_bit == 0:
this_bit = 7
this_byte += 1
if this_byte < len(encoded):
b = encoded[this_byte]
else:
this_bit -= 1
if max_code > 0 and bits < max_code:
#print('{0:0{width}b}'.format(bits, width=bit_length))
break
max_code = (max_code << 1) + lengths[bit_length]
searched_length += lengths[bit_length]
v = values[searched_length + bits - max_code]
dec[i] = v
return dec
def compress(encoding_table, decompressed):
if not isinstance(decompressed, bytes):
raise TypeError()
values, lengths = encoding_table
enc = bytearray(len(decompressed))
#print(decompressed)
#print(lengths)
current_bit = 7
current_byte = 0
for c in decompressed:
#print()
#print("char", c, values.index(c))
start = 0
end = lengths[0]
bits = 1
compressed = None
code = 0
while compressed is None:
s = start
e = end
#print("{0:0{width}b}".format(code, width=bits))
# Binary search!
while e > s:
midpoint = (s + e) // 2
#print(s, e, midpoint)
if values[midpoint] == c:
compressed = code + (midpoint - start)
#print("found {0:0{width}b}".format(compressed, width=bits))
break
elif c < values[midpoint]:
e = midpoint
else:
s = midpoint + 1
code += end - start
code <<= 1
start = end
end += lengths[bits]
bits += 1
#print("next bit", bits)
for i in range(bits - 1, 0, -1):
if compressed & (1 << (i - 1)):
enc[current_byte] |= 1 << current_bit
if current_bit == 0:
current_bit = 7
#print("packed {0:0{width}b}".format(enc[current_byte], width=8))
current_byte += 1
else:
current_bit -= 1
if current_bit != 7:
current_byte += 1
return enc[:current_byte]
def qstr_escape(qst): def qstr_escape(qst):
def esc_char(m): def esc_char(m):
c = ord(m.group(0)) c = ord(m.group(0))
@ -178,7 +321,7 @@ def make_bytes(cfg_bytes_len, cfg_bytes_hash, qstr):
qhash_str = ('\\x%02x' * cfg_bytes_hash) % tuple(((qhash >> (8 * i)) & 0xff) for i in range(cfg_bytes_hash)) qhash_str = ('\\x%02x' * cfg_bytes_hash) % tuple(((qhash >> (8 * i)) & 0xff) for i in range(cfg_bytes_hash))
return '(const byte*)"%s%s" "%s"' % (qhash_str, qlen_str, qdata) return '(const byte*)"%s%s" "%s"' % (qhash_str, qlen_str, qdata)
def print_qstr_data(qcfgs, qstrs, i18ns): def print_qstr_data(encoding_table, qcfgs, qstrs, i18ns):
# get config variables # get config variables
cfg_bytes_len = int(qcfgs['BYTES_IN_LEN']) cfg_bytes_len = int(qcfgs['BYTES_IN_LEN'])
cfg_bytes_hash = int(qcfgs['BYTES_IN_HASH']) cfg_bytes_hash = int(qcfgs['BYTES_IN_HASH'])
@ -191,6 +334,7 @@ def print_qstr_data(qcfgs, qstrs, i18ns):
print('QDEF(MP_QSTR_NULL, (const byte*)"%s%s" "")' % ('\\x00' * cfg_bytes_hash, '\\x00' * cfg_bytes_len)) print('QDEF(MP_QSTR_NULL, (const byte*)"%s%s" "")' % ('\\x00' * cfg_bytes_hash, '\\x00' * cfg_bytes_len))
total_qstr_size = 0 total_qstr_size = 0
total_qstr_compressed_size = 0
# go through each qstr and print it out # go through each qstr and print it out
for order, ident, qstr in sorted(qstrs.values(), key=lambda x: x[0]): for order, ident, qstr in sorted(qstrs.values(), key=lambda x: x[0]):
qbytes = make_bytes(cfg_bytes_len, cfg_bytes_hash, qstr) qbytes = make_bytes(cfg_bytes_len, cfg_bytes_hash, qstr)
@ -198,17 +342,23 @@ def print_qstr_data(qcfgs, qstrs, i18ns):
total_qstr_size += len(qstr) total_qstr_size += len(qstr)
total_text_size = 0 total_text_size = 0
total_text_compressed_size = 0
for original, translation in i18ns: for original, translation in i18ns:
# Add in carriage returns to work in terminals translation_encoded = translation.encode("utf-8")
translation = translation.replace("\n", "\r\n") compressed = compress(encoding_table, translation_encoded)
for s in C_ESCAPES: total_text_compressed_size += len(compressed)
translation = translation.replace(s, C_ESCAPES[s]) decompressed = decompress(encoding_table, len(translation_encoded), compressed).decode("utf-8")
print("TRANSLATION(\"{}\", \"{}\")".format(original, translation)) for c in C_ESCAPES:
total_text_size += len(translation) decompressed.replace(c, C_ESCAPES[c])
#print("// \"{}\"".format(translation))
print("TRANSLATION(\"{}\", {}, {{ {} }}) // {}".format(original, len(translation_encoded)+1, ", ".join(["0x{:02x}".format(x) for x in compressed]), decompressed))
total_text_size += len(translation.encode("utf-8"))
print() print()
print("// {} bytes worth of qstr".format(total_qstr_size)) print("// {} bytes worth of qstr".format(total_qstr_size))
print("// {} bytes worth of translations".format(total_text_size)) print("// {} bytes worth of translations".format(total_text_size))
print("// {} bytes worth of translations compressed".format(total_text_compressed_size))
print("// {} bytes saved".format(total_text_size - total_text_compressed_size))
def print_qstr_enums(qstrs): def print_qstr_enums(qstrs):
# print out the starter of the generated C header file # print out the starter of the generated C header file
@ -230,12 +380,15 @@ if __name__ == "__main__":
help='an integer for the accumulator') help='an integer for the accumulator')
parser.add_argument('--translation', default=None, type=str, parser.add_argument('--translation', default=None, type=str,
help='translations for i18n() items') help='translations for i18n() items')
parser.add_argument('--compression_filename', default=None, type=str,
help='header for compression info')
args = parser.parse_args() args = parser.parse_args()
qcfgs, qstrs, i18ns = parse_input_headers(args.infiles) qcfgs, qstrs, i18ns = parse_input_headers(args.infiles)
if args.translation: if args.translation:
translations = translate(args.translation, i18ns) translations = translate(args.translation, i18ns)
print_qstr_data(qcfgs, qstrs, translations) encoding_table = compute_huffman_coding(translations, qstrs, args.compression_filename)
print_qstr_data(encoding_table, qcfgs, qstrs, translations)
else: else:
print_qstr_enums(qstrs) print_qstr_enums(qstrs)

2
py/modbuiltins.c
View File

@ -316,7 +316,7 @@ MP_DEFINE_CONST_FUN_OBJ_KW(mp_builtin_min_obj, 1, mp_builtin_min);
STATIC mp_obj_t mp_builtin_next(mp_obj_t o) { STATIC mp_obj_t mp_builtin_next(mp_obj_t o) {
mp_obj_t ret = mp_iternext_allow_raise(o); mp_obj_t ret = mp_iternext_allow_raise(o);
if (ret == MP_OBJ_STOP_ITERATION) { if (ret == MP_OBJ_STOP_ITERATION) {
mp_raise_msg(&mp_type_StopIteration, ""); mp_raise_msg(&mp_type_StopIteration, NULL);
} else { } else {
return ret; return ret;
} }

32
py/moduerrno.c
View File

@ -102,20 +102,6 @@ const mp_obj_module_t mp_module_uerrno = {
}; };
const char* mp_errno_to_str(mp_obj_t errno_val) { const char* mp_errno_to_str(mp_obj_t errno_val) {
// For commonly encountered errors, return human readable strings
if (MP_OBJ_IS_SMALL_INT(errno_val)) {
switch (MP_OBJ_SMALL_INT_VALUE(errno_val)) {
case EPERM: return translate("Permission denied");
case ENOENT: return translate("No such file/directory");
case EIO: return translate("Input/output error");
case EACCES: return translate("Permission denied");
case EEXIST: return translate("File exists");
case ENODEV: return translate("Unsupported operation");
case EINVAL: return translate("Invalid argument");
case EROFS: return translate("Read-only filesystem");
}
}
// Otherwise, return the Exxxx string for that error code // Otherwise, return the Exxxx string for that error code
#if MICROPY_PY_UERRNO_ERRORCODE #if MICROPY_PY_UERRNO_ERRORCODE
// We have the errorcode dict so can do a lookup using the hash map // We have the errorcode dict so can do a lookup using the hash map
@ -148,3 +134,21 @@ const char* mp_errno_to_str(mp_obj_t errno_val) {
} }
#endif //MICROPY_PY_UERRNO #endif //MICROPY_PY_UERRNO
// For commonly encountered errors, return human readable strings
const compressed_string_t* mp_common_errno_to_str(mp_obj_t errno_val) {
if (MP_OBJ_IS_SMALL_INT(errno_val)) {
switch (MP_OBJ_SMALL_INT_VALUE(errno_val)) {
case EPERM: return translate("Permission denied");
case ENOENT: return translate("No such file/directory");
case EIO: return translate("Input/output error");
case EACCES: return translate("Permission denied");
case EEXIST: return translate("File exists");
case ENODEV: return translate("Unsupported operation");
case EINVAL: return translate("Invalid argument");
case EROFS: return translate("Read-only filesystem");
}
}
return NULL;
}

2
py/mperrno.h
View File

@ -141,5 +141,7 @@
#endif #endif
const char* mp_errno_to_str(mp_obj_t errno_val); const char* mp_errno_to_str(mp_obj_t errno_val);
// For commonly encountered errors, return compressed human readable strings
const compressed_string_t* mp_common_errno_to_str(mp_obj_t errno_val);
#endif // MICROPY_INCLUDED_PY_MPERRNO_H #endif // MICROPY_INCLUDED_PY_MPERRNO_H

24
py/obj.c
View File

@ -86,19 +86,35 @@ void mp_obj_print_exception(const mp_print_t *print, mp_obj_t exc) {
mp_obj_exception_get_traceback(exc, &n, &values); mp_obj_exception_get_traceback(exc, &n, &values);
if (n > 0) { if (n > 0) {
assert(n % 3 == 0); assert(n % 3 == 0);
mp_print_str(print, translate("Traceback (most recent call last):\n")); // Decompress the format strings
const compressed_string_t* traceback = translate("Traceback (most recent call last):\n");
char decompressed[traceback->length];
decompress(traceback, decompressed);
#if MICROPY_ENABLE_SOURCE_LINE
const compressed_string_t* frame = translate(" File \"%q\", line %d");
#else
const compressed_string_t* frame = translate(" File \"%q\"");
#endif
char decompressed_frame[frame->length];
decompress(frame, decompressed_frame);
const compressed_string_t* block_fmt = translate(", in %q\n");
char decompressed_block[block_fmt->length];
decompress(block_fmt, decompressed_block);
// Print the traceback
mp_print_str(print, decompressed);
for (int i = n - 3; i >= 0; i -= 3) { for (int i = n - 3; i >= 0; i -= 3) {
#if MICROPY_ENABLE_SOURCE_LINE #if MICROPY_ENABLE_SOURCE_LINE
mp_printf(print, translate(" File \"%q\", line %d"), values[i], (int)values[i + 1]); mp_printf(print, decompressed_frame, values[i], (int)values[i + 1]);
#else #else
mp_printf(print, translate(" File \"%q\""), values[i]); mp_printf(print, decompressed_frame, values[i]);
#endif #endif
// the block name can be NULL if it's unknown // the block name can be NULL if it's unknown
qstr block = values[i + 2]; qstr block = values[i + 2];
if (block == MP_QSTR_NULL) { if (block == MP_QSTR_NULL) {
mp_print_str(print, "\n"); mp_print_str(print, "\n");
} else { } else {
mp_printf(print, translate(", in %q\n"), block); mp_printf(print, decompressed_block, block);
} }
} }
} }

8
py/obj.h
View File

@ -34,6 +34,8 @@
#include "py/mpprint.h" #include "py/mpprint.h"
#include "py/runtime0.h" #include "py/runtime0.h"
#include "supervisor/shared/translate.h"
// This is the definition of the opaque MicroPython object type. // This is the definition of the opaque MicroPython object type.
// All concrete objects have an encoding within this type and the // All concrete objects have an encoding within this type and the
// particular encoding is specified by MICROPY_OBJ_REPR. // particular encoding is specified by MICROPY_OBJ_REPR.
@ -639,9 +641,9 @@ mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag);
mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type); mp_obj_t mp_obj_new_exception(const mp_obj_type_t *exc_type);
mp_obj_t mp_obj_new_exception_arg1(const mp_obj_type_t *exc_type, mp_obj_t arg); mp_obj_t mp_obj_new_exception_arg1(const mp_obj_type_t *exc_type, mp_obj_t arg);
mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, size_t n_args, const mp_obj_t *args); mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, size_t n_args, const mp_obj_t *args);
mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg); mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const compressed_string_t *msg);
mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!) mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, ...); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!)
mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, const char *fmt, va_list ap); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!) mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, va_list ap); // counts args by number of % symbols in fmt, excluding %%; can only handle void* sizes (ie no float/double!)
mp_obj_t mp_obj_new_fun_bc(mp_obj_t def_args, mp_obj_t def_kw_args, const byte *code, const mp_uint_t *const_table); mp_obj_t mp_obj_new_fun_bc(mp_obj_t def_args, mp_obj_t def_kw_args, const byte *code, const mp_uint_t *const_table);
mp_obj_t mp_obj_new_fun_native(mp_obj_t def_args_in, mp_obj_t def_kw_args, const void *fun_data, const mp_uint_t *const_table); mp_obj_t mp_obj_new_fun_native(mp_obj_t def_args_in, mp_obj_t def_kw_args, const void *fun_data, const mp_uint_t *const_table);
mp_obj_t mp_obj_new_fun_viper(size_t n_args, void *fun_data, mp_uint_t type_sig); mp_obj_t mp_obj_new_fun_viper(size_t n_args, void *fun_data, mp_uint_t type_sig);

29
py/objexcept.c
View File

@ -114,7 +114,15 @@ void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kin
} else if (o->args->len == 1) { } else if (o->args->len == 1) {
// try to provide a nice OSError error message // try to provide a nice OSError error message
if (o->base.type == &mp_type_OSError && MP_OBJ_IS_SMALL_INT(o->args->items[0])) { if (o->base.type == &mp_type_OSError && MP_OBJ_IS_SMALL_INT(o->args->items[0])) {
const char* msg = mp_errno_to_str(o->args->items[0]); const compressed_string_t* common = mp_common_errno_to_str(o->args->items[0]);
const char* msg;
char decompressed[50];
if (common != NULL && common->length <= 50) {
decompress(common, decompressed);
msg = decompressed;
} else {
msg = mp_errno_to_str(o->args->items[0]);
}
if (msg[0] != '\0') { if (msg[0] != '\0') {
mp_printf(print, "[Errno " INT_FMT "] %s", MP_OBJ_SMALL_INT_VALUE(o->args->items[0]), msg); mp_printf(print, "[Errno " INT_FMT "] %s", MP_OBJ_SMALL_INT_VALUE(o->args->items[0]), msg);
return; return;
@ -311,7 +319,7 @@ mp_obj_t mp_obj_new_exception_args(const mp_obj_type_t *exc_type, size_t n_args,
return exc_type->make_new(exc_type, n_args, 0, args); return exc_type->make_new(exc_type, n_args, 0, args);
} }
mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const char *msg) { mp_obj_t mp_obj_new_exception_msg(const mp_obj_type_t *exc_type, const compressed_string_t *msg) {
return mp_obj_new_exception_msg_varg(exc_type, msg); return mp_obj_new_exception_msg_varg(exc_type, msg);
} }
@ -349,7 +357,7 @@ STATIC void exc_add_strn(void *data, const char *str, size_t len) {
} }
mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...) { mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, ...) {
va_list ap; va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
mp_obj_t exception = mp_obj_new_exception_msg_vlist(exc_type, fmt, ap); mp_obj_t exception = mp_obj_new_exception_msg_vlist(exc_type, fmt, ap);
@ -357,7 +365,7 @@ mp_obj_t mp_obj_new_exception_msg_varg(const mp_obj_type_t *exc_type, const char
return exception; return exception;
} }
mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, const char *fmt, va_list ap) { mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, va_list ap) {
assert(fmt != NULL); assert(fmt != NULL);
// Check that the given type is an exception type // Check that the given type is an exception type
@ -365,7 +373,7 @@ mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, const cha
// Try to allocate memory for the message // Try to allocate memory for the message
mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t); mp_obj_str_t *o_str = m_new_obj_maybe(mp_obj_str_t);
size_t o_str_alloc = strlen(fmt) + 1; size_t o_str_alloc = fmt->length + 1;
byte *o_str_buf = m_new_maybe(byte, o_str_alloc); byte *o_str_buf = m_new_maybe(byte, o_str_alloc);
bool used_emg_buf = false; bool used_emg_buf = false;
@ -391,15 +399,16 @@ mp_obj_t mp_obj_new_exception_msg_vlist(const mp_obj_type_t *exc_type, const cha
} }
if (o_str_buf == NULL) { if (o_str_buf == NULL) {
// No memory for the string buffer: assume that the fmt string is in ROM // No memory for the string buffer: the string is compressed so don't add it.
// and use that data as the data of the string o_str->len = 0;
o_str->len = o_str_alloc - 1; // will be equal to strlen(fmt) o_str->data = NULL;
o_str->data = (const byte*)fmt;
} else { } else {
// We have some memory to format the string // We have some memory to format the string
struct _exc_printer_t exc_pr = {!used_emg_buf, o_str_alloc, 0, o_str_buf}; struct _exc_printer_t exc_pr = {!used_emg_buf, o_str_alloc, 0, o_str_buf};
mp_print_t print = {&exc_pr, exc_add_strn}; mp_print_t print = {&exc_pr, exc_add_strn};
mp_vprintf(&print, fmt, ap); char fmt_decompressed[fmt->length];
decompress(fmt, fmt_decompressed);
mp_vprintf(&print, fmt_decompressed, ap);
exc_pr.buf[exc_pr.len] = '\0'; exc_pr.buf[exc_pr.len] = '\0';
o_str->len = exc_pr.len; o_str->len = exc_pr.len;
o_str->data = exc_pr.buf; o_str->data = exc_pr.buf;

10
py/parsenum.c
View File

@ -148,11 +148,11 @@ overflow:
value_error: value_error:
if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) { if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_ValueError, mp_obj_t exc = mp_obj_new_exception_msg(&mp_type_ValueError,
"invalid syntax for integer"); translate("invalid syntax for integer"));
raise_exc(exc, lex); raise_exc(exc, lex);
} else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL) { } else if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_NORMAL) {
mp_obj_t exc = mp_obj_new_exception_msg_varg(&mp_type_ValueError, mp_obj_t exc = mp_obj_new_exception_msg_varg(&mp_type_ValueError,
"invalid syntax for integer with base %d", base); translate("invalid syntax for integer with base %d"), base);
raise_exc(exc, lex); raise_exc(exc, lex);
} else { } else {
vstr_t vstr; vstr_t vstr;
@ -328,7 +328,7 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool
} }
#else #else
if (imag || force_complex) { 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, translate("complex values not supported")), lex);
} }
#endif #endif
else { else {
@ -336,9 +336,9 @@ mp_obj_t mp_parse_num_decimal(const char *str, size_t len, bool allow_imag, bool
} }
value_error: 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, translate("invalid syntax for number")), lex);
#else #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, translate("decimal numbers not supported")), lex);
#endif #endif
} }

2
py/py.mk
View File

@ -315,7 +315,7 @@ $(HEADER_BUILD)/qstrdefs.enum.h: $(PY_SRC)/makeqstrdata.py $(HEADER_BUILD)/qstrd
# the lines in "" and then unwrap after the preprocessor is finished. # the lines in "" and then unwrap after the preprocessor is finished.
$(HEADER_BUILD)/qstrdefs.generated.h: $(PY_SRC)/makeqstrdata.py $(HEADER_BUILD)/$(TRANSLATION).mo $(HEADER_BUILD)/qstrdefs.preprocessed.h $(HEADER_BUILD)/qstrdefs.generated.h: $(PY_SRC)/makeqstrdata.py $(HEADER_BUILD)/$(TRANSLATION).mo $(HEADER_BUILD)/qstrdefs.preprocessed.h
$(STEPECHO) "GEN $@" $(STEPECHO) "GEN $@"
$(PYTHON3) $(PY_SRC)/makeqstrdata.py --translation $(HEADER_BUILD)/$(TRANSLATION).mo $(HEADER_BUILD)/qstrdefs.preprocessed.h > $@ $(PYTHON3) $(PY_SRC)/makeqstrdata.py --compression_filename $(HEADER_BUILD)/compression.generated.h --translation $(HEADER_BUILD)/$(TRANSLATION).mo $(HEADER_BUILD)/qstrdefs.preprocessed.h > $@
$(PY_BUILD)/qstr.o: $(HEADER_BUILD)/qstrdefs.generated.h $(PY_BUILD)/qstr.o: $(HEADER_BUILD)/qstrdefs.generated.h

2
py/qstr.c
View File

@ -104,7 +104,7 @@ const qstr_pool_t mp_qstr_const_pool = {
{ {
#ifndef NO_QSTR #ifndef NO_QSTR
#define QDEF(id, str) str, #define QDEF(id, str) str,
#define TRANSLATION(id, str) #define TRANSLATION(id, length, compressed...)
#include "genhdr/qstrdefs.generated.h" #include "genhdr/qstrdefs.generated.h"
#undef TRANSLATION #undef TRANSLATION
#undef QDEF #undef QDEF

22
py/runtime.c
View File

@ -1539,7 +1539,7 @@ NORETURN void m_malloc_fail(size_t num_bytes) {
translate("memory allocation failed, allocating %u bytes"), (uint)num_bytes); translate("memory allocation failed, allocating %u bytes"), (uint)num_bytes);
} }
NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg) { NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const compressed_string_t *msg) {
if (msg == NULL) { if (msg == NULL) {
nlr_raise(mp_obj_new_exception(exc_type)); nlr_raise(mp_obj_new_exception(exc_type));
} else { } else {
@ -1547,7 +1547,7 @@ NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg) {
} }
} }
NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...) { NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, ...) {
va_list argptr; va_list argptr;
va_start(argptr,fmt); va_start(argptr,fmt);
mp_obj_t exception = mp_obj_new_exception_msg_vlist(exc_type, fmt, argptr); mp_obj_t exception = mp_obj_new_exception_msg_vlist(exc_type, fmt, argptr);
@ -1555,27 +1555,27 @@ NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const char *fmt,
nlr_raise(exception); nlr_raise(exception);
} }
NORETURN void mp_raise_AttributeError(const char *msg) { NORETURN void mp_raise_AttributeError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_AttributeError, msg); mp_raise_msg(&mp_type_AttributeError, msg);
} }
NORETURN void mp_raise_RuntimeError(const char *msg) { NORETURN void mp_raise_RuntimeError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_RuntimeError, msg); mp_raise_msg(&mp_type_RuntimeError, msg);
} }
NORETURN void mp_raise_ImportError(const char *msg) { NORETURN void mp_raise_ImportError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_ImportError, msg); mp_raise_msg(&mp_type_ImportError, msg);
} }
NORETURN void mp_raise_IndexError(const char *msg) { NORETURN void mp_raise_IndexError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_IndexError, msg); mp_raise_msg(&mp_type_IndexError, msg);
} }
NORETURN void mp_raise_ValueError(const char *msg) { NORETURN void mp_raise_ValueError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_ValueError, msg); mp_raise_msg(&mp_type_ValueError, msg);
} }
NORETURN void mp_raise_ValueError_varg(const char *fmt, ...) { NORETURN void mp_raise_ValueError_varg(const compressed_string_t *fmt, ...) {
va_list argptr; va_list argptr;
va_start(argptr,fmt); va_start(argptr,fmt);
mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_ValueError, fmt, argptr); mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_ValueError, fmt, argptr);
@ -1583,11 +1583,11 @@ NORETURN void mp_raise_ValueError_varg(const char *fmt, ...) {
nlr_raise(exception); nlr_raise(exception);
} }
NORETURN void mp_raise_TypeError(const char *msg) { NORETURN void mp_raise_TypeError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_TypeError, msg); mp_raise_msg(&mp_type_TypeError, msg);
} }
NORETURN void mp_raise_TypeError_varg(const char *fmt, ...) { NORETURN void mp_raise_TypeError_varg(const compressed_string_t *fmt, ...) {
va_list argptr; va_list argptr;
va_start(argptr,fmt); va_start(argptr,fmt);
mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_TypeError, fmt, argptr); mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_TypeError, fmt, argptr);
@ -1600,7 +1600,7 @@ NORETURN void mp_raise_OSError(int errno_) {
} }
NORETURN void mp_raise_NotImplementedError(const char *msg) { NORETURN void mp_raise_NotImplementedError(const compressed_string_t *msg) {
mp_raise_msg(&mp_type_NotImplementedError, msg); mp_raise_msg(&mp_type_NotImplementedError, msg);
} }

22
py/runtime.h
View File

@ -147,18 +147,18 @@ mp_obj_t mp_import_name(qstr name, mp_obj_t fromlist, mp_obj_t level);
mp_obj_t mp_import_from(mp_obj_t module, qstr name); mp_obj_t mp_import_from(mp_obj_t module, qstr name);
void mp_import_all(mp_obj_t module); void mp_import_all(mp_obj_t module);
NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const char *msg); NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const compressed_string_t *msg);
NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const char *fmt, ...); NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, ...);
NORETURN void mp_raise_ValueError(const char *msg); NORETURN void mp_raise_ValueError(const compressed_string_t *msg);
NORETURN void mp_raise_ValueError_varg(const char *fmt, ...); NORETURN void mp_raise_ValueError_varg(const compressed_string_t *fmt, ...);
NORETURN void mp_raise_TypeError(const char *msg); NORETURN void mp_raise_TypeError(const compressed_string_t *msg);
NORETURN void mp_raise_TypeError_varg(const char *fmt, ...); NORETURN void mp_raise_TypeError_varg(const compressed_string_t *fmt, ...);
NORETURN void mp_raise_AttributeError(const char *msg); NORETURN void mp_raise_AttributeError(const compressed_string_t *msg);
NORETURN void mp_raise_RuntimeError(const char *msg); NORETURN void mp_raise_RuntimeError(const compressed_string_t *msg);
NORETURN void mp_raise_ImportError(const char *msg); NORETURN void mp_raise_ImportError(const compressed_string_t *msg);
NORETURN void mp_raise_IndexError(const char *msg); NORETURN void mp_raise_IndexError(const compressed_string_t *msg);
NORETURN void mp_raise_OSError(int errno_); NORETURN void mp_raise_OSError(int errno_);
NORETURN void mp_raise_NotImplementedError(const char *msg); NORETURN void mp_raise_NotImplementedError(const compressed_string_t *msg);
NORETURN void mp_raise_recursion_depth(void); NORETURN void mp_raise_recursion_depth(void);
#if MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG #if MICROPY_BUILTIN_METHOD_CHECK_SELF_ARG

6
py/vm.c
View File

@ -252,7 +252,7 @@ dispatch_loop:
if (obj_shared == MP_OBJ_NULL) { if (obj_shared == MP_OBJ_NULL) {
local_name_error: { local_name_error: {
MARK_EXC_IP_SELECTIVE(); 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, translate("local variable referenced before assignment"));
RAISE(obj); RAISE(obj);
} }
} }
@ -1139,7 +1139,7 @@ unwind_return:
} }
} }
if (obj == MP_OBJ_NULL) { 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, translate("no active exception to reraise"));
RAISE(obj); RAISE(obj);
} }
} else { } else {
@ -1281,7 +1281,7 @@ yield:
} else } else
#endif #endif
{ {
mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, "byte code not implemented"); mp_obj_t obj = mp_obj_new_exception_msg(&mp_type_NotImplementedError, translate("byte code not implemented"));
nlr_pop(); nlr_pop();
fastn[0] = obj; fastn[0] = obj;
return MP_VM_RETURN_EXCEPTION; return MP_VM_RETURN_EXCEPTION;

2
shared-bindings/audiobusio/PDMIn.c
View File

@ -196,7 +196,7 @@ STATIC mp_obj_t audiobusio_pdmin_obj_record(mp_obj_t self_obj, mp_obj_t destinat
mp_buffer_info_t bufinfo; mp_buffer_info_t bufinfo;
if (MP_OBJ_IS_TYPE(destination, &mp_type_fileio)) { if (MP_OBJ_IS_TYPE(destination, &mp_type_fileio)) {
mp_raise_NotImplementedError(""); mp_raise_NotImplementedError(translate("Cannot record to a file"));
} else if (mp_get_buffer(destination, &bufinfo, MP_BUFFER_WRITE)) { } else if (mp_get_buffer(destination, &bufinfo, MP_BUFFER_WRITE)) {
if (bufinfo.len / mp_binary_get_size('@', bufinfo.typecode, NULL) < length) { if (bufinfo.len / mp_binary_get_size('@', bufinfo.typecode, NULL) < length) {
mp_raise_ValueError(translate("Destination capacity is smaller than destination_length.")); mp_raise_ValueError(translate("Destination capacity is smaller than destination_length."));

2
shared-bindings/os/__init__.c
View File

@ -197,7 +197,7 @@ STATIC mp_obj_t os_urandom(mp_obj_t size_in) {
mp_int_t size = mp_obj_get_int(size_in); mp_int_t size = mp_obj_get_int(size_in);
uint8_t tmp[size]; uint8_t tmp[size];
if (!common_hal_os_urandom(tmp, size)) { if (!common_hal_os_urandom(tmp, size)) {
mp_raise_NotImplementedError(""); mp_raise_NotImplementedError(translate("No hardware random available"));
} }
return mp_obj_new_bytes(tmp, size); return mp_obj_new_bytes(tmp, size);
} }

6
shared-module/audioio/WaveFile.c
View File

@ -84,7 +84,7 @@ void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
} }
// Get the sample_rate // Get the sample_rate
self->sample_rate = format.sample_rate; self->sample_rate = format.sample_rate;
self->len = 512; self->len = 256;
self->channel_count = format.num_channels; self->channel_count = format.num_channels;
self->bits_per_sample = format.bits_per_sample; self->bits_per_sample = format.bits_per_sample;
@ -114,13 +114,13 @@ void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
self->buffer = m_malloc(self->len, false); self->buffer = m_malloc(self->len, false);
if (self->buffer == NULL) { if (self->buffer == NULL) {
common_hal_audioio_wavefile_deinit(self); common_hal_audioio_wavefile_deinit(self);
mp_raise_msg(&mp_type_MemoryError, ""); mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate first buffer"));
} }
self->second_buffer = m_malloc(self->len, false); self->second_buffer = m_malloc(self->len, false);
if (self->second_buffer == NULL) { if (self->second_buffer == NULL) {
common_hal_audioio_wavefile_deinit(self); common_hal_audioio_wavefile_deinit(self);
mp_raise_msg(&mp_type_MemoryError, ""); mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate second buffer"));
} }
} }

51
supervisor/shared/translate.c
View File

@ -26,17 +26,58 @@
#include "supervisor/shared/translate.h" #include "supervisor/shared/translate.h"
#include <stdbool.h>
#include <stdint.h>
#include <string.h> #include <string.h>
inline __attribute__((always_inline)) const char* translate(const char* c) { #ifndef NO_QSTR
#include "genhdr/compression.generated.h"
#endif
char* decompress(const compressed_string_t* compressed, char* decompressed) {
uint8_t this_byte = 0;
uint8_t this_bit = 7;
uint8_t b = compressed->data[this_byte];
// Stop one early because the last byte is always NULL.
for (uint16_t i = 0; i < compressed->length - 1; i++) {
uint32_t bits = 0;
uint8_t bit_length = 0;
uint32_t max_code = lengths[0];
uint32_t searched_length = lengths[0];
while (true) {
bits <<= 1;
if ((0x80 & b) != 0) {
bits |= 1;
}
b <<= 1;
bit_length += 1;
if (this_bit == 0) {
this_bit = 7;
this_byte += 1;
b = compressed->data[this_byte]; // This may read past the end but its never used.
} else {
this_bit -= 1;
}
if (max_code > 0 && bits < max_code) {
break;
}
max_code = (max_code << 1) + lengths[bit_length];
searched_length += lengths[bit_length];
}
decompressed[i] = values[searched_length + bits - max_code];
}
decompressed[compressed->length-1] = '\0';
return decompressed;
}
inline __attribute__((always_inline)) const compressed_string_t* translate(const char* original) {
#ifndef NO_QSTR #ifndef NO_QSTR
#define QDEF(id, str) #define QDEF(id, str)
#define TRANSLATION(id, str) if (strcmp(c, id) == 0) { return str; } else #define TRANSLATION(id, len, compressed...) if (strcmp(original, id) == 0) { static const compressed_string_t v = {.length = len, .data = compressed}; return &v; } else
#include "genhdr/qstrdefs.generated.h" #include "genhdr/qstrdefs.generated.h"
#undef TRANSLATION #undef TRANSLATION
#undef QDEF #undef QDEF
#endif #endif
{ return NULL;
return "";
}
} }

11
supervisor/shared/translate.h
View File

@ -27,6 +27,15 @@
#ifndef MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H #ifndef MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H
#define MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H #define MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H
const char* translate(const char* c); #include <stdint.h>
typedef struct {
uint16_t length;
const uint8_t data[];
} compressed_string_t;
const compressed_string_t* translate(const char* c);
char* decompress(const compressed_string_t* compressed, char* decompressed);
#endif // MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H #endif // MICROPY_INCLUDED_SUPERVISOR_TRANSLATE_H

1
tools/huffman Submodule

@ -0,0 +1 @@
Subproject commit 27b1bba76198a0b343f694a6d680b5293d1c56aa