codal_port: Enable MICROPY_ROM_TEXT_COMPRESSION.

Reduces the firmware by about 1800 bytes.

Signed-off-by: Damien George <damien@micropython.org>

Author: dpgeorge

src/codal_port/Makefile

@@ -1,5 +1,6 @@
 # Makefile to build libmicropython.a
 
+MICROPY_ROM_TEXT_COMPRESSION ?= 1
 FROZEN_MANIFEST ?= manifest.py
 
 CROSS_COMPILE = arm-none-eabi-

src/codal_port/drv_display.c

@@ -93,7 +93,7 @@ static void draw_object(mp_obj_t obj) {
             async_stop();
         }
     } else {
-        mp_sched_schedule_exception(mp_obj_new_exception_msg(&mp_type_TypeError, "not an image"));
+        mp_sched_schedule_exception(mp_obj_new_exception_msg(&mp_type_TypeError, MP_ERROR_TEXT("not an image")));
         async_stop();
     }
 }

src/codal_port/microbit_accelerometer.c

@@ -62,7 +62,7 @@ STATIC uint32_t gesture_from_obj(mp_obj_t gesture_in) {
             return i;
         }
     }
-    mp_raise_ValueError("invalid gesture");
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid gesture"));
 }
 
 STATIC void update_for_gesture(void) {

src/codal_port/microbit_display.c

@@ -170,10 +170,10 @@ MP_DEFINE_CONST_FUN_OBJ_1(microbit_display_clear_obj, microbit_display_clear_fun
 
 void microbit_display_set_pixel(microbit_display_obj_t *display, mp_int_t x, mp_int_t y, mp_int_t bright) {
     if (x < 0 || y < 0 || x >= MICROBIT_DISPLAY_WIDTH || y >= MICROBIT_DISPLAY_HEIGHT) {
-        mp_raise_ValueError("index out of bounds");
+        mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds"));
     }
     if (bright < 0 || bright > MICROBIT_DISPLAY_MAX_BRIGHTNESS) {
-        mp_raise_ValueError("brightness out of bounds");
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds"));
     }
     microbit_hal_display_set_pixel(x, y, bright);
 }
@@ -188,7 +188,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_display_set_pixel_obj, 4, 4, microb
 
 mp_int_t microbit_display_get_pixel(microbit_display_obj_t *display, mp_int_t x, mp_int_t y) {
     if (x < 0 || y < 0 || x >= MICROBIT_DISPLAY_WIDTH || y >= MICROBIT_DISPLAY_HEIGHT) {
-        mp_raise_ValueError("index out of bounds");
+        mp_raise_ValueError(MP_ERROR_TEXT("index out of bounds"));
     }
     return microbit_hal_display_get_pixel(x, y);
 }

src/codal_port/microbit_image.c

@@ -68,7 +68,7 @@ STATIC microbit_image_obj_t *image_from_parsed_str(const char *s, mp_int_t len)
         } else if ('c' >= '0' && c <= '9') {
             ++line_len;
         } else {
-            mp_raise_ValueError("unexpected character in Image definition");
+            mp_raise_ValueError(MP_ERROR_TEXT("unexpected character in Image definition"));
         }
     }
     if (line_len) {
@@ -133,7 +133,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
                     return image_from_parsed_str(str, len);
                 }
             } else {
-                mp_raise_TypeError("Image(s) takes a string");
+                mp_raise_TypeError(MP_ERROR_TEXT("Image(s) takes a string"));
             }
         }
 
@@ -149,7 +149,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
                 mp_get_buffer_raise(args[2], &bufinfo, MP_BUFFER_READ);
 
                 if (w < 0 || h < 0 || (size_t)(w * h) != bufinfo.len) {
-                    mp_raise_ValueError("image data is incorrect size");
+                    mp_raise_ValueError(MP_ERROR_TEXT("image data is incorrect size"));
                 }
                 mp_int_t i = 0;
                 for (mp_int_t y = 0; y < h; y++) {
@@ -164,7 +164,7 @@ STATIC mp_obj_t microbit_image_make_new(const mp_obj_type_t *type_in, mp_uint_t
         }
 
         default: {
-            mp_raise_TypeError("Image() takes 0 to 3 arguments");
+            mp_raise_TypeError(MP_ERROR_TEXT("Image() takes 0 to 3 arguments"));
         }
     }
 }
@@ -205,19 +205,19 @@ mp_obj_t microbit_image_get_pixel(mp_obj_t self_in, mp_obj_t x_in, mp_obj_t y_in
     mp_int_t x = mp_obj_get_int(x_in);
     mp_int_t y = mp_obj_get_int(y_in);
     if (x < 0 || y < 0) {
-        mp_raise_ValueError("index cannot be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("index cannot be negative"));
     }
     if (x < image_width(self) && y < image_height(self)) {
         return MP_OBJ_NEW_SMALL_INT(image_get_pixel(self, x, y));
     }
-    mp_raise_ValueError("index too large");
+    mp_raise_ValueError(MP_ERROR_TEXT("index too large"));
 }
 MP_DEFINE_CONST_FUN_OBJ_3(microbit_image_get_pixel_obj, microbit_image_get_pixel);
 
 /* Raise an exception if not mutable */
 static void check_mutability(microbit_image_obj_t *self) {
     if (self->base.five) {
-        mp_raise_TypeError("image cannot be modified (try copying first)");
+        mp_raise_TypeError(MP_ERROR_TEXT("image cannot be modified (try copying first)"));
     }
 }
 
@@ -228,17 +228,17 @@ mp_obj_t microbit_image_set_pixel(mp_uint_t n_args, const mp_obj_t *args) {
     mp_int_t x = mp_obj_get_int(args[1]);
     mp_int_t y = mp_obj_get_int(args[2]);
     if (x < 0 || y < 0) {
-        mp_raise_ValueError("index cannot be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("index cannot be negative"));
     }
     mp_int_t bright = mp_obj_get_int(args[3]);
     if (bright < 0 || bright > MICROBIT_DISPLAY_MAX_BRIGHTNESS) {
-        mp_raise_ValueError("brightness out of bounds");
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds"));
     }
     if (x < image_width(self) && y < image_height(self)) {
         greyscale_set_pixel(&self->greyscale, x, y, bright);
         return mp_const_none;
     }
-    mp_raise_ValueError("index too large");
+    mp_raise_ValueError(MP_ERROR_TEXT("index too large"));
 }
 MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(microbit_image_set_pixel_obj, 4, 4, microbit_image_set_pixel);
 
@@ -247,7 +247,7 @@ mp_obj_t microbit_image_fill(mp_obj_t self_in, mp_obj_t n_in) {
     check_mutability(self);
     mp_int_t n = mp_obj_get_int(n_in);
     if (n < 0 || n > MICROBIT_DISPLAY_MAX_BRIGHTNESS) {
-        mp_raise_ValueError("brightness out of bounds");
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness out of bounds"));
     }
     greyscale_fill(&self->greyscale, n);
     return mp_const_none;
@@ -260,17 +260,17 @@ mp_obj_t microbit_image_blit(mp_uint_t n_args, const mp_obj_t *args) {
 
     mp_obj_t src = args[1];
     if (mp_obj_get_type(src) != &microbit_image_type) {
-        mp_raise_TypeError("expecting an image");
+        mp_raise_TypeError(MP_ERROR_TEXT("expecting an image"));
     }
     if (n_args == 7) {
-        mp_raise_TypeError("must specify both offsets");
+        mp_raise_TypeError(MP_ERROR_TEXT("must specify both offsets"));
     }
     mp_int_t x = mp_obj_get_int(args[2]);
     mp_int_t y = mp_obj_get_int(args[3]);
     mp_int_t w = mp_obj_get_int(args[4]);
     mp_int_t h = mp_obj_get_int(args[5]);
     if (w < 0 || h < 0) {
-        mp_raise_ValueError("size cannot be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("size cannot be negative"));
     }
     mp_int_t xdest;
     mp_int_t ydest;
@@ -450,7 +450,7 @@ microbit_image_obj_t *microbit_image_for_char(char c) {
 
 microbit_image_obj_t *microbit_image_dim(microbit_image_obj_t *lhs, mp_float_t fval) {
     if (fval < 0) {
-        mp_raise_ValueError("brightness multiplier must not be negative");
+        mp_raise_ValueError(MP_ERROR_TEXT("brightness multiplier must not be negative"));
     }
     greyscale_t *result = greyscale_new(image_width(lhs), image_height(lhs));
     for (int x = 0; x < image_width(lhs); ++x) {
@@ -466,7 +466,7 @@ STATIC microbit_image_obj_t *microbit_image_sum(microbit_image_obj_t *lhs, micro
     mp_int_t h = image_height(lhs);
     mp_int_t w = image_width(lhs);
     if (image_height(rhs) != h || image_width(rhs) != w) {
-        mp_raise_ValueError("images must be the same size");
+        mp_raise_ValueError(MP_ERROR_TEXT("images must be the same size"));
     }
     greyscale_t *result = greyscale_new(w, h);
     for (int x = 0; x < w; ++x) {

src/codal_port/microbit_microphone.c

@@ -78,7 +78,7 @@ STATIC uint8_t sound_event_from_obj(mp_obj_t sound) {
             return i;
         }
     }
-    mp_raise_ValueError("invalid sound");
+    mp_raise_ValueError(MP_ERROR_TEXT("invalid sound"));
 }
 
 STATIC mp_obj_t microbit_microphone_set_threshold(mp_obj_t self_in, mp_obj_t sound_in, mp_obj_t value_in) {
@@ -90,7 +90,7 @@ STATIC mp_obj_t microbit_microphone_set_threshold(mp_obj_t self_in, mp_obj_t sou
     } else if (sound == SOUND_EVENT_LOUD) {
         kind = 1;
     } else {
-        mp_raise_ValueError("invalid sound");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid sound"));
     }
     int value = mp_obj_get_int(value_in);
     microphone_init();

src/codal_port/microbit_pin.c

@@ -61,7 +61,7 @@ mp_obj_t microbit_pin_write_digital(mp_obj_t self_in, mp_obj_t value_in) {
     microbit_pin_obj_t *self = (microbit_pin_obj_t*)self_in;
     int val = mp_obj_get_int(value_in);
     if (val >> 1) {
-        mp_raise_ValueError("value must be 0 or 1");
+        mp_raise_ValueError(MP_ERROR_TEXT("value must be 0 or 1"));
     }
     if (microbit_obj_pin_acquire(self, microbit_pin_mode_write_digital)) {
     }
@@ -109,7 +109,7 @@ mp_obj_t microbit_pin_write_analog(mp_obj_t self_in, mp_obj_t value_in) {
         set_value = mp_obj_get_int(value_in);
     }
     if (set_value < 0 || set_value > 1023) {
-        mp_raise_ValueError("value must be between 0 and 1023");
+        mp_raise_ValueError(MP_ERROR_TEXT("value must be between 0 and 1023"));
     }
     if (microbit_obj_pin_acquire(self, microbit_pin_mode_write_analog)) {
     }
@@ -132,7 +132,7 @@ mp_obj_t microbit_pin_set_analog_period(mp_obj_t self_in, mp_obj_t period_in) {
     microbit_pin_obj_t *self = (microbit_pin_obj_t*)self_in;
     mp_int_t period = mp_obj_get_int(period_in) * 1000;
     if (microbit_hal_pin_set_analog_period_us(self->name, period) == -1) {
-        mp_raise_ValueError("invalid period");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid period"));
     }
     return mp_const_none;
 }
@@ -142,7 +142,7 @@ mp_obj_t microbit_pin_set_analog_period_microseconds(mp_obj_t self_in, mp_obj_t
     microbit_pin_obj_t *self = (microbit_pin_obj_t*)self_in;
     mp_int_t period = mp_obj_get_int(period_in);
     if (microbit_hal_pin_set_analog_period_us(self->name, period) == -1) {
-        mp_raise_ValueError("invalid period");
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid period"));
     }
     return mp_const_none;
 }
@@ -269,7 +269,7 @@ const microbit_pin_obj_t *microbit_obj_get_pin(mp_const_obj_t o) {
     if (type == &microbit_touch_pin_type || type == &microbit_ad_pin_type || type == &microbit_dig_pin_type) {
         return (microbit_pin_obj_t*)o;
     } else {
-        mp_raise_TypeError("expecting a pin");
+        mp_raise_TypeError(MP_ERROR_TEXT("expecting a pin"));
     }
 }
 

src/codal_port/microbit_pinaudio.c

@@ -36,7 +36,7 @@ void microbit_pin_audio_select(mp_const_obj_t select) {
     if (select == mp_const_none) {
         pin_selected = NULL;
     } else if (select == MP_OBJ_FROM_PTR(&microbit_pin_speaker_obj)) {
-        mp_raise_ValueError("pin_speaker not allowed");
+        mp_raise_ValueError(MP_ERROR_TEXT("pin_speaker not allowed"));
     } else {
         pin_selected = microbit_obj_get_pin((mp_obj_t)select);
     }

src/codal_port/microbit_pinmode.c

@@ -77,7 +77,7 @@ static void noop(const microbit_pin_obj_t *pin) {
 
 void pinmode_error(const microbit_pin_obj_t *pin) {
     const microbit_pinmode_t *current_mode = microbit_pin_get_mode(pin);
-    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Pin %d in %q mode", pin->number, current_mode->name));
+    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("Pin %d in %q mode"), pin->number, current_mode->name));
 }
 
 static void analog_release(const microbit_pin_obj_t *pin) {

src/codal_port/microbit_spi.c

@@ -38,7 +38,7 @@ STATIC bool microbit_spi_initialised = false;
 
 STATIC void microbit_spi_check_initialised(void) {
     if (!microbit_spi_initialised) {
-        mp_raise_ValueError("SPI not initialised");
+        mp_raise_ValueError(MP_ERROR_TEXT("SPI not initialised"));
     }
 }
 
@@ -125,7 +125,7 @@ STATIC mp_obj_t microbit_spi_write_readinto(mp_obj_t self_in, mp_obj_t write_buf
     mp_buffer_info_t read_bufinfo;
     mp_get_buffer_raise(read_buf, &read_bufinfo, MP_BUFFER_WRITE);
     if (write_bufinfo.len != read_bufinfo.len) {
-        mp_raise_ValueError("write and read buffers must be the same length");
+        mp_raise_ValueError(MP_ERROR_TEXT("write and read buffers must be the same length"));
     }
     microbit_hal_spi_transfer(write_bufinfo.len, write_bufinfo.buf, read_bufinfo.buf);
     return mp_const_none;