Latest arch uncrustify

extmod/vfs_blockdev.c

@@ -51,7 +51,7 @@ int mp_vfs_blockdev_read(mp_vfs_blockdev_t *self, size_t block_num, size_t num_b
         mp_uint_t (*f)(uint8_t *, uint32_t, uint32_t) = (void *)(uintptr_t)self->readblocks[2];
         return f(buf, block_num, num_blocks);
     } else {
-        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, num_blocks *self->block_size, buf};
+        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, num_blocks * self->block_size, buf};
         self->readblocks[2] = MP_OBJ_NEW_SMALL_INT(block_num);
         self->readblocks[3] = MP_OBJ_FROM_PTR(&ar);
         mp_call_method_n_kw(2, 0, self->readblocks);
@@ -83,7 +83,7 @@ int mp_vfs_blockdev_write(mp_vfs_blockdev_t *self, size_t block_num, size_t num_
         mp_uint_t (*f)(const uint8_t *, uint32_t, uint32_t) = (void *)(uintptr_t)self->writeblocks[2];
         return f(buf, block_num, num_blocks);
     } else {
-        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, num_blocks *self->block_size, (void *)buf};
+        mp_obj_array_t ar = {{&mp_type_bytearray}, BYTEARRAY_TYPECODE, 0, num_blocks * self->block_size, (void *)buf};
         self->writeblocks[2] = MP_OBJ_NEW_SMALL_INT(block_num);
         self->writeblocks[3] = MP_OBJ_FROM_PTR(&ar);
         mp_call_method_n_kw(2, 0, self->writeblocks);

extmod/vfs_lfsx.c

@@ -36,7 +36,7 @@
 #include "extmod/vfs.h"
 #include "shared/timeutils/timeutils.h"
 
-STATIC int MP_VFS_LFSx(dev_ioctl)(const struct LFSx_API (config) * c, int cmd, int arg, bool must_return_int) {
+STATIC int MP_VFS_LFSx(dev_ioctl)(const struct LFSx_API(config) * c, int cmd, int arg, bool must_return_int) {
     mp_obj_t ret = mp_vfs_blockdev_ioctl(c->context, cmd, arg);
     int ret_i = 0;
     if (must_return_int || ret != mp_const_none) {
@@ -45,27 +45,27 @@ STATIC int MP_VFS_LFSx(dev_ioctl)(const struct LFSx_API (config) * c, int cmd, i
     return ret_i;
 }
 
-STATIC int MP_VFS_LFSx(dev_read)(const struct LFSx_API (config) * c, LFSx_API(block_t) block, LFSx_API(off_t) off, void *buffer, LFSx_API(size_t) size) {
+STATIC int MP_VFS_LFSx(dev_read)(const struct LFSx_API(config) * c, LFSx_API(block_t) block, LFSx_API(off_t) off, void *buffer, LFSx_API(size_t) size) {
     return mp_vfs_blockdev_read_ext(c->context, block, off, size, buffer);
 }
 
-STATIC int MP_VFS_LFSx(dev_prog)(const struct LFSx_API (config) * c, LFSx_API(block_t) block, LFSx_API(off_t) off, const void *buffer, LFSx_API(size_t) size) {
+STATIC int MP_VFS_LFSx(dev_prog)(const struct LFSx_API(config) * c, LFSx_API(block_t) block, LFSx_API(off_t) off, const void *buffer, LFSx_API(size_t) size) {
     return mp_vfs_blockdev_write_ext(c->context, block, off, size, buffer);
 }
 
-STATIC int MP_VFS_LFSx(dev_erase)(const struct LFSx_API (config) * c, LFSx_API(block_t) block) {
+STATIC int MP_VFS_LFSx(dev_erase)(const struct LFSx_API(config) * c, LFSx_API(block_t) block) {
     return MP_VFS_LFSx(dev_ioctl)(c, MP_BLOCKDEV_IOCTL_BLOCK_ERASE, block, true);
 }
 
-STATIC int MP_VFS_LFSx(dev_sync)(const struct LFSx_API (config) * c) {
+STATIC int MP_VFS_LFSx(dev_sync)(const struct LFSx_API(config) * c) {
     return MP_VFS_LFSx(dev_ioctl)(c, MP_BLOCKDEV_IOCTL_SYNC, 0, false);
 }
 
 STATIC void MP_VFS_LFSx(init_config)(MP_OBJ_VFS_LFSx * self, mp_obj_t bdev, size_t read_size, size_t prog_size, size_t lookahead) {
     self->blockdev.flags = MP_BLOCKDEV_FLAG_FREE_OBJ;
     mp_vfs_blockdev_init(&self->blockdev, bdev);
 
-    struct LFSx_API (config) * config = &self->config;
+    struct LFSx_API(config) * config = &self->config;
     memset(config, 0, sizeof(*config));
 
     config->context = &self->blockdev;
@@ -163,7 +163,7 @@ typedef struct MP_VFS_LFSx (_ilistdir_it_t) {
 STATIC mp_obj_t MP_VFS_LFSx(ilistdir_it_iternext)(mp_obj_t self_in) {
     MP_VFS_LFSx(ilistdir_it_t) * self = MP_OBJ_TO_PTR(self_in);
 
-    struct LFSx_API (info) info;
+    struct LFSx_API(info) info;
     for (;;) {
         int ret = LFSx_API(dir_read)(&self->vfs->lfs, &self->dir, &info);
         if (ret == 0) {
@@ -275,7 +275,7 @@ STATIC mp_obj_t MP_VFS_LFSx(chdir)(mp_obj_t self_in, mp_obj_t path_in) {
     const char *path = MP_VFS_LFSx(make_path)(self, path_in);
     if (path[1] != '\0') {
         // Not at root, check it exists
-        struct LFSx_API (info) info;
+        struct LFSx_API(info) info;
         int ret = LFSx_API(stat)(&self->lfs, path, &info);
         if (ret < 0 || info.type != LFSx_MACRO(_TYPE_DIR)) {
             mp_raise_OSError(-MP_ENOENT);
@@ -350,7 +350,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(MP_VFS_LFSx(getcwd_obj), MP_VFS_LFSx(getcwd));
 STATIC mp_obj_t MP_VFS_LFSx(stat)(mp_obj_t self_in, mp_obj_t path_in) {
     MP_OBJ_VFS_LFSx *self = MP_OBJ_TO_PTR(self_in);
     const char *path = MP_VFS_LFSx(make_path)(self, path_in);
-    struct LFSx_API (info) info;
+    struct LFSx_API(info) info;
     int ret = LFSx_API(stat)(&self->lfs, path, &info);
     if (ret < 0) {
         mp_raise_OSError(-ret);
@@ -464,7 +464,7 @@ STATIC MP_DEFINE_CONST_DICT(MP_VFS_LFSx(locals_dict), MP_VFS_LFSx(locals_dict_ta
 
 STATIC mp_import_stat_t MP_VFS_LFSx(import_stat)(void *self_in, const char *path) {
     MP_OBJ_VFS_LFSx *self = self_in;
-    struct LFSx_API (info) info;
+    struct LFSx_API(info) info;
     mp_obj_str_t path_obj = { { &mp_type_str }, 0, 0, (const byte *)path };
     path = MP_VFS_LFSx(make_path)(self, MP_OBJ_FROM_PTR(&path_obj));
     int ret = LFSx_API(stat)(&self->lfs, path, &info);

ports/atmel-samd/common-hal/analogio/AnalogOut.c

@@ -57,17 +57,17 @@ void common_hal_analogio_analogout_construct(analogio_analogout_obj_t *self,
 
     uint8_t channel;
     switch (pin->number) {
-        #if defined(PIN_PA02) && !defined(IGNORE_PIN_PA02)
+    #if defined(PIN_PA02) && !defined(IGNORE_PIN_PA02)
         case PIN_PA02:
             channel = 0;
             break;
-        #endif
+    #endif
 
-        #if defined(SAM_D5X_E5X) && defined(PIN_PA05) && !defined(IGNORE_PIN_PA05)
+    #if defined(SAM_D5X_E5X) && defined(PIN_PA05) && !defined(IGNORE_PIN_PA05)
         case PIN_PA05:
             channel = 1;
             break;
-        #endif
+    #endif
 
         default:
             raise_ValueError_invalid_pin();

ports/atmel-samd/eic_handler.c

@@ -43,35 +43,35 @@ void set_eic_handler(uint8_t channel, uint8_t eic_handler) {
 void shared_eic_handler(uint8_t channel) {
     uint8_t handler = eic_channel_handler[channel];
     switch (handler) {
-        #if CIRCUITPY_PULSEIO
+    #if CIRCUITPY_PULSEIO
         case EIC_HANDLER_PULSEIN:
             pulsein_interrupt_handler(channel);
             break;
-        #endif
+    #endif
 
-        #if CIRCUITPY_PS2IO
+    #if CIRCUITPY_PS2IO
         case EIC_HANDLER_PS2:
             ps2_interrupt_handler(channel);
             break;
-        #endif
+    #endif
 
-        #if CIRCUITPY_ROTARYIO
+    #if CIRCUITPY_ROTARYIO
         case EIC_HANDLER_INCREMENTAL_ENCODER:
             incrementalencoder_interrupt_handler(channel);
             break;
-        #endif
+    #endif
 
-        #if CIRCUITPY_COUNTIO
+    #if CIRCUITPY_COUNTIO
         case EIC_HANDLER_COUNTER:
             counter_interrupt_handler(channel);
             break;
-        #endif
+    #endif
 
-        #if CIRCUITPY_ALARM
+    #if CIRCUITPY_ALARM
         case EIC_HANDLER_ALARM:
             pin_alarm_callback(channel);
             break;
-        #endif
+    #endif
 
         default:
             break;

ports/nrf/bluetooth/ble_drv.c

@@ -121,7 +121,7 @@ void SD_EVT_IRQHandler(void) {
     uint32_t evt_id;
     while (sd_evt_get(&evt_id) != NRF_ERROR_NOT_FOUND) {
         switch (evt_id) {
-            #if CIRCUITPY_USB
+        #if CIRCUITPY_USB
             // usb power event
             case NRF_EVT_POWER_USB_DETECTED:
             case NRF_EVT_POWER_USB_POWER_READY:
@@ -133,7 +133,7 @@ void SD_EVT_IRQHandler(void) {
                 tusb_hal_nrf_power_event(usbevt);
             }
             break;
-            #endif
+        #endif
 
             // Set flag indicating that a flash operation has finished.
             case NRF_EVT_FLASH_OPERATION_SUCCESS:

ports/stm/common-hal/audiobusio/MEMS_Audio.h

@@ -61,7 +61,7 @@ typedef int32_t mems_audio_err_t;
  * @brief The datatype that holds an output PCM sample.
  */
 typedef int16_t pcm_sample_t;
-_Static_assert(PCM_OUT_RESOLUTION==16, "Output PCM resolution must be 16-bits");
+_Static_assert(PCM_OUT_RESOLUTION == 16, "Output PCM resolution must be 16-bits");
 
 
 typedef enum {
@@ -79,7 +79,7 @@ typedef struct MemsAudio_t MemsAudio;
 /**
  * @brief Callback informing that PCM samples are available for processing.
  */
-typedef void (*pcm_data_available_t)(MemsAudio* audio, pcm_sample_t* pcmSamples, size_t pcmLength);
+typedef void (*pcm_data_available_t)(MemsAudio *audio, pcm_sample_t *pcmSamples, size_t pcmLength);
 
 /**
  * @brief MemsAudio manages the filter, buffers and callbacks used to capture PDM audio samples and convert to PCM.
@@ -90,7 +90,7 @@ typedef struct MemsAudio_t {
     /**
      * @brief The buffer to store PCM audio samples
      */
-    volatile pcm_sample_t* volatile pcmOutputBuffer;
+    volatile pcm_sample_t *volatile pcmOutputBuffer;
 
     /**
      * @brief The length of the PCM buffer. SHould be at least MEMS_AUDIO_PCM_BUFFER_LENGTH
@@ -102,20 +102,20 @@ typedef struct MemsAudio_t {
      */
     pcm_data_available_t pcm_data_available;
 
-    void* audioImpl;
-    void* userData;
+    void *audioImpl;
+    void *userData;
 } MemsAudio;
 
 
-mems_audio_err_t mems_audio_init(MemsAudio* audio);
+mems_audio_err_t mems_audio_init(MemsAudio *audio);
 
 /**
  * @brief Uninitializes the MemsAudio instance.
  *
  * @param audio
  * @return mems_audio_err_t
  */
-mems_audio_err_t mems_audio_uninit(MemsAudio* audio);
+mems_audio_err_t mems_audio_uninit(MemsAudio *audio);
 
 /**
  * @brief Asynchronously records audio.
@@ -125,28 +125,28 @@ mems_audio_err_t mems_audio_uninit(MemsAudio* audio);
  * @param pdmBufferLength
  * @return mems_audio_err_t
  */
-mems_audio_err_t mems_audio_record(MemsAudio* audio);
+mems_audio_err_t mems_audio_record(MemsAudio *audio);
 
 /**
  * @brief Pause recording audio.
  */
-mems_audio_err_t mems_audio_pause(MemsAudio* audio);
+mems_audio_err_t mems_audio_pause(MemsAudio *audio);
 
 /**
  * @brief Resume recording audio.
  *
  * @param audio
  * @return mems_audio_err_t
  */
-mems_audio_err_t mems_audio_resume(MemsAudio* audio);
+mems_audio_err_t mems_audio_resume(MemsAudio *audio);
 
 /**
  * @brief Stop recording audio and
  *
  * @param audio
  * @return mems_audio_err_t
  */
-mems_audio_err_t mems_audio_stop(MemsAudio* audio);
+mems_audio_err_t mems_audio_stop(MemsAudio *audio);
 
 #ifdef __cplusplus
 }