rtos: fix coding style in the boot files

0xc0170 · 0xc0170 · commit 87265f774444 · 2018-11-08T08:54:22.000Z
diff --git a/rtos/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c b/rtos/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c
@@ -37,10 +37,10 @@ void _main_init(void)
 {
     /* microlib only supports the two region memory model */
 
-    mbed_heap_start = (unsigned char*)__heap_base;
+    mbed_heap_start = (unsigned char *)__heap_base;
     mbed_heap_size = (uint32_t)__heap_base - (uint32_t)__heap_limit;
 
-    mbed_stack_isr_start = (unsigned char*)((uint32_t)__initial_sp - ISR_STACK_SIZE);
+    mbed_stack_isr_start = (unsigned char *)((uint32_t)__initial_sp - ISR_STACK_SIZE);
     mbed_stack_isr_size = ISR_STACK_SIZE;
 
     mbed_init();
diff --git a/rtos/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c b/rtos/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c
@@ -105,15 +105,16 @@ __asm(".global __use_no_semihosting\n\t");
 //lint -esym(9003, os_libspace*) "variables 'os_libspace*' defined at module scope"
 
 // Memory for libspace
-static uint32_t os_libspace[OS_THREAD_LIBSPACE_NUM+1][LIBSPACE_SIZE/4] \
+static uint32_t os_libspace[OS_THREAD_LIBSPACE_NUM + 1][LIBSPACE_SIZE / 4] \
 __attribute__((section(".bss.os.libspace")));
 
 // Thread IDs for libspace
 static osThreadId_t os_libspace_id[OS_THREAD_LIBSPACE_NUM] \
 __attribute__((section(".bss.os.libspace")));
 
 // Check if Kernel has been started
-static uint32_t os_kernel_is_active (void) {
+static uint32_t os_kernel_is_active(void)
+{
     static uint8_t os_kernel_active = 0U;
 
     if (os_kernel_active == 0U) {
@@ -125,7 +126,8 @@ static uint32_t os_kernel_is_active (void) {
 }
 
 // Provide libspace for current thread
-void *__user_perthread_libspace (void) {
+void *__user_perthread_libspace(void)
+{
     osThreadId_t id;
     uint32_t     n;
 
@@ -182,7 +184,7 @@ __USED int _mutex_initialize(mutex *m)
     core_util_critical_section_enter();
     for (int i = 0; i < OS_MUTEX_STATIC_NUM; i++) {
         if (_static_mutexes[i] == NULL) {
-            _static_mutexes[i] = (mutex)-1; // dummy value to reserve slot
+            _static_mutexes[i] = (mutex) - 1; // dummy value to reserve slot
             slot = &_static_mutexes[i];
             //Use the static attrs
             attr.cb_size = sizeof(mbed_rtos_storage_mutex_t);
@@ -202,7 +204,7 @@ __USED int _mutex_initialize(mutex *m)
 
     /* Mutex pool exhausted, try using HEAP */
     attr.cb_size = sizeof(mbed_rtos_storage_mutex_t);
-    attr.cb_mem = (void*)malloc(attr.cb_size);
+    attr.cb_mem = (void *)malloc(attr.cb_size);
     if (attr.cb_mem == NULL) {
         osRtxErrorNotify(osRtxErrorClibSpace, m);
         return 0;
@@ -218,21 +220,24 @@ __USED int _mutex_initialize(mutex *m)
 }
 
 /* Acquire mutex */
-__USED void _mutex_acquire(mutex *m) {
+__USED void _mutex_acquire(mutex *m)
+{
     if (os_kernel_is_active() != 0U) {
         (void)osMutexAcquire(*m, osWaitForever);
     }
 }
 
 /* Release mutex */
-__USED void _mutex_release(mutex *m) {
+__USED void _mutex_release(mutex *m)
+{
     if (os_kernel_is_active() != 0U) {
         (void)osMutexRelease(*m);
     }
 }
 
 /* Free mutex */
-__USED void _mutex_free(mutex *m) {
+__USED void _mutex_free(mutex *m)
+{
     mutex *slot = NULL;
     core_util_critical_section_enter();
     for (int i = 0; i < OS_MUTEX_STATIC_NUM; i++) {
diff --git a/rtos/TARGET_CORTEX/TOOLCHAIN_GCC_ARM/mbed_boot_gcc_arm.c b/rtos/TARGET_CORTEX/TOOLCHAIN_GCC_ARM/mbed_boot_gcc_arm.c
@@ -35,7 +35,7 @@ extern uint32_t __end__[];
 #define HEAP_SIZE       ((uint32_t)((uint32_t)INITIAL_SP - (uint32_t)HEAP_START))
 #endif
 
-extern void __libc_init_array (void);
+extern void __libc_init_array(void);
 
 /*
  * mbed entry point for the GCC toolchain
@@ -86,30 +86,31 @@ void mbed_toolchain_init()
 }
 
 extern int __real_main(void);
-int __wrap_main(void) {
+int __wrap_main(void)
+{
     /* For backwards compatibility */
     return __real_main();
 }
 
 /* Opaque declaration of _reent structure */
 struct _reent;
 
-void __rtos_malloc_lock( struct _reent *_r )
+void __rtos_malloc_lock(struct _reent *_r)
 {
     osMutexAcquire(malloc_mutex_id, osWaitForever);
 }
 
-void __rtos_malloc_unlock( struct _reent *_r )
+void __rtos_malloc_unlock(struct _reent *_r)
 {
     osMutexRelease(malloc_mutex_id);
 }
 
-void __rtos_env_lock( struct _reent *_r )
+void __rtos_env_lock(struct _reent *_r)
 {
     osMutexAcquire(env_mutex_id, osWaitForever);
 }
 
-void __rtos_env_unlock( struct _reent *_r )
+void __rtos_env_unlock(struct _reent *_r)
 {
     osMutexRelease(env_mutex_id);
 }
diff --git a/rtos/TARGET_CORTEX/TOOLCHAIN_IAR/mbed_boot_iar.c b/rtos/TARGET_CORTEX/TOOLCHAIN_IAR/mbed_boot_iar.c
@@ -27,7 +27,7 @@
 #pragma section="CSTACK"
 #pragma section="HEAP"
 
-extern void* __vector_table;
+extern void *__vector_table;
 extern int  __low_level_init(void);
 extern void __iar_data_init3(void);
 extern __weak void __iar_init_core(void);
@@ -53,7 +53,7 @@ extern void __iar_dynamic_initialization(void);
  * <IAR>\arm\src\lib\thumb\cstartup_M.s
  */
 #pragma required=__vector_table
-void __iar_program_start( void )
+void __iar_program_start(void)
 {
     /* the calls below are normally made in IAR cstartup */
     __iar_init_core();
@@ -74,10 +74,10 @@ void __iar_program_start( void )
     __iar_data_init3();
 
     /* mbed specific code */
-    mbed_heap_start = (unsigned char*)__section_begin("HEAP");
+    mbed_heap_start = (unsigned char *)__section_begin("HEAP");
     mbed_heap_size = (uint32_t)__section_size("HEAP");
 
-    mbed_stack_isr_start = (unsigned char*)__section_begin("CSTACK");
+    mbed_stack_isr_start = (unsigned char *)__section_begin("CSTACK");
     mbed_stack_isr_size = (uint32_t)__section_size("CSTACK");
 
     mbed_init();
@@ -112,7 +112,7 @@ void __iar_system_Mtxinit(__iar_Rmtx *mutex) /* Initialize a system lock */
             attr.cb_size = sizeof(std_mutex_sys[index]);
             attr.attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust;
             std_mutex_id_sys[index] = osMutexNew(&attr);
-            *mutex = (__iar_Rmtx*)&std_mutex_id_sys[index];
+            *mutex = (__iar_Rmtx *)&std_mutex_id_sys[index];
             return;
         }
     }
@@ -123,18 +123,18 @@ void __iar_system_Mtxinit(__iar_Rmtx *mutex) /* Initialize a system lock */
 
 void __iar_system_Mtxdst(__iar_Rmtx *mutex) /* Destroy a system lock */
 {
-    osMutexDelete(*(osMutexId_t*)*mutex);
+    osMutexDelete(*(osMutexId_t *)*mutex);
     *mutex = 0;
 }
 
 void __iar_system_Mtxlock(__iar_Rmtx *mutex) /* Lock a system lock */
 {
-    osMutexAcquire(*(osMutexId_t*)*mutex, osWaitForever);
+    osMutexAcquire(*(osMutexId_t *)*mutex, osWaitForever);
 }
 
 void __iar_system_Mtxunlock(__iar_Rmtx *mutex) /* Unlock a system lock */
 {
-    osMutexRelease(*(osMutexId_t*)*mutex);
+    osMutexRelease(*(osMutexId_t *)*mutex);
 }
 
 void __iar_file_Mtxinit(__iar_Rmtx *mutex) /* Initialize a file lock */
@@ -148,7 +148,7 @@ void __iar_file_Mtxinit(__iar_Rmtx *mutex) /* Initialize a file lock */
             attr.cb_size = sizeof(std_mutex_file[index]);
             attr.attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust;
             std_mutex_id_file[index] = osMutexNew(&attr);
-            *mutex = (__iar_Rmtx*)&std_mutex_id_file[index];
+            *mutex = (__iar_Rmtx *)&std_mutex_id_file[index];
             return;
         }
     }
@@ -158,16 +158,16 @@ void __iar_file_Mtxinit(__iar_Rmtx *mutex) /* Initialize a file lock */
 
 void __iar_file_Mtxdst(__iar_Rmtx *mutex) /* Destroy a file lock */
 {
-    osMutexDelete(*(osMutexId_t*)*mutex);
+    osMutexDelete(*(osMutexId_t *)*mutex);
     *mutex = 0;
 }
 
 void __iar_file_Mtxlock(__iar_Rmtx *mutex) /* Lock a file lock */
 {
-    osMutexAcquire(*(osMutexId_t*)*mutex, osWaitForever);
+    osMutexAcquire(*(osMutexId_t *)*mutex, osWaitForever);
 }
 
 void __iar_file_Mtxunlock(__iar_Rmtx *mutex) /* Unlock a file lock */
 {
-    osMutexRelease(*(osMutexId_t*)*mutex);
+    osMutexRelease(*(osMutexId_t *)*mutex);
 }

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ extern uint32_t __end__[];`
`35`	`35`	`#define HEAP_SIZE ((uint32_t)((uint32_t)INITIAL_SP - (uint32_t)HEAP_START))`
`36`	`36`	`#endif`
`37`	`37`
`38`		`-extern void __libc_init_array (void);`
	`38`	`+extern void __libc_init_array(void);`
`39`	`39`
`40`	`40`	`/*`
`41`	`41`	`* mbed entry point for the GCC toolchain`
`@@ -86,30 +86,31 @@ void mbed_toolchain_init()`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`extern int __real_main(void);`
`89`		`-int __wrap_main(void) {`
	`89`	`+int __wrap_main(void)`
	`90`	`+{`
`90`	`91`	`/* For backwards compatibility */`
`91`	`92`	`return __real_main();`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`/* Opaque declaration of _reent structure */`
`95`	`96`	`struct _reent;`
`96`	`97`
`97`		`-void __rtos_malloc_lock( struct _reent *_r )`
	`98`	`+void __rtos_malloc_lock(struct _reent *_r)`
`98`	`99`	`{`
`99`	`100`	`osMutexAcquire(malloc_mutex_id, osWaitForever);`
`100`	`101`	`}`
`101`	`102`
`102`		`-void __rtos_malloc_unlock( struct _reent *_r )`
	`103`	`+void __rtos_malloc_unlock(struct _reent *_r)`
`103`	`104`	`{`
`104`	`105`	`osMutexRelease(malloc_mutex_id);`
`105`	`106`	`}`
`106`	`107`
`107`		`-void __rtos_env_lock( struct _reent *_r )`
	`108`	`+void __rtos_env_lock(struct _reent *_r)`
`108`	`109`	`{`
`109`	`110`	`osMutexAcquire(env_mutex_id, osWaitForever);`
`110`	`111`	`}`
`111`	`112`
`112`		`-void __rtos_env_unlock( struct _reent *_r )`
	`113`	`+void __rtos_env_unlock(struct _reent *_r)`
`113`	`114`	`{`
`114`	`115`	`osMutexRelease(env_mutex_id);`
`115`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@`
`27`	`27`	`#pragma section="CSTACK"`
`28`	`28`	`#pragma section="HEAP"`
`29`	`29`
`30`		`-extern void* __vector_table;`
	`30`	`+extern void *__vector_table;`
`31`	`31`	`extern int __low_level_init(void);`
`32`	`32`	`extern void __iar_data_init3(void);`
`33`	`33`	`extern __weak void __iar_init_core(void);`
`@@ -53,7 +53,7 @@ extern void __iar_dynamic_initialization(void);`
`53`	`53`	`* <IAR>\arm\src\lib\thumb\cstartup_M.s`
`54`	`54`	`*/`
`55`	`55`	`#pragma required=__vector_table`
`56`		`-void __iar_program_start( void )`
	`56`	`+void __iar_program_start(void)`
`57`	`57`	`{`
`58`	`58`	`/* the calls below are normally made in IAR cstartup */`
`59`	`59`	`__iar_init_core();`
`@@ -74,10 +74,10 @@ void __iar_program_start( void )`
`74`	`74`	`__iar_data_init3();`
`75`	`75`
`76`	`76`	`/* mbed specific code */`
`77`		`- mbed_heap_start = (unsigned char*)__section_begin("HEAP");`
	`77`	`+ mbed_heap_start = (unsigned char *)__section_begin("HEAP");`
`78`	`78`	`mbed_heap_size = (uint32_t)__section_size("HEAP");`
`79`	`79`
`80`		`- mbed_stack_isr_start = (unsigned char*)__section_begin("CSTACK");`
	`80`	`+ mbed_stack_isr_start = (unsigned char *)__section_begin("CSTACK");`
`81`	`81`	`mbed_stack_isr_size = (uint32_t)__section_size("CSTACK");`
`82`	`82`
`83`	`83`	`mbed_init();`
`@@ -112,7 +112,7 @@ void __iar_system_Mtxinit(__iar_Rmtx mutex) / Initialize a system lock */`
`112`	`112`	`attr.cb_size = sizeof(std_mutex_sys[index]);`
`113`	`113`	`attr.attr_bits = osMutexRecursive \| osMutexPrioInherit \| osMutexRobust;`
`114`	`114`	`std_mutex_id_sys[index] = osMutexNew(&attr);`
`115`		`- mutex = (__iar_Rmtx)&std_mutex_id_sys[index];`
	`115`	`+ mutex = (__iar_Rmtx )&std_mutex_id_sys[index];`
`116`	`116`	`return;`
`117`	`117`	`}`
`118`	`118`	`}`
`@@ -123,18 +123,18 @@ void __iar_system_Mtxinit(__iar_Rmtx mutex) / Initialize a system lock */`
`123`	`123`
`124`	`124`	`void __iar_system_Mtxdst(__iar_Rmtx mutex) / Destroy a system lock */`
`125`	`125`	`{`
`126`		`- osMutexDelete((osMutexId_t)*mutex);`
	`126`	`+ osMutexDelete((osMutexId_t )*mutex);`
`127`	`127`	`*mutex = 0;`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`void __iar_system_Mtxlock(__iar_Rmtx mutex) / Lock a system lock */`
`131`	`131`	`{`
`132`		`- osMutexAcquire((osMutexId_t)*mutex, osWaitForever);`
	`132`	`+ osMutexAcquire((osMutexId_t )*mutex, osWaitForever);`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`void __iar_system_Mtxunlock(__iar_Rmtx mutex) / Unlock a system lock */`
`136`	`136`	`{`
`137`		`- osMutexRelease((osMutexId_t)*mutex);`
	`137`	`+ osMutexRelease((osMutexId_t )*mutex);`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`void __iar_file_Mtxinit(__iar_Rmtx mutex) / Initialize a file lock */`
`@@ -148,7 +148,7 @@ void __iar_file_Mtxinit(__iar_Rmtx mutex) / Initialize a file lock */`
`148`	`148`	`attr.cb_size = sizeof(std_mutex_file[index]);`
`149`	`149`	`attr.attr_bits = osMutexRecursive \| osMutexPrioInherit \| osMutexRobust;`
`150`	`150`	`std_mutex_id_file[index] = osMutexNew(&attr);`
`151`		`- mutex = (__iar_Rmtx)&std_mutex_id_file[index];`
	`151`	`+ mutex = (__iar_Rmtx )&std_mutex_id_file[index];`
`152`	`152`	`return;`
`153`	`153`	`}`
`154`	`154`	`}`
`@@ -158,16 +158,16 @@ void __iar_file_Mtxinit(__iar_Rmtx mutex) / Initialize a file lock */`
`158`	`158`
`159`	`159`	`void __iar_file_Mtxdst(__iar_Rmtx mutex) / Destroy a file lock */`
`160`	`160`	`{`
`161`		`- osMutexDelete((osMutexId_t)*mutex);`
	`161`	`+ osMutexDelete((osMutexId_t )*mutex);`
`162`	`162`	`*mutex = 0;`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`void __iar_file_Mtxlock(__iar_Rmtx mutex) / Lock a file lock */`
`166`	`166`	`{`
`167`		`- osMutexAcquire((osMutexId_t)*mutex, osWaitForever);`
	`167`	`+ osMutexAcquire((osMutexId_t )*mutex, osWaitForever);`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`void __iar_file_Mtxunlock(__iar_Rmtx mutex) / Unlock a file lock */`
`171`	`171`	`{`
`172`		`- osMutexRelease((osMutexId_t)*mutex);`
	`172`	`+ osMutexRelease((osMutexId_t )*mutex);`
`173`	`173`	`}`