Merge pull request #8542 from jepler/mp-error-text

Switch to using MP_ERROR_TEXT instead of translate, globally

Author: dhalbert

Makefile

@@ -227,7 +227,7 @@ pseudoxml:
 all-source:
 
 locale/circuitpython.pot: all-source
-	find $(TRANSLATE_SOURCES) -type d \( $(TRANSLATE_SOURCES_EXC) \) -prune -o -type f \( -iname "*.c" -o -iname "*.h" \) -print | (LC_ALL=C sort) | xgettext -f- -L C -s --add-location=file --keyword=translate --keyword=MP_ERROR_TEXT -o - | sed -e '/"POT-Creation-Date: /d' > $@
+	find $(TRANSLATE_SOURCES) -type d \( $(TRANSLATE_SOURCES_EXC) \) -prune -o -type f \( -iname "*.c" -o -iname "*.h" \) -print | (LC_ALL=C sort) | xgettext -f- -L C -s --add-location=file --keyword=MP_ERROR_TEXT -o - | sed -e '/"POT-Creation-Date: /d' > $@
 
 # Historically, `make translate` updated the .pot file and ran msgmerge.
 # However, this was a frequent source of merge conflicts.  Weblate can perform

devices/ble_hci/common-hal/_bleio/Adapter.c

@@ -180,7 +180,7 @@ STATIC void add_generic_services(bleio_adapter_obj_t *adapter) {
 
 STATIC void check_enabled(bleio_adapter_obj_t *adapter) {
     if (!common_hal_bleio_adapter_get_enabled(adapter)) {
-        mp_raise_bleio_BluetoothError(translate("Adapter not enabled"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Adapter not enabled"));
     }
 }
 
@@ -297,18 +297,18 @@ STATIC void bleio_adapter_hci_init(bleio_adapter_obj_t *self) {
     // Get version information.
     if (hci_read_local_version(&self->hci_version, &self->hci_revision, &self->lmp_version,
         &self->manufacturer, &self->lmp_subversion) != HCI_OK) {
-        mp_raise_bleio_BluetoothError(translate("Could not read HCI version"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Could not read HCI version"));
     }
     // Get supported features.
     if (hci_le_read_local_supported_features(self->features) != HCI_OK) {
-        mp_raise_bleio_BluetoothError(translate("Could not read BLE features"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Could not read BLE features"));
     }
 
     // Enabled desired events.
     // Most importantly, includes:
     // BT_EVT_MASK_LE_META_EVENT                BT_EVT_BIT(61)
     if (hci_set_event_mask(0x3FFFFFFFFFFFFFFF) != HCI_OK) {
-        mp_raise_bleio_BluetoothError(translate("Could not set event mask"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Could not set event mask"));
     }
     // The default events for LE are:
     // BT_EVT_MASK_LE_CONN_COMPLETE,  BT_EVT_MASK_LE_ADVERTISING_REPORT,
@@ -329,7 +329,7 @@ STATIC void bleio_adapter_hci_init(bleio_adapter_obj_t *self) {
         uint16_t acl_max_num;
         uint16_t sco_max_num;
         if (hci_read_buffer_size(&acl_max_len, &sco_max_len, &acl_max_num, &sco_max_num) != HCI_OK) {
-            mp_raise_bleio_BluetoothError(translate("Could not read BLE buffer info"));
+            mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Could not read BLE buffer info"));
         }
         self->max_acl_buffer_len = acl_max_len;
         self->max_acl_num_buffers = acl_max_num;
@@ -339,7 +339,7 @@ STATIC void bleio_adapter_hci_init(bleio_adapter_obj_t *self) {
     if (BT_FEAT_LE_EXT_ADV(self->features)) {
         uint16_t max_adv_data_len;
         if (hci_le_read_maximum_advertising_data_length(&max_adv_data_len) != HCI_OK) {
-            mp_raise_bleio_BluetoothError(translate("Could not get max advertising length"));
+            mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Could not get max advertising length"));
         }
         self->max_adv_data_len = max_adv_data_len;
     } else {
@@ -472,7 +472,7 @@ mp_obj_t common_hal_bleio_adapter_start_scan(bleio_adapter_obj_t *self, uint8_t
 
     if (self->scan_results != NULL) {
         if (!shared_module_bleio_scanresults_get_done(self->scan_results)) {
-            mp_raise_bleio_BluetoothError(translate("Scan already in progress. Stop with stop_scan."));
+            mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Scan already in progress. Stop with stop_scan."));
         }
         self->scan_results = NULL;
     }
@@ -601,7 +601,7 @@ mp_obj_t common_hal_bleio_adapter_connect(bleio_adapter_obj_t *self, bleio_addre
 
     // uint16_t conn_handle = event_info.conn_handle;
     // if (conn_handle == BLE_CONN_HANDLE_INVALID) {
-    //     mp_raise_bleio_BluetoothError(translate("Failed to connect: timeout"));
+    //     mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Failed to connect: timeout"));
     // }
 
     // // Negotiate for better PHY, larger MTU and data lengths since we are the central. These are
@@ -622,14 +622,14 @@ mp_obj_t common_hal_bleio_adapter_connect(bleio_adapter_obj_t *self, bleio_addre
     //     }
     // }
 
-    mp_raise_bleio_BluetoothError(translate("Failed to connect: internal error"));
+    mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Failed to connect: internal error"));
 
     return mp_const_none;
 }
 
 STATIC void check_data_fit(size_t data_len, bool connectable) {
     if (data_len > MAX_ADVERTISEMENT_SIZE) {
-        mp_raise_ValueError(translate("Data too large for advertisement packet"));
+        mp_raise_ValueError(MP_ERROR_TEXT("Data too large for advertisement packet"));
     }
 }
 
@@ -686,7 +686,7 @@ uint32_t _common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
 
     if (extended) {
         if (!BT_FEAT_LE_EXT_ADV(self->features)) {
-            mp_raise_bleio_BluetoothError(translate("Data length needs extended advertising, but this adapter does not support it"));
+            mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Data length needs extended advertising, but this adapter does not support it"));
         }
 
         uint16_t props = 0;
@@ -801,7 +801,7 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
     check_data_fit(scan_response_data_bufinfo->len, connectable);
 
     if (advertising_data_bufinfo->len > MAX_ADVERTISEMENT_SIZE && scan_response_data_bufinfo->len > 0) {
-        mp_raise_bleio_BluetoothError(translate("Extended advertisements with scan response not supported."));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Extended advertisements with scan response not supported."));
     }
 
     // Anonymous mode requires a timeout so that we don't continue to broadcast
@@ -811,13 +811,13 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
         timeout = MAX_ANONYMOUS_ADV_TIMEOUT_SECS;
     } else {
         if (timeout > MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS) {
-            mp_raise_bleio_BluetoothError(translate("Timeout is too long: Maximum timeout length is %d seconds"),
+            mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Timeout is too long: Maximum timeout length is %d seconds"),
                 MAX_LIMITED_DISCOVERABLE_ADV_TIMEOUT_SECS);
         }
     }
 
     if (tx_power != 0) {
-        mp_raise_NotImplementedError(translate("Only tx_power=0 supported"));
+        mp_raise_NotImplementedError(MP_ERROR_TEXT("Only tx_power=0 supported"));
     }
 
     const uint32_t result = _common_hal_bleio_adapter_start_advertising(
@@ -829,7 +829,7 @@ void common_hal_bleio_adapter_start_advertising(bleio_adapter_obj_t *self,
         tx_power, directed_to);
 
     if (result) {
-        mp_raise_bleio_BluetoothError(translate("Already advertising"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Already advertising"));
     }
     self->circuitpython_advertising = false;
 }

devices/ble_hci/common-hal/_bleio/Attribute.c

@@ -45,5 +45,5 @@ bleio_uuid_obj_t *bleio_attribute_get_uuid(mp_obj_t *attribute) {
         bleio_service_obj_t *service = MP_OBJ_TO_PTR(attribute);
         return service->uuid;
     }
-    mp_raise_RuntimeError(translate("Invalid BLE attribute"));
+    mp_raise_RuntimeError(MP_ERROR_TEXT("Invalid BLE attribute"));
 }

devices/ble_hci/common-hal/_bleio/Characteristic.c

@@ -108,10 +108,10 @@ size_t common_hal_bleio_characteristic_get_value(bleio_characteristic_obj_t *sel
 
 void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self, mp_buffer_info_t *bufinfo) {
     if (self->fixed_length && bufinfo->len != self->max_length) {
-        mp_raise_ValueError(translate("Value length != required fixed length"));
+        mp_raise_ValueError(MP_ERROR_TEXT("Value length != required fixed length"));
     }
     if (bufinfo->len > self->max_length) {
-        mp_raise_ValueError(translate("Value length > max_length"));
+        mp_raise_ValueError(MP_ERROR_TEXT("Value length > max_length"));
     }
 
     // Do GATT operations only if this characteristic has been added to a registered service.
@@ -125,7 +125,7 @@ void common_hal_bleio_characteristic_set_value(bleio_characteristic_obj_t *self,
             } else if (self->props & CHAR_PROP_WRITE_NO_RESPONSE) {
                 // att_write_cmd(conn_handle, self->handle, bufinfo->buff, bufinfo->len);
             } else {
-                mp_raise_bleio_BluetoothError(translate("Characteristic not writable"));
+                mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Characteristic not writable"));
             }
         } else {
             // Always write the value locally even if no connections are active.
@@ -168,7 +168,7 @@ bleio_characteristic_properties_t common_hal_bleio_characteristic_get_properties
 void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *self, bleio_descriptor_obj_t *descriptor) {
     if (self->handle != common_hal_bleio_adapter_obj.last_added_characteristic_handle) {
         mp_raise_bleio_BluetoothError(
-            translate("Descriptor can only be added to most recently added characteristic"));
+            MP_ERROR_TEXT("Descriptor can only be added to most recently added characteristic"));
     }
 
     descriptor->handle = bleio_adapter_add_attribute(&common_hal_bleio_adapter_obj, MP_OBJ_TO_PTR(descriptor));
@@ -181,11 +181,11 @@ void common_hal_bleio_characteristic_add_descriptor(bleio_characteristic_obj_t *
 
 void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self, bool notify, bool indicate) {
     if (self->cccd == NULL) {
-        mp_raise_bleio_BluetoothError(translate("No CCCD for this Characteristic"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("No CCCD for this Characteristic"));
     }
 
     if (!common_hal_bleio_service_get_is_remote(self->service)) {
-        mp_raise_bleio_RoleError(translate("Can't set CCCD on local Characteristic"));
+        mp_raise_bleio_RoleError(MP_ERROR_TEXT("Can't set CCCD on local Characteristic"));
     }
 
     const uint16_t conn_handle = bleio_connection_get_conn_handle(self->service->connection);
@@ -199,7 +199,7 @@ void common_hal_bleio_characteristic_set_cccd(bleio_characteristic_obj_t *self,
     (void)cccd_value;
     // uint8_t rsp[sizeof(bt_att_error_rsp)];
     // if (att_write_req(conn_handle, self->cccd->handle, &cccd_value, sizeof(cccd_value)) == 0) {
-    //     mp_raise_bleio_BluetoothError(translate("Could not write CCCD"));
+    //     mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Could not write CCCD"));
     // }
 }
 

devices/ble_hci/common-hal/_bleio/Connection.c

@@ -640,7 +640,7 @@ void common_hal_bleio_connection_set_connection_interval(bleio_connection_intern
 //         mp_obj_t uuid_obj;
 //         while ((uuid_obj = mp_iternext(iterable)) != MP_OBJ_STOP_ITERATION) {
 //             if (!mp_obj_is_type(uuid_obj, &bleio_uuid_type)) {
-//                 mp_raise_TypeError(translate("non-UUID found in service_uuids_whitelist"));
+//                 mp_raise_TypeError(MP_ERROR_TEXT("non-UUID found in service_uuids_whitelist"));
 //             }
 //             bleio_uuid_obj_t *uuid = MP_OBJ_TO_PTR(uuid_obj);
 

devices/ble_hci/common-hal/_bleio/Descriptor.c

@@ -43,7 +43,7 @@ void common_hal_bleio_descriptor_construct(bleio_descriptor_obj_t *self, bleio_c
 
     const mp_int_t max_length_max = fixed_length ? BLE_GATTS_FIX_ATTR_LEN_MAX : BLE_GATTS_VAR_ATTR_LEN_MAX;
     if (max_length < 0 || max_length > max_length_max) {
-        mp_raise_ValueError_varg(translate("max_length must be 0-%d when fixed_length is %s"),
+        mp_raise_ValueError_varg(MP_ERROR_TEXT("max_length must be 0-%d when fixed_length is %s"),
             max_length_max, fixed_length ? "True" : "False");
     }
     self->max_length = max_length;
@@ -85,10 +85,10 @@ size_t common_hal_bleio_descriptor_get_value(bleio_descriptor_obj_t *self, uint8
 
 void common_hal_bleio_descriptor_set_value(bleio_descriptor_obj_t *self, mp_buffer_info_t *bufinfo) {
     if (self->fixed_length && bufinfo->len != self->max_length) {
-        mp_raise_ValueError(translate("Value length != required fixed length"));
+        mp_raise_ValueError(MP_ERROR_TEXT("Value length != required fixed length"));
     }
     if (bufinfo->len > self->max_length) {
-        mp_raise_ValueError(translate("Value length > max_length"));
+        mp_raise_ValueError(MP_ERROR_TEXT("Value length > max_length"));
     }
 
     self->value = mp_obj_new_bytes(bufinfo->buf, bufinfo->len);

devices/ble_hci/common-hal/_bleio/PacketBuffer.c

@@ -102,7 +102,7 @@ void common_hal_bleio_packet_buffer_construct(
 
     if (incoming) {
         if (!ringbuf_alloc(&self->ringbuf, buffer_size * (sizeof(uint16_t) + max_packet_size))) {
-            mp_raise_ValueError(translate("Buffer too large and unable to allocate"));
+            mp_raise_ValueError(MP_ERROR_TEXT("Buffer too large and unable to allocate"));
         }
     }
 
@@ -151,7 +151,7 @@ mp_int_t common_hal_bleio_packet_buffer_readinto(bleio_packet_buffer_obj_t *self
 mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self,
     const uint8_t *data, size_t len, uint8_t *header, size_t header_len) {
     if (self->outgoing[0] == NULL) {
-        mp_raise_bleio_BluetoothError(translate("Writes not supported on Characteristic"));
+        mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Writes not supported on Characteristic"));
     }
     if (self->conn_handle == BLE_CONN_HANDLE_INVALID) {
         return -1;
@@ -160,7 +160,7 @@ mp_int_t common_hal_bleio_packet_buffer_write(bleio_packet_buffer_obj_t *self,
 
     if (len + header_len > outgoing_packet_length) {
         // Supplied data will not fit in a single BLE packet.
-        mp_raise_ValueError(translate("Total data to write is larger than outgoing_packet_length"));
+        mp_raise_ValueError(MP_ERROR_TEXT("Total data to write is larger than outgoing_packet_length"));
     }
 
     if (len + self->pending_size > outgoing_packet_length) {

devices/ble_hci/common-hal/_bleio/Service.c

@@ -53,7 +53,7 @@ uint32_t _common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uu
 void common_hal_bleio_service_construct(bleio_service_obj_t *self, bleio_uuid_obj_t *uuid, bool is_secondary) {
     if (_common_hal_bleio_service_construct(self, uuid, is_secondary,
         mp_obj_new_list(0, NULL)) != 0) {
-        mp_raise_RuntimeError(translate("Failed to add service"));
+        mp_raise_RuntimeError(MP_ERROR_TEXT("Failed to add service"));
     }
 }
 
@@ -89,7 +89,7 @@ void common_hal_bleio_service_add_characteristic(bleio_service_obj_t *self,
 
     if (self->handle != common_hal_bleio_adapter_obj.last_added_service_handle) {
         mp_raise_bleio_BluetoothError(
-            translate("Characteristic can only be added to most recently added service"));
+            MP_ERROR_TEXT("Characteristic can only be added to most recently added service"));
     }
     characteristic->decl_handle = bleio_adapter_add_attribute(
         &common_hal_bleio_adapter_obj, MP_OBJ_TO_PTR(characteristic));

devices/ble_hci/common-hal/_bleio/__init__.c

@@ -50,10 +50,10 @@ bool vm_used_ble;
 
 //     switch (sec_status) {
 //         case BLE_GAP_SEC_STATUS_UNSPECIFIED:
-//             mp_raise_bleio_SecurityError(translate("Unspecified issue. Can be that the pairing prompt on the other device was declined or ignored."));
+//             mp_raise_bleio_SecurityError(MP_ERROR_TEXT("Unspecified issue. Can be that the pairing prompt on the other device was declined or ignored."));
 //             return;
 //         default:
-//             mp_raise_bleio_SecurityError(translate("Unknown security error: 0x%04x"), sec_status);
+//             mp_raise_bleio_SecurityError(MP_ERROR_TEXT("Unknown security error: 0x%04x"), sec_status);
 //     }
 // }
 
@@ -96,14 +96,14 @@ bleio_adapter_obj_t common_hal_bleio_adapter_obj = {
 
 bleio_adapter_obj_t *common_hal_bleio_allocate_adapter_or_raise(void) {
     if (common_hal_bleio_adapter_obj.allocated) {
-        mp_raise_RuntimeError(translate("Too many Adapters"));
+        mp_raise_RuntimeError(MP_ERROR_TEXT("Too many Adapters"));
     }
     return &common_hal_bleio_adapter_obj;
 }
 
 void common_hal_bleio_check_connected(uint16_t conn_handle) {
     if (conn_handle == BLE_CONN_HANDLE_INVALID) {
-        mp_raise_ConnectionError(translate("Not connected"));
+        mp_raise_ConnectionError(MP_ERROR_TEXT("Not connected"));
     }
 }
 

devices/ble_hci/common-hal/_bleio/att.c

@@ -1727,52 +1727,52 @@ static void check_att_err(uint8_t err) {
         case 0:
             return;
         case BT_ATT_ERR_INVALID_HANDLE:
-            msg = translate("Invalid handle");
+            msg = MP_ERROR_TEXT("Invalid handle");
             break;
         case BT_ATT_ERR_READ_NOT_PERMITTED:
-            msg = translate("Read not permitted");
+            msg = MP_ERROR_TEXT("Read not permitted");
             break;
         case BT_ATT_ERR_WRITE_NOT_PERMITTED:
-            msg = translate("Write not permitted");
+            msg = MP_ERROR_TEXT("Write not permitted");
             break;
         case BT_ATT_ERR_INVALID_PDU:
-            msg = translate("Invalid PDU");
+            msg = MP_ERROR_TEXT("Invalid PDU");
             break;
         case BT_ATT_ERR_NOT_SUPPORTED:
-            msg = translate("Not supported");
+            msg = MP_ERROR_TEXT("Not supported");
             break;
         case BT_ATT_ERR_INVALID_OFFSET:
-            msg = translate("Invalid offset");
+            msg = MP_ERROR_TEXT("Invalid offset");
             break;
         case BT_ATT_ERR_PREPARE_QUEUE_FULL:
-            msg = translate("Prepare queue full");
+            msg = MP_ERROR_TEXT("Prepare queue full");
             break;
         case BT_ATT_ERR_ATTRIBUTE_NOT_FOUND:
-            msg = translate("Attribute not found");
+            msg = MP_ERROR_TEXT("Attribute not found");
             break;
         case BT_ATT_ERR_ATTRIBUTE_NOT_LONG:
-            msg = translate("Attribute not long");
+            msg = MP_ERROR_TEXT("Attribute not long");
             break;
         case BT_ATT_ERR_ENCRYPTION_KEY_SIZE:
-            msg = translate("Encryption key size");
+            msg = MP_ERROR_TEXT("Encryption key size");
             break;
         case BT_ATT_ERR_INVALID_ATTRIBUTE_LEN:
-            msg = translate("Invalid attribute length");
+            msg = MP_ERROR_TEXT("Invalid attribute length");
             break;
         case BT_ATT_ERR_UNLIKELY:
-            msg = translate("Unlikely");
+            msg = MP_ERROR_TEXT("Unlikely");
             break;
         case BT_ATT_ERR_UNSUPPORTED_GROUP_TYPE:
-            msg = translate("Unsupported group type");
+            msg = MP_ERROR_TEXT("Unsupported group type");
             break;
         case BT_ATT_ERR_INSUFFICIENT_RESOURCES:
-            msg = translate("Insufficient resources");
+            msg = MP_ERROR_TEXT("Insufficient resources");
             break;
         case BT_ATT_ERR_DB_OUT_OF_SYNC:
-            msg = translate("DB out of sync");
+            msg = MP_ERROR_TEXT("DB out of sync");
             break;
         case BT_ATT_ERR_VALUE_NOT_ALLOWED:
-            msg = translate("Value not allowed");
+            msg = MP_ERROR_TEXT("Value not allowed");
             break;
     }
     if (msg) {
@@ -1781,15 +1781,15 @@ static void check_att_err(uint8_t err) {
 
     switch (err) {
         case BT_ATT_ERR_AUTHENTICATION:
-            msg = translate("Insufficient authentication");
+            msg = MP_ERROR_TEXT("Insufficient authentication");
             break;
         case BT_ATT_ERR_INSUFFICIENT_ENCRYPTION:
-            msg = translate("Insufficient encryption");
+            msg = MP_ERROR_TEXT("Insufficient encryption");
             break;
     }
     if (msg) {
         mp_raise_bleio_SecurityError(msg);
     }
 
-    mp_raise_bleio_BluetoothError(translate("Unknown ATT error: 0x%02x"), err);
+    mp_raise_bleio_BluetoothError(MP_ERROR_TEXT("Unknown ATT error: 0x%02x"), err);
 }