cleanup kernel code

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1722 bbd45198-f89e-11dd-88c7-29a3b14d5316

include/rtdebug.h

+/*
+ * File      : rtdebug.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ */
+ 
 #ifndef __RTDEBUG_H__
 #define __RTDEBUG_H__
 
@@ -44,18 +54,18 @@
 #define RT_DEBUG_CONTEXT_CHECK 1
 #endif
 
-#define RT_DEBUG_LOG(type,message)  do{ if(type) rt_kprintf message;}while(0)
+#define RT_DEBUG_LOG(type,message)  do { if (type) rt_kprintf message;} while (0)
 
-#define RT_ASSERT(EX)   if (!(EX)) {volatile char dummy=0;\
+#define RT_ASSERT(EX)   if (!(EX)) {volatile char dummy = 0;\
                             rt_kprintf("(%s) assert failed at %s:%d \n", \
-                            #EX, __FUNCTION__, __LINE__); while (dummy==0);}
+                            #EX, __FUNCTION__, __LINE__); while (dummy == 0);}
 
 /* Macro to check current context */
 #if RT_DEBUG_CONTEXT_CHECK
 #define RT_DEBUG_NOT_IN_INTERRUPT do {\
         rt_base_t level;\
         level = rt_hw_interrupt_disable();\
-        if(rt_interrupt_get_nest() != 0){\
+        if (rt_interrupt_get_nest() != 0){\
             rt_kprintf("Function[%s] shall not used in ISR\n", __FUNCTION__);\
             RT_ASSERT(0)}\
         rt_hw_interrupt_enable(level);} while (0)

include/rthw.h

 /*
  * File      : rthw.h
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
  *
  * The license and distribution terms for this file may be
  * found in the file LICENSE in this distribution or at
- * http://openlab.rt-thread.com/license/LICENSE.
+ * http://www.rt-thread.org/license/LICENSE
  *
  * Change Logs:
  * Date           Author       Notes
@@ -32,8 +32,7 @@ rt_base_t rt_hw_cpu_dcache_status(void);
 void rt_hw_cpu_reset(void);
 void rt_hw_cpu_shutdown(void);
 
-rt_uint8_t *rt_hw_stack_init(void *entry, void *parameter,
-	rt_uint8_t *stack_addr, void *exit);
+rt_uint8_t *rt_hw_stack_init(void *entry, void *parameter, rt_uint8_t *stack_addr, void *exit);
 
 void rt_hw_interrupt_init(void);
 void rt_hw_interrupt_mask(int vector);
@@ -47,7 +46,7 @@ void rt_hw_context_switch(rt_uint32_t from, rt_uint32_t to);
 void rt_hw_context_switch_to(rt_uint32_t to);
 void rt_hw_context_switch_interrupt(rt_uint32_t from, rt_uint32_t to);
 
-void rt_hw_console_output(const char* str);
+void rt_hw_console_output(const char *str);
 
 void rt_hw_backtrace(rt_uint32_t *fp, rt_uint32_t thread_entry);
 void rt_hw_show_memory(rt_uint32_t addr, rt_uint32_t size);

include/rtm.h

+/*
+ * File      : rtm.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ */
+ 
 #ifndef __RTM_H__
 #define __RTM_H__
 
@@ -19,8 +29,8 @@ const struct rt_module_symtab __rtmsym_##symbol SECTION("RTMSymTab")= 	\
 
 struct rt_module_symtab
 {
-	void* addr;
-	const char* name;
-}; 
+	void *addr;
+	const char *name;
+};
 
 #endif

include/rtthread.h

 /*
  * File      : rtthread.h
  * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
  *
  * The license and distribution terms for this file may be
  * found in the file LICENSE in this distribution or at
- * http://openlab.rt-thread.com/license/LICENSE.
+ * http://www.rt-thread.org/license/LICENSE
  *
  * Change Logs:
  * Date           Author       Notes
@@ -14,7 +14,7 @@
  * 2006-08-10     Bernard      add version information
  * 2007-01-28     Bernard      rename RT_OBJECT_Class_Static to RT_Object_Class_Static
  * 2007-03-03     Bernard      clean up the definitions to rtdef.h
- * 2010-04-11     yi.qiu      add module feature
+ * 2010-04-11     yi.qiu       add module feature
  */
 
 #ifndef __RT_THREAD_H__
@@ -37,19 +37,19 @@ extern "C" {
 
 void rt_system_object_init(void);
 struct rt_object_information *rt_object_get_information(enum rt_object_class_type type);
-void rt_object_init(struct rt_object* object, enum rt_object_class_type type, const char* name);
+void rt_object_init(struct rt_object *object, enum rt_object_class_type type, const char *name);
 void rt_object_detach(rt_object_t object);
-rt_object_t rt_object_allocate(enum rt_object_class_type type, const char* name);
+rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name);
 void rt_object_delete(rt_object_t object);
 rt_err_t rt_object_is_systemobject(rt_object_t object);
-rt_object_t rt_object_find(const char* name, rt_uint8_t type);
+rt_object_t rt_object_find(const char *name, rt_uint8_t type);
 
 #ifdef RT_USING_HOOK
-void rt_object_attach_sethook(void (*hook)(struct rt_object* object));
-void rt_object_detach_sethook(void (*hook)(struct rt_object* object));
-void rt_object_trytake_sethook(void (*hook)(struct rt_object* object));
-void rt_object_take_sethook(void (*hook)(struct rt_object* object));
-void rt_object_put_sethook(void (*hook)(struct rt_object* object));
+void rt_object_attach_sethook(void (*hook)(struct rt_object *object));
+void rt_object_detach_sethook(void (*hook)(struct rt_object *object));
+void rt_object_trytake_sethook(void (*hook)(struct rt_object *object));
+void rt_object_take_sethook(void (*hook)(struct rt_object *object));
+void rt_object_put_sethook(void (*hook)(struct rt_object *object));
 #endif
 
 /*@}*/
@@ -71,20 +71,20 @@ void rt_system_timer_init(void);
 void rt_system_timer_thread_init(void);
 
 void rt_timer_init(rt_timer_t timer,
-	const char* name,
-	void (*timeout)(void* parameter), void* parameter,
+	const char *name,
+	void (*timeout)(void *parameter), void *parameter,
 	rt_tick_t time, rt_uint8_t flag);
 rt_err_t rt_timer_detach(rt_timer_t timer);
-rt_timer_t rt_timer_create(const char* name,
-	void (*timeout)(void* parameter), void* parameter,
+rt_timer_t rt_timer_create(const char *name,
+	void (*timeout)(void *parameter), void *parameter,
 	rt_tick_t time, rt_uint8_t flag);
 rt_err_t rt_timer_delete(rt_timer_t timer);
 rt_err_t rt_timer_start(rt_timer_t timer);
 rt_err_t rt_timer_stop(rt_timer_t timer);
-rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void* arg);
+rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg);
 
 #ifdef RT_USING_HOOK
-void rt_timer_timeout_sethook(void (*hook)(struct rt_timer* timer));
+void rt_timer_timeout_sethook(void (*hook)(struct rt_timer *timer));
 #endif
 /*@}*/
 
@@ -95,27 +95,27 @@ void rt_timer_timeout_sethook(void (*hook)(struct rt_timer* timer));
 /*
  * thread interface
  */
-rt_err_t rt_thread_init(struct rt_thread* thread,
-	const char* name,
-	void (*entry)(void* parameter), void* parameter,
-	void* stack_start, rt_uint32_t stack_size,
+rt_err_t rt_thread_init(struct rt_thread *thread,
+	const char *name,
+	void (*entry)(void *parameter), void *parameter,
+	void *stack_start, rt_uint32_t stack_size,
 	rt_uint8_t priority, rt_uint32_t tick);
 rt_err_t rt_thread_detach(rt_thread_t thread);
-rt_thread_t rt_thread_create (const char* name,
-	void (*entry)(void* parameter), void* parameter,
+rt_thread_t rt_thread_create(const char *name,
+	void (*entry)(void *parameter), void *parameter,
 	rt_uint32_t stack_size,
 	rt_uint8_t priority, rt_uint32_t tick);
 rt_thread_t rt_thread_self(void);
-rt_thread_t rt_thread_find(char* name);
+rt_thread_t rt_thread_find(char *name);
 rt_err_t rt_thread_startup(rt_thread_t thread);
 rt_err_t rt_thread_delete(rt_thread_t thread);
 
 rt_err_t rt_thread_yield(void);
 rt_err_t rt_thread_delay(rt_tick_t tick);
-rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void* arg);
+rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void *arg);
 rt_err_t rt_thread_suspend(rt_thread_t thread);
 rt_err_t rt_thread_resume(rt_thread_t thread);
-void rt_thread_timeout(void* parameter);
+void rt_thread_timeout(void *parameter);
 
 /*
  * idle thread interface
@@ -133,8 +133,8 @@ void rt_system_scheduler_init(void);
 void rt_system_scheduler_start(void);
 
 void rt_schedule(void);
-void rt_schedule_insert_thread(struct rt_thread* thread);
-void rt_schedule_remove_thread(struct rt_thread* thread);
+void rt_schedule_insert_thread(struct rt_thread *thread);
+void rt_schedule_remove_thread(struct rt_thread *thread);
 
 void rt_enter_critical(void);
 void rt_exit_critical(void);
@@ -155,17 +155,17 @@ void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
 /*
  * memory pool interface
  */
-rt_err_t rt_mp_init(struct rt_mempool* mp, const char* name, void *start, rt_size_t size, rt_size_t block_size);
-rt_err_t rt_mp_detach(struct rt_mempool* mp);
-rt_mp_t rt_mp_create(const char* name, rt_size_t block_count, rt_size_t block_size);
+rt_err_t rt_mp_init(struct rt_mempool *mp, const char *name, void *start, rt_size_t size, rt_size_t block_size);
+rt_err_t rt_mp_detach(struct rt_mempool *mp);
+rt_mp_t rt_mp_create(const char *name, rt_size_t block_count, rt_size_t block_size);
 rt_err_t rt_mp_delete(rt_mp_t mp);
 
-void *rt_mp_alloc (rt_mp_t mp, rt_int32_t time);
-void rt_mp_free  (void *block);
+void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time);
+void rt_mp_free(void *block);
 
 #ifdef RT_USING_HOOK
-void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool* mp, void *block));
-void rt_mp_free_sethook(void (*hook)(struct rt_mempool* mp, void *block));
+void rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block));
+void rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block));
 #endif
 #endif
 
@@ -173,16 +173,14 @@ void rt_mp_free_sethook(void (*hook)(struct rt_mempool* mp, void *block));
 /*
  * heap memory interface
  */
-void rt_system_heap_init(void* begin_addr, void* end_addr);
+void rt_system_heap_init(void *begin_addr, void *end_addr);
 
-void* rt_malloc(rt_size_t nbytes);
-void rt_free (void *ptr);
-void* rt_realloc(void *ptr, rt_size_t nbytes);
+void *rt_malloc(rt_size_t nbytes);
+void rt_free(void *ptr);
+void *rt_realloc(void *ptr, rt_size_t nbytes);
 void *rt_calloc(rt_size_t count, rt_size_t size);
 
-void rt_memory_info(rt_uint32_t *total, 
-	rt_uint32_t *used,
-	rt_uint32_t *max_used);
+void rt_memory_info(rt_uint32_t *total, rt_uint32_t *used, rt_uint32_t *max_used);
 
 #ifdef RT_USING_SLAB
 void *rt_page_alloc(rt_size_t npages);
@@ -205,44 +203,43 @@ void rt_free_sethook(void (*hook)(void *ptr));
 /*
  * semaphore interface
  */
-rt_err_t rt_sem_init (rt_sem_t sem, const char* name, rt_uint32_t value, rt_uint8_t flag);
-rt_err_t rt_sem_detach (rt_sem_t sem);
-rt_sem_t rt_sem_create (const char* name, rt_uint32_t value, rt_uint8_t flag);
-rt_err_t rt_sem_delete (rt_sem_t sem);
+rt_err_t rt_sem_init(rt_sem_t sem, const char *name, rt_uint32_t value, rt_uint8_t flag);
+rt_err_t rt_sem_detach(rt_sem_t sem);
+rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag);
+rt_err_t rt_sem_delete(rt_sem_t sem);
 
-rt_err_t rt_sem_take (rt_sem_t sem, rt_int32_t time);
+rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time);
 rt_err_t rt_sem_trytake(rt_sem_t sem);
 rt_err_t rt_sem_release(rt_sem_t sem);
-rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void* arg);
+rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void *arg);
 #endif
 
 #ifdef RT_USING_MUTEX
 /*
  * mutex interface
  */
-rt_err_t rt_mutex_init (rt_mutex_t mutex, const char* name, rt_uint8_t flag);
-rt_err_t rt_mutex_detach (rt_mutex_t mutex);
-rt_mutex_t rt_mutex_create (const char* name, rt_uint8_t flag);
-rt_err_t rt_mutex_delete (rt_mutex_t mutex);
+rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag);
+rt_err_t rt_mutex_detach(rt_mutex_t mutex);
+rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);
+rt_err_t rt_mutex_delete(rt_mutex_t mutex);
 
-rt_err_t rt_mutex_take (rt_mutex_t mutex, rt_int32_t time);
+rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time);
 rt_err_t rt_mutex_release(rt_mutex_t mutex);
-rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t cmd, void* arg);
+rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t cmd, void *arg);
 #endif
 
 #ifdef RT_USING_EVENT
 /*
  * event interface
  */
-rt_err_t rt_event_init(rt_event_t event, const char* name, rt_uint8_t flag);
+rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag);
 rt_err_t rt_event_detach(rt_event_t event);
-rt_event_t rt_event_create (const char* name, rt_uint8_t flag);
-rt_err_t rt_event_delete (rt_event_t event);
+rt_event_t rt_event_create(const char *name, rt_uint8_t flag);
+rt_err_t rt_event_delete(rt_event_t event);
 
 rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);
-rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t opt, rt_int32_t timeout, rt_uint32_t* recved);
-rt_err_t rt_event_control (rt_event_t event, rt_uint8_t cmd, void* arg);
-
+rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t opt, rt_int32_t timeout, rt_uint32_t *recved);
+rt_err_t rt_event_control(rt_event_t event, rt_uint8_t cmd, void *arg);
 #endif
 
 #ifdef RT_USING_MAILBOX
@@ -250,30 +247,30 @@ rt_err_t rt_event_control (rt_event_t event, rt_uint8_t cmd, void* arg);
  * mailbox interface
  *
  */
-rt_err_t rt_mb_init(rt_mailbox_t mb, const char* name, void* msgpool, rt_size_t size, rt_uint8_t flag);
+rt_err_t rt_mb_init(rt_mailbox_t mb, const char *name, void *msgpool, rt_size_t size, rt_uint8_t flag);
 rt_err_t rt_mb_detach(rt_mailbox_t mb);
-rt_mailbox_t rt_mb_create (const char* name, rt_size_t size, rt_uint8_t flag);
-rt_err_t rt_mb_delete (rt_mailbox_t mb);
+rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag);
+rt_err_t rt_mb_delete(rt_mailbox_t mb);
 
-rt_err_t rt_mb_send (rt_mailbox_t mb, rt_uint32_t value);
-rt_err_t rt_mb_send_wait (rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);
-rt_err_t rt_mb_recv (rt_mailbox_t mb, rt_uint32_t* value, rt_int32_t timeout);
-rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t cmd, void* arg);
+rt_err_t rt_mb_send(rt_mailbox_t mb, rt_uint32_t value);
+rt_err_t rt_mb_send_wait(rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout);
+rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_uint32_t *value, rt_int32_t timeout);
+rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t cmd, void *arg);
 #endif
 
 #ifdef RT_USING_MESSAGEQUEUE
 /*
  * message queue interface
  */
-rt_err_t rt_mq_init(rt_mq_t mq, const char* name, void *msgpool, rt_size_t msg_size, rt_size_t pool_size, rt_uint8_t flag);
+rt_err_t rt_mq_init(rt_mq_t mq, const char *name, void *msgpool, rt_size_t msg_size, rt_size_t pool_size, rt_uint8_t flag);
 rt_err_t rt_mq_detach(rt_mq_t mq);
-rt_mq_t rt_mq_create (const char* name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag);
-rt_err_t rt_mq_delete (rt_mq_t mq);
+rt_mq_t rt_mq_create(const char *name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag);
+rt_err_t rt_mq_delete(rt_mq_t mq);
 
-rt_err_t rt_mq_send (rt_mq_t mq, void* buffer, rt_size_t size);
-rt_err_t rt_mq_urgent(rt_mq_t mq, void* buffer, rt_size_t size);
-rt_err_t rt_mq_recv (rt_mq_t mq, void* buffer, rt_size_t size, rt_int32_t timeout);
-rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void* arg);
+rt_err_t rt_mq_send(rt_mq_t mq, void *buffer, rt_size_t size);
+rt_err_t rt_mq_urgent(rt_mq_t mq, void *buffer, rt_size_t size);
+rt_err_t rt_mq_recv(rt_mq_t mq, void *buffer, rt_size_t size, rt_int32_t timeout);
+rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void *arg);
 #endif
 /*@}*/
 
@@ -286,9 +283,9 @@ rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void* arg);
  * device (I/O) system interface
  */
 
-rt_device_t rt_device_find(const char* name);
+rt_device_t rt_device_find(const char *name);
 
-rt_err_t rt_device_register(rt_device_t dev, const char* name, rt_uint16_t flags);
+rt_err_t rt_device_register(rt_device_t dev, const char *name, rt_uint16_t flags);
 rt_err_t rt_device_unregister(rt_device_t dev);
 rt_err_t rt_device_init_all(void);
 
@@ -298,9 +295,9 @@ rt_err_t rt_device_set_tx_complete(rt_device_t dev, rt_err_t (*tx_done)(rt_devic
 rt_err_t  rt_device_init (rt_device_t dev);
 rt_err_t  rt_device_open (rt_device_t dev, rt_uint16_t oflag);
 rt_err_t  rt_device_close(rt_device_t dev);
-rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size);
-rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size);
-rt_err_t  rt_device_control(rt_device_t dev, rt_uint8_t cmd, void* arg);
+rt_size_t rt_device_read (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
+rt_size_t rt_device_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
+rt_err_t  rt_device_control(rt_device_t dev, rt_uint8_t cmd, void *arg);
 /*@}*/
 #endif
 
@@ -313,15 +310,15 @@ rt_err_t  rt_device_control(rt_device_t dev, rt_uint8_t cmd, void* arg);
  * module interface
  */
 
-rt_module_t rt_module_load(const char* name, void* module_ptr);
+rt_module_t rt_module_load(const char *name, void *module_ptr);
 rt_err_t rt_module_unload(rt_module_t module);
-rt_module_t rt_module_open(const char* filename);
+rt_module_t rt_module_open(const char *filename);
 void *rt_module_malloc(rt_size_t size);
 void *rt_module_realloc(void *ptr, rt_size_t size);
 void rt_module_free(rt_module_t module, void *addr);
-rt_module_t rt_module_self (void);
-rt_err_t rt_module_set (rt_module_t module);
-rt_module_t rt_module_find(const char* name);
+rt_module_t rt_module_self(void);
+rt_err_t rt_module_set(rt_module_t module);
+rt_module_t rt_module_find(const char *name);
 
 #ifdef RT_USING_HOOK
 void rt_module_load_sethook(void (*hook)(rt_module_t module));
@@ -353,13 +350,13 @@ rt_uint8_t rt_interrupt_get_nest(void);
 /*
  * general kernel service
  */
-rt_int32_t rt_sprintf(char *buf ,const char *format,...);
+rt_int32_t rt_sprintf(char *buf ,const char *format, ...);
 rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
-rt_int32_t rt_sprintf(char *buf ,const char *format,...);
+rt_int32_t rt_sprintf(char *buf ,const char *format, ...);
 rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
 
 #ifdef RT_USING_DEVICE
-rt_device_t rt_console_set_device(const char* name);
+rt_device_t rt_console_set_device(const char *name);
 #endif
 void rt_kprintf(const char *fmt, ...);
 
@@ -372,19 +369,19 @@ int *_rt_errno(void);
 #endif
 #endif
 
-void* rt_memset(void *src, int c, rt_ubase_t n);
-void* rt_memcpy(void *dest, const void *src, rt_ubase_t n);
+void *rt_memset(void *src, int c, rt_ubase_t n);
+void *rt_memcpy(void *dest, const void *src, rt_ubase_t n);
 
-rt_ubase_t rt_strncmp(const char * cs, const char * ct, rt_ubase_t count);
+rt_ubase_t rt_strncmp(const char *cs, const char *ct, rt_ubase_t count);
 rt_ubase_t rt_strcmp (const char *cs, const char *ct);
 rt_ubase_t rt_strlen (const char *src);
 char *rt_strdup(const char *s);
 
-char * rt_strstr( const char * str1, const char * str2 );
-rt_int32_t rt_sscanf(const char * buf, const char * fmt, ...);
+char *rt_strstr(const char *str1, const char *str2);
+rt_int32_t rt_sscanf(const char *buf, const char *fmt, ...);
 char *rt_strncpy(char *dest, const char *src, rt_ubase_t n);
-void* rt_memmove(void *dest, const void *src, rt_ubase_t n);
-rt_int32_t rt_memcmp(const void * cs,const void * ct, rt_ubase_t count);
+void *rt_memmove(void *dest, const void *src, rt_ubase_t n);
+rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_ubase_t count);
 rt_uint32_t rt_strcasecmp(const char *a, const char *b);
 
 void rt_show_version(void);

src/object.c

@@ -187,7 +187,7 @@ struct rt_object_information *rt_object_get_information(enum rt_object_class_typ
 void rt_object_init(struct rt_object *object, enum rt_object_class_type type, const char *name)
 {
 	register rt_base_t temp;
-	struct rt_object_information* information;
+	struct rt_object_information *information;
 
 #ifdef RT_USING_MODULE
 	/* get module object information */

src/thread.c

@@ -142,7 +142,7 @@ rt_err_t rt_thread_init(struct rt_thread *thread,
  * @return the created thread object
  *
  */
-rt_thread_t rt_thread_create (const char *name,
+rt_thread_t rt_thread_create(const char *name,
 	void (*entry)(void *parameter), void *parameter,
 	rt_uint32_t stack_size,
 	rt_uint8_t priority,
@@ -151,7 +151,7 @@ rt_thread_t rt_thread_create (const char *name,
 	struct rt_thread *thread;
 	void *stack_start;
 
-	thread = (struct rt_thread *) rt_object_allocate(RT_Object_Class_Thread, name);
+	thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread, name);
 	if (thread == RT_NULL) return RT_NULL;
 
 	stack_start = (void *)rt_malloc(stack_size);
@@ -603,7 +603,7 @@ rt_err_t rt_thread_resume(rt_thread_t thread)
 
 /**
  * This function is the timeout function for thread, normally which is invoked
- * when thread is timeout to wait some recourse.
+ * when thread is timeout to wait some resourse.
  *
  * @param parameter the parameter of thread timeout function
  *