applies clang--format

port/moonlight/aclint.h

@@ -4,12 +4,14 @@
 #include "gen/aclint.h"
 #include <stdint.h>
 
-static void set_aclint_mtime(volatile aclint_t* reg, uint64_t value) {
+static void set_aclint_mtime(volatile aclint_t* reg, uint64_t value)
+{
     set_aclint_mtime_hi(reg, (uint32_t)(value >> 32));
     set_aclint_mtime_lo(reg, (uint32_t)value);
 }
 
-static uint64_t get_aclint_mtime(volatile aclint_t* reg) {
+static uint64_t get_aclint_mtime(volatile aclint_t* reg)
+{
 #if (__riscv_xlen == 64)
     // this assume little endianness
     volatile uint64_t* mtime = (volatile uint64_t*)(uint64_t)(&reg->MTIME_LO);
@@ -17,7 +19,8 @@ static uint64_t get_aclint_mtime(volatile aclint_t* reg) {
 #else
     uint32_t mtimeh_val;
     uint32_t mtimel_val;
-    do {
+    do
+    {
         mtimeh_val = get_aclint_mtime_hi(reg);
         mtimel_val = get_aclint_mtime_lo(reg);
     } while (mtimeh_val != get_aclint_mtime_hi(reg));
@@ -25,13 +28,15 @@ static uint64_t get_aclint_mtime(volatile aclint_t* reg) {
 #endif
 }
 
-static void set_aclint_mtimecmp(volatile aclint_t* reg, uint64_t value) {
+static void set_aclint_mtimecmp(volatile aclint_t* reg, uint64_t value)
+{
     set_aclint_mtimecmp0lo(reg, (uint32_t)0xFFFFFFFF);
     set_aclint_mtimecmp0hi(reg, (uint32_t)(value >> 32));
     set_aclint_mtimecmp0lo(reg, (uint32_t)value);
 }
 
-static uint64_t get_aclint_mtimecmp(volatile aclint_t* reg) {
+static uint64_t get_aclint_mtimecmp(volatile aclint_t* reg)
+{
     uint64_t value = ((uint64_t)get_aclint_mtimecmp0hi(reg) << 32) | (uint64_t)get_aclint_mtimecmp0lo(reg);
     return value;
 }

port/moonlight/hwtimer.h

@@ -17,13 +17,15 @@
 #define TICKNUM_PER_SECOND 32768
 #define TICKNUM_PER_TIMER  (TICKNUM_PER_SECOND / 100) // ~ 1ms timer
 
-static inline int hwtimer_init(void) {
+static inline int hwtimer_init(void)
+{
     uint64_t time = get_aclint_mtime(aclint);
     set_aclint_mtimecmp(aclint, time + TICKNUM_PER_TIMER);
     return 0;
 }
 
-static inline int hwtimer_handler(void) {
+static inline int hwtimer_handler(void)
+{
     uint64_t time = get_aclint_mtime(aclint);
     set_aclint_mtimecmp(aclint, time + TICKNUM_PER_TIMER);
     return 0;

port/moonlight/platform.h

@@ -1,8 +1,8 @@
-#include "uart.h"
-#include "gen/ethmac.h"
 #include "aclint.h"
+#include "gen/ethmac.h"
 #include "riscv-csr.h"
 #include "riscv-traps.h"
+#include "uart.h"
 
 #define PERIPH(TYPE, ADDR) ((volatile TYPE*)(ADDR))
 #define PERIPH_BASE        0x10000000
@@ -21,4 +21,3 @@
 #define GPIO_ORQ    23
 #define ETH0_IRQ    24
 #define ETH1_IRQ    25
-

port/moonlight/riscv-traps.h

@@ -9,7 +9,8 @@
 #ifndef RISCV_TRAPS_H
 #define RISCV_TRAPS_H
 
-enum {
+enum
+{
     RISCV_INT_MSI = 3,
     RISCV_INT_MTI = 7,
     RISCV_INT_MEI = 11,
@@ -21,7 +22,8 @@ enum {
     RISCV_INT_UEI = 8,
 };
 
-enum {
+enum
+{
     RISCV_INT_POS_MSI = 3,
     RISCV_INT_POS_MTI = 7,
     RISCV_INT_POS_MEI = 11,
@@ -33,7 +35,8 @@ enum {
     RISCV_INT_POS_UEI = 8,
 };
 
-enum {
+enum
+{
     RISCV_INT_MASK_MSI = (1UL << RISCV_INT_POS_MSI),
     RISCV_INT_MASK_MTI = (1UL << RISCV_INT_POS_MTI),
     RISCV_INT_MASK_MEI = (1UL << RISCV_INT_POS_MEI),
@@ -45,7 +48,8 @@ enum {
     RISCV_INT_MASK_UEI = (1UL << RISCV_INT_POS_UEI),
 };
 
-enum {
+enum
+{
     RISCV_EXCP_INSTRUCTION_ADDRESS_MISALIGNED = 0,  /* Instruction address misaligned */
     RISCV_EXCP_INSTRUCTION_ACCESS_FAULT       = 1,  /* Instruction access fault	*/
     RISCV_EXCP_ILLEGAL_INSTRUCTION            = 2,  /* Illegal instruction */
@@ -64,5 +68,4 @@ enum {
     RISCV_EXCP_STORE_AMO_PAGE_FAULT           = 15, /* Store/AMO page fault */
 };
 
-
 #endif /* RISCV_TRAPS_H */

port/moonlight/uart.h

@@ -3,19 +3,30 @@
 #include "gen/uart.h"
 #include <stdint.h>
 
-static inline uint32_t uart_get_tx_free(volatile uart_t* reg) { return get_uart_rx_tx_reg_tx_free(reg); }
+static inline uint32_t uart_get_tx_free(volatile uart_t* reg)
+{
+    return get_uart_rx_tx_reg_tx_free(reg);
+}
 
-static inline uint32_t uart_get_tx_empty(volatile uart_t* reg) { return get_uart_rx_tx_reg_tx_empty(reg); }
+static inline uint32_t uart_get_tx_empty(volatile uart_t* reg)
+{
+    return get_uart_rx_tx_reg_tx_empty(reg);
+}
 
-static inline uint32_t uart_get_rx_avail(volatile uart_t* reg) { return get_uart_rx_tx_reg_rx_avail(reg); }
+static inline uint32_t uart_get_rx_avail(volatile uart_t* reg)
+{
+    return get_uart_rx_tx_reg_rx_avail(reg);
+}
 
-static inline void uart_write(volatile uart_t* reg, uint8_t data) {
+static inline void uart_write(volatile uart_t* reg, uint8_t data)
+{
     while (get_uart_rx_tx_reg_tx_free(reg) == 0)
         ;
     set_uart_rx_tx_reg_data(reg, data);
 }
 
-static inline uint8_t uart_read(volatile uart_t* reg) {
+static inline uint8_t uart_read(volatile uart_t* reg)
+{
     uint32_t res = get_uart_rx_tx_reg_data(reg);
     while ((res & 0x10000) == 0)
         res = get_uart_rx_tx_reg_data(reg);

port/moonlight/vector_table.h

@@ -17,7 +17,6 @@
 #ifndef VECTOR_TABLE_H
 #define VECTOR_TABLE_H
 
-
 /** Symbol for machine mode vector table - do not call
  */
 void riscv_mtvec_table(void) __attribute__((naked));
@@ -106,8 +105,6 @@ void riscv_mtvec_platform_irq14(void) __attribute__ ((interrupt ("machine")) );
 /* Platform interrupt 15, bit 31 of mip/mie */
 void riscv_mtvec_platform_irq15(void) __attribute__((interrupt("machine")));
 
-
 #endif // #ifndef VECTOR_TABLE_MTVEC_PLATFORM_INTS
 
-
 #endif // #ifndef VECTOR_TABLE_H

port/threadx/inc/csr.h

@@ -8,11 +8,9 @@
  * SPDX-License-Identifier: MIT
  **************************************************************************/
 
-
 #ifndef CSR_H
 #define CSR_H
 
-
 // Machine Status Register, mstatus
 #define MSTATUS_MPP_MASK (3L << 11) // previous mode.
 #define MSTATUS_MPP_M    (3L << 11)

port/threadx/inc/nx_port.h

@@ -131,7 +131,8 @@
     extern volatile ULONG TX_THREAD_GET_SYSTEM_STATE();
 
 #define NX_THREADS_ONLY_CALLER_CHECKING                                                                                \
-    if((TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == TX_NULL) || (_tx_thread_current_ptr == &_tx_timer_thread))             \
+    if ((TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == TX_NULL) ||                                       \
+        (_tx_thread_current_ptr == &_tx_timer_thread))                                                                 \
         return (NX_CALLER_ERROR);
 
 #define NX_INIT_AND_THREADS_CALLER_CHECKING                                                                            \
@@ -144,8 +145,8 @@
         return (NX_CALLER_ERROR);
 
 #define NX_THREAD_WAIT_CALLER_CHECKING                                                                                 \
-    if((wait_option) &&                                                                                                                    \
+    if ((wait_option) && ((_tx_thread_current_ptr == NX_NULL) || (TX_THREAD_GET_SYSTEM_STATE()) ||                     \
-       ((_tx_thread_current_ptr == NX_NULL) || (TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == &_tx_timer_thread)))           \
+                             (_tx_thread_current_ptr == &_tx_timer_thread)))                                           \
         return (NX_CALLER_ERROR);
 
 #else

port/threadx/inc/nx_user.h

@@ -765,7 +765,8 @@
 */
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
     int rand(void);

port/threadx/inc/tx_port.h

@@ -248,7 +248,9 @@ ULONG64 _tx_thread_interrupt_control(unsigned int new_posture);
 #define TX_INTERRUPT_SAVE_AREA ULONG64 interrupt_save;
 /* Atomically read mstatus into interrupt_save and clear bit 3 of mstatus.  */
 #define TX_DISABLE                                                                                                     \
-    { __asm__("csrrci %0, mstatus, 0x08" : "=r"(interrupt_save) :); };
+    {                                                                                                                  \
+        __asm__("csrrci %0, mstatus, 0x08" : "=r"(interrupt_save) :);                                                  \
+    };
 /* We only care about mstatus.mie (bit 3), so mask interrupt_save and write to mstatus.  */
 #define TX_RESTORE                                                                                                     \
     {                                                                                                                  \

port/threadx/inc/tx_user.h

@@ -8,7 +8,6 @@
  * SPDX-License-Identifier: MIT
  **************************************************************************/
 
-
 /**************************************************************************/
 /**************************************************************************/
 /**                                                                       */
@@ -19,7 +18,6 @@
 /**************************************************************************/
 /**************************************************************************/
 
-
 /**************************************************************************/
 /*                                                                        */
 /*  PORT SPECIFIC C INFORMATION                            RELEASE        */
@@ -71,7 +69,6 @@
 #ifndef TX_USER_H
 #define TX_USER_H
 
-
 /* Define various build options for the ThreadX port.  The application should either make changes
    here by commenting or un-commenting the conditional compilation defined OR supply the defines
    though the compiler's equivalent of the -D option.
@@ -105,7 +102,6 @@
    therefore return an error if this option is used. This may or may not be desirable for a
    given application.  */
 
-
 /* Override various options with default values already assigned in tx_port.h. Please also refer
    to tx_port.h for descriptions on each of these options.  */
 
@@ -129,10 +125,8 @@
    version in tx_port.h or here.
    Note: the actual hardware timer value may need to be changed (usually in tx_initialize_low_level).  */
 
-
 #define TX_TIMER_TICKS_PER_SECOND (100) // for moonlight with 32,7kHz Frequency (divided by 1000)
 
-
 /* Determine if there is a FileX pointer in the thread control block.
    By default, the pointer is there for legacy/backwards compatibility.
    The pointer must also be there for applications using FileX.
@@ -225,7 +219,6 @@
 #define TX_DISABLE_NOTIFY_CALLBACKS
 */
 
-
 /* Determine if the tx_thread_resume and tx_thread_suspend services should have their internal
    code in-line. This results in a larger image, but improves the performance of the thread
    resume and suspend services.  */
@@ -234,7 +227,6 @@
 #define TX_INLINE_THREAD_RESUME_SUSPEND
 */
 
-
 /* Determine if the internal ThreadX code is non-interruptable. This results in smaller code
    size and less processing overhead, but increases the interrupt lockout time.  */
 
@@ -242,7 +234,6 @@
 #define TX_NOT_INTERRUPTABLE
 */
 
-
 /* Determine if the trace event logging code should be enabled. This causes slight increases in
    code size and overhead, but provides the ability to generate system trace information which
    is available for viewing in TraceX.  */
@@ -251,7 +242,6 @@
 #define TX_ENABLE_EVENT_TRACE
 */
 
-
 /* Determine if block pool performance gathering is required by the application. When the following is
    defined, ThreadX gathers various block pool performance information. */
 
@@ -321,4 +311,3 @@
 */
 
 #endif
-

src/tcp_demo/main.c

@@ -44,13 +44,15 @@ void _nx_mnrs_network_driver(struct NX_IP_DRIVER_STRUCT* driver_req);
 
 /* Define main entry point.  */
 
-int main() {
+int main()
+{
     /* Enter the ThreadX kernel.  */
     tx_kernel_enter();
 }
 
 /* Define what the initial system looks like.  */
-void tx_application_define(void* first_unused_memory) {
+void tx_application_define(void* first_unused_memory)
+{
     CHAR* pointer;
     UINT status;
     puts("Setting up application");
@@ -58,12 +60,14 @@ void tx_application_define(void* first_unused_memory) {
     pointer = (CHAR*)first_unused_memory;
 
     /* Create the main thread.  */
-    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(
+        &thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
 
     pointer = pointer + DEMO_STACK_SIZE;
 
     /* Create the main thread.  */
-    tx_thread_create(&thread_1, "thread 1", thread_1_entry, 0, pointer, DEMO_STACK_SIZE, 3, 3, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(
+        &thread_1, "thread 1", thread_1_entry, 0, pointer, DEMO_STACK_SIZE, 3, 3, TX_NO_TIME_SLICE, TX_AUTO_START);
 
     pointer = pointer + DEMO_STACK_SIZE;
 
@@ -73,19 +77,23 @@ void tx_application_define(void* first_unused_memory) {
     /* Create a packet pool.  */
     status = nx_packet_pool_create(&pool_0, "packet_pool0", PACKET_SIZE, pool_buffer, POOL_SIZE);
 
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
     /* Create an IP instance.  */
-    status = nx_ip_create(&ip_0, "eth0", IP_ADDRESS(1, 2, 3, 4), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1);
+    status =
+        nx_ip_create(&ip_0, "eth0", IP_ADDRESS(1, 2, 3, 4), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1);
     pointer = pointer + 2048;
 
     /* Create another IP instance.  */
-    status += nx_ip_create(&ip_1, "eth1", IP_ADDRESS(1, 2, 3, 5), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1);
+    status +=
+        nx_ip_create(&ip_1, "eth1", IP_ADDRESS(1, 2, 3, 5), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1);
     pointer = pointer + 2048;
 
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
@@ -98,18 +106,21 @@ void tx_application_define(void* first_unused_memory) {
     pointer = pointer + 1024;
 
     /* Check ARP enable status.  */
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
     /* Enable ICMP */
     status = nxd_icmp_enable(&ip_0);
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
     status = nxd_icmp_enable(&ip_1);
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
@@ -122,7 +133,8 @@ void tx_application_define(void* first_unused_memory) {
 
 /* Define the test threads.  */
 
-void thread_0_entry(ULONG thread_input) {
+void thread_0_entry(ULONG thread_input)
+{
 
     UINT status;
     NX_PACKET* my_packet;
@@ -142,14 +154,23 @@ void thread_0_entry(ULONG thread_input) {
     server_ipv4_address.nxd_ip_address.v4 = IP_ADDRESS(1, 2, 3, 5);
     /* Loop to repeat things over and over again!  */
     puts("Entering client loop");
-    while(1) {
+    while (1)
+    {
 
         /* Create a socket.  */
-        status = nx_tcp_socket_create(&ip_0, &client_socket, "Client Socket", NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 200,
+        status = nx_tcp_socket_create(&ip_0,
-                                      NX_NULL, NX_NULL);
+            &client_socket,
+            "Client Socket",
+            NX_IP_NORMAL,
+            NX_FRAGMENT_OKAY,
+            NX_IP_TIME_TO_LIVE,
+            200,
+            NX_NULL,
+            NX_NULL);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -157,7 +178,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nx_tcp_client_socket_bind(&client_socket, 12, NX_WAIT_FOREVER);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -165,7 +187,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nxd_tcp_client_socket_connect(&client_socket, &server_ipv4_address, 12, NX_IP_PERIODIC_RATE);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             printf("Error with socket connect: 0x%x\n", status);
             return;
         }
@@ -176,7 +199,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nx_packet_allocate(&pool_0, &my_packet, NX_TCP_PACKET, NX_WAIT_FOREVER);
 
         /* Check status.  */
-        if(status != NX_SUCCESS) {
+        if (status != NX_SUCCESS)
+        {
             break;
         }
 
@@ -184,7 +208,8 @@ void thread_0_entry(ULONG thread_input) {
         nx_packet_data_append(my_packet, DEMO_DATA, sizeof(DEMO_DATA), &pool_0, TX_WAIT_FOREVER);
 
         status = nx_packet_length_get(my_packet, &length);
-        if((status) || (length != sizeof(DEMO_DATA))) {
+        if ((status) || (length != sizeof(DEMO_DATA)))
+        {
             error_counter++;
         }
 
@@ -192,7 +217,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nx_tcp_socket_send(&client_socket, my_packet, NX_IP_PERIODIC_RATE);
 
         /* Determine if the status is valid.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
             nx_packet_release(my_packet);
         }
@@ -201,7 +227,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nx_tcp_socket_disconnect(&client_socket, NX_IP_PERIODIC_RATE);
 
         /* Determine if the status is valid.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -209,7 +236,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nx_tcp_client_socket_unbind(&client_socket);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -217,7 +245,8 @@ void thread_0_entry(ULONG thread_input) {
         status = nx_tcp_socket_delete(&client_socket);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -226,7 +255,8 @@ void thread_0_entry(ULONG thread_input) {
     }
 }
 
-void thread_1_entry(ULONG thread_input) {
+void thread_1_entry(ULONG thread_input)
+{
 
     UINT status;
     NX_PACKET* packet_ptr;
@@ -241,18 +271,27 @@ void thread_1_entry(ULONG thread_input) {
     status = nx_ip_status_check(&ip_1, NX_IP_INITIALIZE_DONE, &actual_status, NX_IP_PERIODIC_RATE);
 
     /* Check status...  */
-    if(status != NX_SUCCESS) {
+    if (status != NX_SUCCESS)
+    {
 
         error_counter++;
         return;
     }
 
     /* Create a socket.  */
-    status = nx_tcp_socket_create(&ip_1, &server_socket, "Server Socket", NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 100, NX_NULL,
+    status = nx_tcp_socket_create(&ip_1,
+        &server_socket,
+        "Server Socket",
+        NX_IP_NORMAL,
+        NX_FRAGMENT_OKAY,
+        NX_IP_TIME_TO_LIVE,
+        100,
+        NX_NULL,
         thread_1_disconnect_received);
 
     /* Check for error.  */
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
@@ -260,13 +299,15 @@ void thread_1_entry(ULONG thread_input) {
     status = nx_tcp_server_socket_listen(&ip_1, 12, &server_socket, 5, thread_1_connect_received);
 
     /* Check for error.  */
-    if(status) {
+    if (status)
+    {
         error_counter++;
     }
 
     /* Loop to create and establish server connections.  */
     puts("Entering server loop");
-    while(1) {
+    while (1)
+    {
 
         /* Increment thread 1's counter.  */
         thread_1_counter++;
@@ -275,7 +316,8 @@ void thread_1_entry(ULONG thread_input) {
         status = nx_tcp_server_socket_accept(&server_socket, NX_WAIT_FOREVER);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -283,9 +325,12 @@ void thread_1_entry(ULONG thread_input) {
         status = nx_tcp_socket_receive(&server_socket, &packet_ptr, NX_IP_PERIODIC_RATE);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
-        } else {
+        }
+        else
+        {
             char buffer[64];
             ULONG size;
             nx_packet_data_extract_offset(packet_ptr, 0, buffer, 64, &size);
@@ -299,7 +344,8 @@ void thread_1_entry(ULONG thread_input) {
         status = nx_tcp_socket_disconnect(&server_socket, NX_IP_PERIODIC_RATE);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -307,7 +353,8 @@ void thread_1_entry(ULONG thread_input) {
         status = nx_tcp_server_socket_unaccept(&server_socket);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
 
@@ -315,24 +362,29 @@ void thread_1_entry(ULONG thread_input) {
         status = nx_tcp_server_socket_relisten(&ip_1, 12, &server_socket);
 
         /* Check for error.  */
-        if(status) {
+        if (status)
+        {
             error_counter++;
         }
     }
 }
 
-void thread_1_connect_received(NX_TCP_SOCKET* socket_ptr, UINT port) {
+void thread_1_connect_received(NX_TCP_SOCKET* socket_ptr, UINT port)
+{
 
     /* Check for the proper socket and port.  */
-    if((socket_ptr != &server_socket) || (port != 12)) {
+    if ((socket_ptr != &server_socket) || (port != 12))
+    {
         error_counter++;
     }
 }
 
-void thread_1_disconnect_received(NX_TCP_SOCKET* socket) {
+void thread_1_disconnect_received(NX_TCP_SOCKET* socket)
+{
 
     /* Check for proper disconnected socket.  */
-    if(socket != &server_socket) {
+    if (socket != &server_socket)
+    {
         error_counter++;
     }
 }

src/thread_demo/main.c

@@ -51,14 +51,16 @@ void thread_5_entry(ULONG thread_input);
 void thread_6_and_7_entry(ULONG thread_input);
 
 /* Define main entry point.  */
-int main() {
+int main()
+{
     /* Enter the ThreadX kernel.  */
     tx_kernel_enter();
 }
 
 /* Define what the initial system looks like.  */
 
-void tx_application_define(void* first_unused_memory) {
+void tx_application_define(void* first_unused_memory)
+{
 
     CHAR* pointer = TX_NULL;
 
@@ -72,7 +74,8 @@ void tx_application_define(void* first_unused_memory) {
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
 
     /* Create the main thread.  */
-    tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(
+        &thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
 
     /* Allocate the stack for thread 1.  */
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
@@ -93,30 +96,67 @@ void tx_application_define(void* first_unused_memory) {
     /* Create threads 3 and 4.  These threads compete for a ThreadX counting
        semaphore. An interesting thing here is that both threads share the same
        instruction area.  */
-    tx_thread_create(&thread_3, "thread 3", thread_3_and_4_entry, 3, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(&thread_3,
+        "thread 3",
+        thread_3_and_4_entry,
+        3,
+        pointer,
+        DEMO_STACK_SIZE,
+        8,
+        8,
+        TX_NO_TIME_SLICE,
+        TX_AUTO_START);
 
     /* Allocate the stack for thread 4.  */
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
 
-    tx_thread_create(&thread_4, "thread 4", thread_3_and_4_entry, 4, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(&thread_4,
+        "thread 4",
+        thread_3_and_4_entry,
+        4,
+        pointer,
+        DEMO_STACK_SIZE,
+        8,
+        8,
+        TX_NO_TIME_SLICE,
+        TX_AUTO_START);
 
     /* Allocate the stack for thread 5.  */
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
 
     /* Create thread 5.  This thread simply pends on an event flag which will be
        set by thread_0.  */
-    tx_thread_create(&thread_5, "thread 5", thread_5_entry, 5, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(
+        &thread_5, "thread 5", thread_5_entry, 5, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
 
     /* Allocate the stack for thread 6.  */
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
 
     /* Create threads 6 and 7.  These threads compete for a ThreadX mutex.  */
-    tx_thread_create(&thread_6, "thread 6", thread_6_and_7_entry, 6, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(&thread_6,
+        "thread 6",
+        thread_6_and_7_entry,
+        6,
+        pointer,
+        DEMO_STACK_SIZE,
+        8,
+        8,
+        TX_NO_TIME_SLICE,
+        TX_AUTO_START);
 
     /* Allocate the stack for thread 7.  */
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
 
-    tx_thread_create(&thread_7, "thread 7", thread_6_and_7_entry, 7, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START);
+    tx_thread_create(&thread_7,
+        "thread 7",
+        thread_6_and_7_entry,
+        7,
+        pointer,
+        DEMO_STACK_SIZE,
+        8,
+        8,
+        TX_NO_TIME_SLICE,
+        TX_AUTO_START);
 
     /* Allocate the message queue.  */
     tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_QUEUE_SIZE * sizeof(ULONG), TX_NO_WAIT);
@@ -148,12 +188,14 @@ void tx_application_define(void* first_unused_memory) {
 
 /* Define the test threads.  */
 
-void thread_0_entry(ULONG thread_input) {
+void thread_0_entry(ULONG thread_input)
+{
 
     UINT status;
 
     /* This thread simply sits in while-forever-sleep loop.  */
-    while(1) {
+    while (1)
+    {
         puts("[Thread] : thread_0_entry is here!");
         /* Increment the thread counter.  */
         thread_0_counter++;
@@ -170,12 +212,14 @@ void thread_0_entry(ULONG thread_input) {
     }
 }
 
-void thread_1_entry(ULONG thread_input) {
+void thread_1_entry(ULONG thread_input)
+{
 
     UINT status;
 
     /* This thread simply sends messages to a queue shared by thread 2.  */
-    while(1) {
+    while (1)
+    {
         /* Increment the thread counter.  */
         thread_1_counter++;
 
@@ -192,13 +236,15 @@ void thread_1_entry(ULONG thread_input) {
     }
 }
 
-void thread_2_entry(ULONG thread_input) {
+void thread_2_entry(ULONG thread_input)
+{
 
     ULONG received_message;
     UINT status;
 
     /* This thread retrieves messages placed on the queue by thread 1.  */
-    while(1) {
+    while (1)
+    {
         /* Increment the thread counter.  */
         thread_2_counter++;
 
@@ -216,13 +262,15 @@ void thread_2_entry(ULONG thread_input) {
     }
 }
 
-void thread_3_and_4_entry(ULONG thread_input) {
+void thread_3_and_4_entry(ULONG thread_input)
+{
 
     UINT status;
 
     /* This function is executed from thread 3 and thread 4.  As the loop
        below shows, these function compete for ownership of semaphore_0.  */
-    while(1) {
+    while (1)
+    {
         puts("[Thread] : thread_3_and_4_entry is here!");
 
         /* Increment the thread counter.  */
@@ -250,13 +298,15 @@ void thread_3_and_4_entry(ULONG thread_input) {
     }
 }
 
-void thread_5_entry(ULONG thread_input) {
+void thread_5_entry(ULONG thread_input)
+{
 
     UINT status;
     ULONG actual_flags;
 
     /* This thread simply waits for an event in a forever loop.  */
-    while(1) {
+    while (1)
+    {
         puts("[Thread] : thread_5_entry is here!");
         /* Increment the thread counter.  */
         thread_5_counter++;
@@ -270,13 +320,15 @@ void thread_5_entry(ULONG thread_input) {
     }
 }
 
-void thread_6_and_7_entry(ULONG thread_input) {
+void thread_6_and_7_entry(ULONG thread_input)
+{
 
     UINT status;
 
     /* This function is executed from thread 6 and thread 7.  As the loop
        below shows, these function compete for ownership of mutex_0.  */
-    while(1) {
+    while (1)
+    {
         puts("[Thread] : thread_6_and_7_entry is here!");
         /* Increment the thread counter.  */
         if (thread_input == 6)