refactor(apptrace): format apptrace component with astyle

Author: erhankur

components/app_trace/app_trace_membufs_proto.c

@@ -52,7 +52,6 @@ const static char *TAG = "esp_apptrace";
 
 static uint32_t esp_apptrace_membufs_down_buffer_write_nolock(esp_apptrace_membufs_proto_data_t *proto, uint8_t *data, uint32_t size);
 
-
 esp_err_t esp_apptrace_membufs_init(esp_apptrace_membufs_proto_data_t *proto, const esp_apptrace_mem_block_t blocks_cfg[2])
 {
     // disabled by default
@@ -66,7 +65,7 @@ esp_err_t esp_apptrace_membufs_init(esp_apptrace_membufs_proto_data_t *proto, co
     proto->state.in_block = 0;
 #if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
     esp_apptrace_rb_init(&proto->rb_pend, proto->pending_data,
-                        sizeof(proto->pending_data));
+                         sizeof(proto->pending_data));
 #endif
     return ESP_OK;
 }
@@ -101,13 +100,13 @@ static esp_err_t esp_apptrace_membufs_swap(esp_apptrace_membufs_proto_data_t *pr
         // TODO: add support for multiple blocks from host, currently there is no need for that
         uint8_t *p = proto->blocks[new_block_num].start + proto->blocks[new_block_num].sz;
         ESP_APPTRACE_LOGD("Recvd %" PRIu16 " bytes from host (@ %p) [%x %x %x %x %x %x %x %x .. %x %x %x %x %x %x %x %x]",
-            hdr->block_sz, proto->blocks[new_block_num].start,
-            *(proto->blocks[new_block_num].start+0), *(proto->blocks[new_block_num].start+1),
-            *(proto->blocks[new_block_num].start+2), *(proto->blocks[new_block_num].start+3),
-            *(proto->blocks[new_block_num].start+4), *(proto->blocks[new_block_num].start+5),
-            *(proto->blocks[new_block_num].start+6), *(proto->blocks[new_block_num].start+7),
-            *(p-8), *(p-7), *(p-6), *(p-5), *(p-4), *(p-3), *(p-2), *(p-1));
-        uint32_t sz = esp_apptrace_membufs_down_buffer_write_nolock(proto, (uint8_t *)(hdr+1), hdr->block_sz);
+                          hdr->block_sz, proto->blocks[new_block_num].start,
+                          *(proto->blocks[new_block_num].start + 0), *(proto->blocks[new_block_num].start + 1),
+                          *(proto->blocks[new_block_num].start + 2), *(proto->blocks[new_block_num].start + 3),
+                          *(proto->blocks[new_block_num].start + 4), *(proto->blocks[new_block_num].start + 5),
+                          *(proto->blocks[new_block_num].start + 6), *(proto->blocks[new_block_num].start + 7),
+                          *(p - 8), *(p - 7), *(p - 6), *(p - 5), *(p - 4), *(p - 3), *(p - 2), *(p - 1));
+        uint32_t sz = esp_apptrace_membufs_down_buffer_write_nolock(proto, (uint8_t *)(hdr + 1), hdr->block_sz);
         if (sz != hdr->block_sz) {
             ESP_APPTRACE_LOGE("Failed to write %" PRIu32 " bytes to down buffer (%" PRIu16 " %" PRIu32 ")!", hdr->block_sz - sz, hdr->block_sz, sz);
         }
@@ -129,8 +128,8 @@ static esp_err_t esp_apptrace_membufs_swap(esp_apptrace_membufs_proto_data_t *pr
             break;
         }
         ESP_APPTRACE_LOGD("Pump %d pend bytes [%x %x %x %x : %x %x %x %x : %x %x %x %x : %x %x...%x %x]",
-            read_sz, *(ptr+0), *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
-            *(ptr+5), *(ptr+6), *(ptr+7), *(ptr+8), *(ptr+9), *(ptr+10), *(ptr+11), *(ptr+12), *(ptr+13), *(ptr+read_sz-2), *(ptr+read_sz-1));
+                          read_sz, *(ptr + 0), *(ptr + 1), *(ptr + 2), *(ptr + 3), *(ptr + 4),
+                          *(ptr + 5), *(ptr + 6), *(ptr + 7), *(ptr + 8), *(ptr + 9), *(ptr + 10), *(ptr + 11), *(ptr + 12), *(ptr + 13), *(ptr + read_sz - 2), *(ptr + read_sz - 1));
         memcpy(proto->blocks[new_block_num].start + proto->state.markers[new_block_num], ptr, read_sz);
         proto->state.markers[new_block_num] += read_sz;
     }
@@ -209,7 +208,7 @@ static uint32_t esp_apptrace_membufs_down_buffer_write_nolock(esp_apptrace_membu
 
     while (total_sz < size) {
         ESP_APPTRACE_LOGD("esp_apptrace_trax_down_buffer_write_nolock WRS %" PRIu32 "-%" PRIu32 "-%" PRIu32 " %" PRIu32, proto->rb_down.wr, proto->rb_down.rd,
-            proto->rb_down.cur_size, size);
+                          proto->rb_down.cur_size, size);
         uint32_t wr_sz = esp_apptrace_rb_write_size_get(&proto->rb_down);
         if (wr_sz == 0) {
             break;
@@ -319,10 +318,10 @@ uint8_t *esp_apptrace_membufs_up_buffer_get(esp_apptrace_membufs_proto_data_t *p
     if (1) {
 #endif
         if (ESP_APPTRACE_INBLOCK_MARKER(proto) + ESP_APPTRACE_USR_BLOCK_RAW_SZ(size) > ESP_APPTRACE_INBLOCK(proto)->sz) {
-            #if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
             ESP_APPTRACE_LOGD("Block full. Get %" PRIu32 " bytes from PEND buffer", size);
             buf_ptr = esp_apptrace_rb_produce(&proto->rb_pend, ESP_APPTRACE_USR_BLOCK_RAW_SZ(size));
-            #endif
+#endif
             if (buf_ptr == NULL) {
                 int pended_buf;
                 ESP_APPTRACE_LOGD(" full. Get %" PRIu32 " bytes from pend buffer", size);
@@ -372,10 +371,11 @@ esp_err_t esp_apptrace_membufs_flush_nolock(esp_apptrace_membufs_proto_data_t *p
         ESP_APPTRACE_LOGD("Try to flush %" PRIu32 " bytes", ESP_APPTRACE_INBLOCK_MARKER(proto));
         res = esp_apptrace_membufs_swap_waitus(proto, tmo);
         if (res != ESP_OK) {
-            if (res == ESP_ERR_TIMEOUT)
+            if (res == ESP_ERR_TIMEOUT) {
                 ESP_APPTRACE_LOGW("Failed to switch to another block in %" PRIi32 " us!", (int32_t)tmo->elapsed);
-            else
+            } else {
                 ESP_APPTRACE_LOGE("Failed to switch to another block, res: %d", res);
+            }
             return res;
         }
     }

components/app_trace/app_trace_util.c

@@ -44,7 +44,7 @@ void esp_apptrace_log_unlock(void)
 
 esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo)
 {
-    if (tmo->tmo != (int64_t)-1) {
+    if (tmo->tmo != (int64_t) -1) {
         tmo->elapsed = esp_timer_get_time() - tmo->start;
         if (tmo->elapsed >= tmo->tmo) {
             return ESP_ERR_TIMEOUT;

components/app_trace/gcov/gcov_rtio.c

@@ -73,7 +73,7 @@ void gcov_create_task(void *arg)
 {
     ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);
     xTaskCreatePinnedToCore(&gcov_dump_task, "gcov_dump_task", CONFIG_APPTRACE_GCOV_DUMP_TASK_STACK_SIZE,
-		(void *)&s_gcov_task_running, configMAX_PRIORITIES - 1, NULL, 0);
+                            (void *)&s_gcov_task_running, configMAX_PRIORITIES - 1, NULL, 0);
 }
 
 static IRAM_ATTR
@@ -180,7 +180,7 @@ int gcov_rtio_feof(void *stream)
     return ret;
 }
 
-void gcov_rtio_setbuf(void *arg1 __attribute__ ((unused)), void *arg2 __attribute__ ((unused)))
+void gcov_rtio_setbuf(void *arg1 __attribute__((unused)), void *arg2 __attribute__((unused)))
 {
     return;
 }

components/app_trace/heap_trace_tohost.c

@@ -33,7 +33,7 @@ esp_err_t heap_trace_init_tohost(void)
 esp_err_t heap_trace_start(heap_trace_mode_t mode_param)
 {
 #if CONFIG_APPTRACE_SV_ENABLE
-    esp_err_t ret = esp_sysview_heap_trace_start((uint32_t)-1);
+    esp_err_t ret = esp_sysview_heap_trace_start((uint32_t) -1);
     if (ret != ESP_OK) {
         return ret;
     }

components/app_trace/host_file_io.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2017-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -152,7 +152,7 @@ void *esp_apptrace_fopen(esp_apptrace_dest_t dest, const char *path, const char
     cmd_args.mode_len = strlen(mode) + 1;
 
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FOPEN, esp_apptrace_fopen_args_prepare,
-                        &cmd_args, cmd_args.path_len+cmd_args.mode_len);
+                                               &cmd_args, cmd_args.path_len + cmd_args.mode_len);
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return NULL;
@@ -182,7 +182,7 @@ int esp_apptrace_fclose(esp_apptrace_dest_t dest, void *stream)
 
     cmd_args.file = stream;
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FCLOSE, esp_apptrace_fclose_args_prepare,
-                        &cmd_args, sizeof(cmd_args));
+                                               &cmd_args, sizeof(cmd_args));
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return EOF;
@@ -211,7 +211,7 @@ size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t siz
 {
     esp_apptrace_fwrite_args_t cmd_args;
 
-    ESP_EARLY_LOGV(TAG, "esp_apptrace_fwrite f %p l %d", stream, size*nmemb);
+    ESP_EARLY_LOGV(TAG, "esp_apptrace_fwrite f %p l %d", stream, size * nmemb);
 
     if (ptr == NULL) {
         return 0;
@@ -221,7 +221,7 @@ size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t siz
     cmd_args.size = size * nmemb;
     cmd_args.file = stream;
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FWRITE, esp_apptrace_fwrite_args_prepare,
-                        &cmd_args, sizeof(cmd_args.file)+cmd_args.size);
+                                               &cmd_args, sizeof(cmd_args.file) + cmd_args.size);
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return 0;
@@ -253,7 +253,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size
 {
     esp_apptrace_fread_args_t cmd_args;
 
-    ESP_EARLY_LOGV(TAG, "esp_apptrace_fread f %p l %d", stream, size*nmemb);
+    ESP_EARLY_LOGV(TAG, "esp_apptrace_fread f %p l %d", stream, size * nmemb);
 
     if (ptr == NULL) {
         return 0;
@@ -262,7 +262,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size
     cmd_args.size = size * nmemb;
     cmd_args.file = stream;
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FREAD, esp_apptrace_fread_args_prepare,
-                        &cmd_args, sizeof(cmd_args));
+                                               &cmd_args, sizeof(cmd_args));
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return 0;
@@ -288,7 +288,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size
      *      fread(buf, 1 ,size, file);
      * So, total read bytes count returns
      */
-    return resp/size; // return the number of items read
+    return resp / size; // return the number of items read
 }
 
 static void esp_apptrace_fseek_args_prepare(uint8_t *buf, void *priv)
@@ -310,7 +310,7 @@ int esp_apptrace_fseek(esp_apptrace_dest_t dest, void *stream, long offset, int
     cmd_args.offset = offset;
     cmd_args.whence = whence;
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FSEEK, esp_apptrace_fseek_args_prepare,
-                        &cmd_args, sizeof(cmd_args));
+                                               &cmd_args, sizeof(cmd_args));
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return -1;
@@ -340,7 +340,7 @@ int esp_apptrace_ftell(esp_apptrace_dest_t dest, void *stream)
 
     cmd_args.file = stream;
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FTELL, esp_apptrace_ftell_args_prepare,
-                        &cmd_args, sizeof(cmd_args));
+                                               &cmd_args, sizeof(cmd_args));
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return -1;
@@ -380,7 +380,7 @@ int esp_apptrace_feof(esp_apptrace_dest_t dest, void *stream)
 
     cmd_args.file = stream;
     esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FEOF, esp_apptrace_feof_args_prepare,
-                        &cmd_args, sizeof(cmd_args));
+                                               &cmd_args, sizeof(cmd_args));
     if (ret != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret);
         return EOF;

components/app_trace/include/esp_app_trace.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2017-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -19,9 +19,9 @@ extern "C" {
  */
 typedef enum {
     ESP_APPTRACE_DEST_JTAG = 1,                         ///< JTAG destination
-    ESP_APPTRACE_DEST_TRAX = ESP_APPTRACE_DEST_JTAG, 	///< xxx_TRAX name is obsolete, use more common xxx_JTAG
-    ESP_APPTRACE_DEST_UART,	                            ///< UART destination
-    ESP_APPTRACE_DEST_MAX = ESP_APPTRACE_DEST_UART+1,
+    ESP_APPTRACE_DEST_TRAX = ESP_APPTRACE_DEST_JTAG,    ///< xxx_TRAX name is obsolete, use more common xxx_JTAG
+    ESP_APPTRACE_DEST_UART,                             ///< UART destination
+    ESP_APPTRACE_DEST_MAX = ESP_APPTRACE_DEST_UART + 1,
     ESP_APPTRACE_DEST_NUM
 } esp_apptrace_dest_t;
 
@@ -171,7 +171,7 @@ bool esp_apptrace_host_is_connected(esp_apptrace_dest_t dest);
 
 /**
  * @brief Opens file on host.
- *		  This function has the same semantic as 'fopen' except for the first argument.
+ *        This function has the same semantic as 'fopen' except for the first argument.
  *
  * @param dest Indicates HW interface to use.
  * @param path Path to file.
@@ -183,7 +183,7 @@ void *esp_apptrace_fopen(esp_apptrace_dest_t dest, const char *path, const char
 
 /**
  * @brief Closes file on host.
- *		  This function has the same semantic as 'fclose' except for the first argument.
+ *        This function has the same semantic as 'fclose' except for the first argument.
  *
  * @param dest   Indicates HW interface to use.
  * @param stream File handle returned by esp_apptrace_fopen.
@@ -194,11 +194,11 @@ int esp_apptrace_fclose(esp_apptrace_dest_t dest, void *stream);
 
 /**
  * @brief Writes to file on host.
- *		  This function has the same semantic as 'fwrite' except for the first argument.
+ *        This function has the same semantic as 'fwrite' except for the first argument.
  *
  * @param dest   Indicates HW interface to use.
- * @param ptr 	 Address of data to write.
- * @param size 	 Size of an item.
+ * @param ptr    Address of data to write.
+ * @param size   Size of an item.
  * @param nmemb  Number of items to write.
  * @param stream File handle returned by esp_apptrace_fopen.
  *
@@ -208,11 +208,11 @@ size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t siz
 
 /**
  * @brief Read file on host.
- *		  This function has the same semantic as 'fread' except for the first argument.
+ *        This function has the same semantic as 'fread' except for the first argument.
  *
  * @param dest   Indicates HW interface to use.
- * @param ptr 	 Address to store read data.
- * @param size 	 Size of an item.
+ * @param ptr    Address to store read data.
+ * @param size   Size of an item.
  * @param nmemb  Number of items to read.
  * @param stream File handle returned by esp_apptrace_fopen.
  *
@@ -222,7 +222,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size
 
 /**
  * @brief Set position indicator in file on host.
- *		  This function has the same semantic as 'fseek' except for the first argument.
+ *        This function has the same semantic as 'fseek' except for the first argument.
  *
  * @param dest   Indicates HW interface to use.
  * @param stream File handle returned by esp_apptrace_fopen.
@@ -235,7 +235,7 @@ int esp_apptrace_fseek(esp_apptrace_dest_t dest, void *stream, long offset, int
 
 /**
  * @brief Get current position indicator for file on host.
- *		  This function has the same semantic as 'ftell' except for the first argument.
+ *        This function has the same semantic as 'ftell' except for the first argument.
  *
  * @param dest   Indicates HW interface to use.
  * @param stream File handle returned by esp_apptrace_fopen.
@@ -246,8 +246,8 @@ int esp_apptrace_ftell(esp_apptrace_dest_t dest, void *stream);
 
 /**
  * @brief Indicates to the host that all file operations are complete.
- *		  This function should be called after all file operations are finished and
- *		  indicate to the host that it can perform cleanup operations (close open files etc.).
+ *        This function should be called after all file operations are finished and
+ *        indicate to the host that it can perform cleanup operations (close open files etc.).
  *
  * @param dest   Indicates HW interface to use.
  *
@@ -257,7 +257,7 @@ int esp_apptrace_fstop(esp_apptrace_dest_t dest);
 
 /**
  * @brief Test end-of-file indicator on a stream.
- *		  This function has the same semantic as 'feof' except for the first argument.
+ *        This function has the same semantic as 'feof' except for the first argument.
  *
  * @param dest   Indicates HW interface to use.
  * @param stream File handle returned by esp_apptrace_fopen.
@@ -268,7 +268,7 @@ int esp_apptrace_feof(esp_apptrace_dest_t dest, void *stream);
 
 /**
  * @brief Triggers gcov info dump.
- *		  This function waits for the host to connect to target before dumping data.
+ *        This function waits for the host to connect to target before dumping data.
  */
 void esp_gcov_dump(void);
 

components/app_trace/include/esp_app_trace_util.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -32,12 +32,12 @@ typedef struct {
  * @brief Initializes timeout structure.
  *
  * @param tmo       Pointer to timeout structure to be initialized.
- * @param user_tmo  Timeout value (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly.
+ * @param user_tmo  Timeout value (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely.
 */
 static inline void esp_apptrace_tmo_init(esp_apptrace_tmo_t *tmo, uint32_t user_tmo)
 {
     tmo->start = esp_timer_get_time();
-    tmo->tmo = user_tmo == ESP_APPTRACE_TMO_INFINITE ? (int64_t)-1 : (int64_t)user_tmo;
+    tmo->tmo = user_tmo == ESP_APPTRACE_TMO_INFINITE ? (int64_t) -1 : (int64_t)user_tmo;
     tmo->elapsed = 0;
 }
 
@@ -52,7 +52,7 @@ esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo);
 
 static inline uint32_t esp_apptrace_tmo_remaining_us(esp_apptrace_tmo_t *tmo)
 {
-    return tmo->tmo != (int64_t)-1 ? (tmo->elapsed - tmo->tmo) : ESP_APPTRACE_TMO_INFINITE;
+    return tmo->tmo != (int64_t) -1 ? (tmo->elapsed - tmo->tmo) : ESP_APPTRACE_TMO_INFINITE;
 }
 
 /** Tracing module synchronization lock */
@@ -94,7 +94,7 @@ esp_err_t esp_apptrace_lock_give(esp_apptrace_lock_t *lock);
 /** Ring buffer control structure.
  *
  * @note For purposes of application tracing module if there is no enough space for user data and write pointer can be wrapped
- *       current ring buffer size can be temporarily shrinked in order to provide buffer with requested size.
+ *       current ring buffer size can be temporarily shrunk in order to provide buffer with requested size.
  */
 typedef struct {
     uint8_t *data;      ///< pointer to data storage