fixed the coding style in thread.c

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

1 files changed, 343 insertions, 322 deletions

diff --git a/src/thread.c b/src/thread.c
index 2723a8b30e..4f6abc7dd8 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -18,10 +18,11 @@
  * 2006-09-03     Bernard      changed rt_timer_delete to rt_timer_detach
  * 2006-09-03     Bernard      implement rt_thread_detach
  * 2008-02-16     Bernard      fixed the rt_thread_timeout bug
- * 2010-03-21     Bernard      change the errno of rt_thread_delay/sleep to RT_EOK.
+ * 2010-03-21     Bernard      change the errno of rt_thread_delay/sleep to
+ *                             RT_EOK.
  * 2010-11-10     Bernard      add cleanup callback function in thread exit.
- * 2011-09-01     Bernard      fixed rt_thread_exit issue when the current thread preempted, 
- *                             which reported by Jiaxing Lee.
+ * 2011-09-01     Bernard      fixed rt_thread_exit issue when the current
+ *                             thread preempted, which reported by Jiaxing Lee.
  * 2011-09-08     Bernard      fixed the scheduling issue in rt_thread_startup.
  */
 
@@ -34,90 +35,93 @@ extern rt_list_t rt_thread_defunct;
 
 static void rt_thread_exit(void)
 {
-	struct rt_thread *thread;
-	register rt_base_t level;
+    struct rt_thread *thread;
+    register rt_base_t level;
 
-	/* get current thread */
-	thread = rt_current_thread;
+    /* get current thread */
+    thread = rt_current_thread;
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
 
-	/* remove from schedule */
-	rt_schedule_remove_thread(thread);
-	/* change stat */
-	thread->stat = RT_THREAD_CLOSE;
+    /* remove from schedule */
+    rt_schedule_remove_thread(thread);
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
 
-	/* remove it from timer list */
-	rt_list_remove(&(thread->thread_timer.list));
-	rt_object_detach((rt_object_t)&(thread->thread_timer));
+    /* remove it from timer list */
+    rt_list_remove(&(thread->thread_timer.list));
+    rt_object_detach((rt_object_t)&(thread->thread_timer));
 
-	if ((rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE) &&
-		thread->cleanup == RT_NULL)
-	{
-		rt_object_detach((rt_object_t)thread);
-	}
-	else
-	{
-		/* insert to defunct thread list */
-		rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
-	}
+    if ((rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE) &&
+        thread->cleanup == RT_NULL)
+    {
+        rt_object_detach((rt_object_t)thread);
+    }
+    else
+    {
+        /* insert to defunct thread list */
+        rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
+    }
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
 
-	/* switch to next task */
-	rt_schedule();
+    /* switch to next task */
+    rt_schedule();
 }
 
 static 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)
+                                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)
 {
-	/* init thread list */
-	rt_list_init(&(thread->tlist));
+    /* init thread list */
+    rt_list_init(&(thread->tlist));
 
-	thread->entry = (void *)entry;
-	thread->parameter = parameter;
+    thread->entry = (void *)entry;
+    thread->parameter = parameter;
 
-	/* stack init */
-	thread->stack_addr = stack_start;
-	thread->stack_size = stack_size;
+    /* stack init */
+    thread->stack_addr = stack_start;
+    thread->stack_size = stack_size;
 
-	/* init thread stack */
-	rt_memset(thread->stack_addr, '#', thread->stack_size);
-	thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
-		(void *) ((char *)thread->stack_addr + thread->stack_size - 4),
-		(void *)rt_thread_exit);
+    /* init thread stack */
+    rt_memset(thread->stack_addr, '#', thread->stack_size);
+    thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
+        (void *)((char *)thread->stack_addr + thread->stack_size - 4),
+        (void *)rt_thread_exit);
 
-	/* priority init */
-	RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
-	thread->init_priority = priority;
-	thread->current_priority = priority;
+    /* priority init */
+    RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
+    thread->init_priority    = priority;
+    thread->current_priority = priority;
 
-	/* tick init */
-	thread->init_tick = tick;
-	thread->remaining_tick = tick;
+    /* tick init */
+    thread->init_tick      = tick;
+    thread->remaining_tick = tick;
 
-	/* error and flags */
-	thread->error = RT_EOK;
-	thread->stat  = RT_THREAD_INIT;
+    /* error and flags */
+    thread->error = RT_EOK;
+    thread->stat  = RT_THREAD_INIT;
 
-	/* initialize cleanup function and user data */
-	thread->cleanup = 0;
-	thread->user_data = 0;
+    /* initialize cleanup function and user data */
+    thread->cleanup   = 0;
+    thread->user_data = 0;
 
-	/* init thread timer */
-	rt_timer_init(&(thread->thread_timer),
-		thread->name,
-		rt_thread_timeout,
-		thread,
-		0,
-		RT_TIMER_FLAG_ONE_SHOT);
+    /* init thread timer */
+    rt_timer_init(&(thread->thread_timer),
+                  thread->name,
+                  rt_thread_timeout,
+                  thread,
+                  0,
+                  RT_TIMER_FLAG_ONE_SHOT);
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 /**
@@ -142,21 +146,29 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread,
  * @return the operation status, RT_EOK on OK, -RT_ERROR on error
  */
 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)
+                        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)
 {
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
-	RT_ASSERT(stack_start != RT_NULL);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(stack_start != RT_NULL);
 
-	/* init thread object */
-	rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);
+    /* init thread object */
+    rt_object_init((rt_object_t)thread, RT_Object_Class_Thread, name);
 
-	return _rt_thread_init(thread, name, entry, parameter,
-		stack_start, stack_size,
-		priority, tick);
+    return _rt_thread_init(thread,
+                           name,
+                           entry,
+                           parameter,
+                           stack_start,
+                           stack_size,
+                           priority,
+                           tick);
 }
 RTM_EXPORT(rt_thread_init);
 
@@ -167,7 +179,7 @@ RTM_EXPORT(rt_thread_init);
  */
 rt_thread_t rt_thread_self(void)
 {
-	return rt_current_thread;
+    return rt_current_thread;
 }
 RTM_EXPORT(rt_thread_self);
 
@@ -180,35 +192,35 @@ RTM_EXPORT(rt_thread_self);
  */
 rt_err_t rt_thread_startup(rt_thread_t thread)
 {
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
-	RT_ASSERT(thread->stat == RT_THREAD_INIT);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(thread->stat == RT_THREAD_INIT);
 
-	/* set current priority to init priority */
-	thread->current_priority = thread->init_priority;
+    /* set current priority to init priority */
+    thread->current_priority = thread->init_priority;
 
-	/* calculate priority attribute */
+    /* calculate priority attribute */
 #if RT_THREAD_PRIORITY_MAX > 32
-	thread->number      = thread->current_priority >> 3; 			/* 5bit */
-	thread->number_mask = 1L << thread->number;
-	thread->high_mask   = 1L << (thread->current_priority & 0x07); 	/* 3bit */
+    thread->number      = thread->current_priority >> 3;            /* 5bit */
+    thread->number_mask = 1L << thread->number;
+    thread->high_mask   = 1L << (thread->current_priority & 0x07);  /* 3bit */
 #else
-	thread->number_mask = 1L << thread->current_priority;
+    thread->number_mask = 1L << thread->current_priority;
 #endif
 
-	RT_DEBUG_LOG(RT_DEBUG_THREAD, ("startup a thread:%s with priority:%d\n",
+    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("startup a thread:%s with priority:%d\n",
                                    thread->name, thread->init_priority));
-	/* change thread stat */
-	thread->stat = RT_THREAD_SUSPEND;
-	/* then resume it */
-	rt_thread_resume(thread);
-	if (rt_thread_self() != RT_NULL)
-	{
-		/* do a scheduling */
-		rt_schedule();
-	}
+    /* change thread stat */
+    thread->stat = RT_THREAD_SUSPEND;
+    /* then resume it */
+    rt_thread_resume(thread);
+    if (rt_thread_self() != RT_NULL)
+    {
+        /* do a scheduling */
+        rt_schedule();
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_startup);
 
@@ -222,36 +234,36 @@ RTM_EXPORT(rt_thread_startup);
  */
 rt_err_t rt_thread_detach(rt_thread_t thread)
 {
-	rt_base_t lock;
+    rt_base_t lock;
 
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
 
-	/* remove from schedule */
-	rt_schedule_remove_thread(thread);
+    /* remove from schedule */
+    rt_schedule_remove_thread(thread);
 
-	/* release thread timer */
-	rt_timer_detach(&(thread->thread_timer));
+    /* release thread timer */
+    rt_timer_detach(&(thread->thread_timer));
 
-	/* change stat */
-	thread->stat = RT_THREAD_CLOSE;
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
 
-	/* detach object */
-	rt_object_detach((rt_object_t)thread);
+    /* detach object */
+    rt_object_detach((rt_object_t)thread);
 
-	if (thread->cleanup != RT_NULL)
-	{
-		/* disable interrupt */
-		lock = rt_hw_interrupt_disable();
+    if (thread->cleanup != RT_NULL)
+    {
+        /* disable interrupt */
+        lock = rt_hw_interrupt_disable();
 
-		/* insert to defunct thread list */
-		rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
+        /* insert to defunct thread list */
+        rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
 
-		/* enable interrupt */
-		rt_hw_interrupt_enable(lock);
-	}
+        /* enable interrupt */
+        rt_hw_interrupt_enable(lock);
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_detach);
 
@@ -271,32 +283,38 @@ RTM_EXPORT(rt_thread_detach);
  * @return the created thread object
  */
 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)
+    void (*entry)(void *parameter), void *parameter,
+    rt_uint32_t stack_size,
+    rt_uint8_t priority,
+    rt_uint32_t tick)
 {
-	struct rt_thread *thread;
-	void *stack_start;
+    struct rt_thread *thread;
+    void *stack_start;
 
-	thread = (struct rt_thread *)rt_object_allocate(RT_Object_Class_Thread, name);
-	if (thread == RT_NULL)
-		return RT_NULL;
+    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);
-	if (stack_start == RT_NULL)
-	{
-		/* allocate stack failure */
-		rt_object_delete((rt_object_t)thread);
+    stack_start = (void *)rt_malloc(stack_size);
+    if (stack_start == RT_NULL)
+    {
+        /* allocate stack failure */
+        rt_object_delete((rt_object_t)thread);
 
-		return RT_NULL; 
-	}
+        return RT_NULL;
+    }
 
-	_rt_thread_init(thread, name, entry, parameter,
-		stack_start, stack_size,
-		priority, tick);
+    _rt_thread_init(thread,
+                    name,
+                    entry,
+                    parameter,
+                    stack_start,
+                    stack_size,
+                    priority,
+                    tick);
 
-	return thread;
+    return thread;
 }
 RTM_EXPORT(rt_thread_create);
 
@@ -310,30 +328,30 @@ RTM_EXPORT(rt_thread_create);
  */
 rt_err_t rt_thread_delete(rt_thread_t thread)
 {
-	rt_base_t lock;
+    rt_base_t lock;
 
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
 
-	/* remove from schedule */
-	rt_schedule_remove_thread(thread);
+    /* remove from schedule */
+    rt_schedule_remove_thread(thread);
 
-	/* release thread timer */
-	rt_timer_detach(&(thread->thread_timer));
+    /* release thread timer */
+    rt_timer_detach(&(thread->thread_timer));
 
-	/* change stat */
-	thread->stat = RT_THREAD_CLOSE;
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
 
-	/* disable interrupt */
-	lock = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    lock = rt_hw_interrupt_disable();
 
-	/* insert to defunct thread list */
-	rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
+    /* insert to defunct thread list */
+    rt_list_insert_after(&rt_thread_defunct, &(thread->tlist));
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(lock);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(lock);
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_delete);
 #endif
@@ -347,37 +365,38 @@ RTM_EXPORT(rt_thread_delete);
  */
 rt_err_t rt_thread_yield(void)
 {
-	register rt_base_t level;
-	struct rt_thread *thread;
+    register rt_base_t level;
+    struct rt_thread *thread;
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
 
-	/* set to current thread */
-	thread = rt_current_thread;
+    /* set to current thread */
+    thread = rt_current_thread;
 
-	/* if the thread stat is READY and on ready queue list */
-	if (thread->stat == RT_THREAD_READY && thread->tlist.next != thread->tlist.prev)
-	{
-		/* remove thread from thread list */
-		rt_list_remove(&(thread->tlist));
+    /* if the thread stat is READY and on ready queue list */
+    if (thread->stat == RT_THREAD_READY &&
+        thread->tlist.next != thread->tlist.prev)
+    {
+        /* remove thread from thread list */
+        rt_list_remove(&(thread->tlist));
 
-		/* put thread to end of ready queue */
-		rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),
-			&(thread->tlist));
+        /* put thread to end of ready queue */
+        rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),
+                              &(thread->tlist));
 
-		/* enable interrupt */
-		rt_hw_interrupt_enable(level);
+        /* enable interrupt */
+        rt_hw_interrupt_enable(level);
 
-		rt_schedule();
+        rt_schedule();
 
-		return RT_EOK;
-	}
+        return RT_EOK;
+    }
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_yield);
 
@@ -390,32 +409,32 @@ RTM_EXPORT(rt_thread_yield);
  */
 rt_err_t rt_thread_sleep(rt_tick_t tick)
 {
-	register rt_base_t temp;
-	struct rt_thread *thread;
+    register rt_base_t temp;
+    struct rt_thread *thread;
 
-	/* disable interrupt */
-	temp = rt_hw_interrupt_disable();
-	/* set to current thread */
-	thread = rt_current_thread;
-	RT_ASSERT(thread != RT_NULL);
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
+    /* set to current thread */
+    thread = rt_current_thread;
+    RT_ASSERT(thread != RT_NULL);
 
-	/* suspend thread */
-	rt_thread_suspend(thread);
+    /* suspend thread */
+    rt_thread_suspend(thread);
 
-	/* reset the timeout of thread timer and start it */
-	rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
-	rt_timer_start(&(thread->thread_timer));
+    /* reset the timeout of thread timer and start it */
+    rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
+    rt_timer_start(&(thread->thread_timer));
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(temp);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
 
-	rt_schedule();
+    rt_schedule();
 
-	/* clear error number of this thread to RT_EOK */
-	if (thread->error == -RT_ETIMEOUT)
-		thread->error = RT_EOK;
+    /* clear error number of this thread to RT_EOK */
+    if (thread->error == -RT_ETIMEOUT)
+        thread->error = RT_EOK;
 
-	return RT_EOK;
+    return RT_EOK;
 }
 
 /**
@@ -427,7 +446,7 @@ rt_err_t rt_thread_sleep(rt_tick_t tick)
  */
 rt_err_t rt_thread_delay(rt_tick_t tick)
 {
-	return rt_thread_sleep(tick);
+    return rt_thread_sleep(tick);
 }
 RTM_EXPORT(rt_thread_delay);
 
@@ -436,7 +455,7 @@ RTM_EXPORT(rt_thread_delay);
  *
  * @param thread the specified thread to be controlled
  * @param cmd the control command, which includes
- * 	RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread;
+ *  RT_THREAD_CTRL_CHANGE_PRIORITY for changing priority level of thread;
  *  RT_THREAD_CTRL_STARTUP for starting a thread;
  *  RT_THREAD_CTRL_CLOSE for delete a thread.
  * @param arg the argument of control command
@@ -445,69 +464,69 @@ RTM_EXPORT(rt_thread_delay);
  */
 rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void *arg)
 {
-	register rt_base_t temp;
+    register rt_base_t temp;
 
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
 
-	switch (cmd)
-	{
-	case RT_THREAD_CTRL_CHANGE_PRIORITY:
-		/* disable interrupt */
-		temp = rt_hw_interrupt_disable();
+    switch (cmd)
+    {
+    case RT_THREAD_CTRL_CHANGE_PRIORITY:
+        /* disable interrupt */
+        temp = rt_hw_interrupt_disable();
 
-		/* for ready thread, change queue */
-		if (thread->stat == RT_THREAD_READY)
-		{
-			/* remove thread from schedule queue first */
-			rt_schedule_remove_thread(thread);
+        /* for ready thread, change queue */
+        if (thread->stat == RT_THREAD_READY)
+        {
+            /* remove thread from schedule queue first */
+            rt_schedule_remove_thread(thread);
 
-			/* change thread priority */
-			thread->current_priority = *(rt_uint8_t *)arg;
+            /* change thread priority */
+            thread->current_priority = *(rt_uint8_t *)arg;
 
-			/* recalculate priority attribute */
+            /* recalculate priority attribute */
 #if RT_THREAD_PRIORITY_MAX > 32
-			thread->number      = thread->current_priority >> 3; 			/* 5bit */
-			thread->number_mask = 1 << thread->number;
-			thread->high_mask   = 1 << (thread->current_priority & 0x07); 	/* 3bit */
+            thread->number      = thread->current_priority >> 3;            /* 5bit */
+            thread->number_mask = 1 << thread->number;
+            thread->high_mask   = 1 << (thread->current_priority & 0x07);   /* 3bit */
 #else
-			thread->number_mask = 1 << thread->current_priority;
+            thread->number_mask = 1 << thread->current_priority;
 #endif
 
-			/* insert thread to schedule queue again */
-			rt_schedule_insert_thread(thread);
-		}
-		else
-		{
-			thread->current_priority = *(rt_uint8_t *)arg;
+            /* insert thread to schedule queue again */
+            rt_schedule_insert_thread(thread);
+        }
+        else
+        {
+            thread->current_priority = *(rt_uint8_t *)arg;
 
-			/* recalculate priority attribute */
+            /* recalculate priority attribute */
 #if RT_THREAD_PRIORITY_MAX > 32
-			thread->number      = thread->current_priority >> 3; 			/* 5bit */
-			thread->number_mask = 1 << thread->number;
-			thread->high_mask   = 1 << (thread->current_priority & 0x07); 	/* 3bit */
+            thread->number      = thread->current_priority >> 3;            /* 5bit */
+            thread->number_mask = 1 << thread->number;
+            thread->high_mask   = 1 << (thread->current_priority & 0x07);   /* 3bit */
 #else
-			thread->number_mask = 1 << thread->current_priority;
+            thread->number_mask = 1 << thread->current_priority;
 #endif
-		}
+        }
 
-		/* enable interrupt */
-		rt_hw_interrupt_enable(temp);
-		break;
+        /* enable interrupt */
+        rt_hw_interrupt_enable(temp);
+        break;
 
-	case RT_THREAD_CTRL_STARTUP:
-		return rt_thread_startup(thread);
+    case RT_THREAD_CTRL_STARTUP:
+        return rt_thread_startup(thread);
 
 #ifdef RT_USING_HEAP
-	case RT_THREAD_CTRL_CLOSE:
-		return rt_thread_delete(thread);
+    case RT_THREAD_CTRL_CLOSE:
+        return rt_thread_delete(thread);
 #endif
 
-	default:
-		break;
-	}
+    default:
+        break;
+    }
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_control);
 
@@ -523,32 +542,32 @@ RTM_EXPORT(rt_thread_control);
  */
 rt_err_t rt_thread_suspend(rt_thread_t thread)
 {
-	register rt_base_t temp;
+    register rt_base_t temp;
 
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
 
-	RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend:  %s\n", thread->name));
+    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend:  %s\n", thread->name));
 
-	if (thread->stat != RT_THREAD_READY)
-	{
-		RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: thread disorder, %d\n",
+    if (thread->stat != RT_THREAD_READY)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread suspend: thread disorder, %d\n",
                                        thread->stat));
-		
-		return -RT_ERROR;
-	}
+        
+        return -RT_ERROR;
+    }
 
-	/* disable interrupt */
-	temp = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
 
-	/* change thread stat */
-	thread->stat = RT_THREAD_SUSPEND;
-	rt_schedule_remove_thread(thread);
+    /* change thread stat */
+    thread->stat = RT_THREAD_SUSPEND;
+    rt_schedule_remove_thread(thread);
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(temp);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_suspend);
 
@@ -561,40 +580,40 @@ RTM_EXPORT(rt_thread_suspend);
  */
 rt_err_t rt_thread_resume(rt_thread_t thread)
 {
-	register rt_base_t temp;
+    register rt_base_t temp;
 
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
 
-	RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume:  %s\n", thread->name));
+    RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume:  %s\n", thread->name));
 
-	if (thread->stat != RT_THREAD_SUSPEND)
-	{
-		RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n",
+    if (thread->stat != RT_THREAD_SUSPEND)
+    {
+        RT_DEBUG_LOG(RT_DEBUG_THREAD, ("thread resume: thread disorder, %d\n",
                                        thread->stat));
 
-		return -RT_ERROR;
-	}
+        return -RT_ERROR;
+    }
 
-	/* disable interrupt */
-	temp = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
 
-	/* remove from suspend list */
-	rt_list_remove(&(thread->tlist));
+    /* remove from suspend list */
+    rt_list_remove(&(thread->tlist));
 
-	/* remove thread timer */
-	rt_list_remove(&(thread->thread_timer.list));
+    /* remove thread timer */
+    rt_list_remove(&(thread->thread_timer.list));
 
-	/* change timer state */
-	thread->thread_timer.parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
+    /* change timer state */
+    thread->thread_timer.parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(temp);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
 
-	/* insert to schedule ready list */
-	rt_schedule_insert_thread(thread);
+    /* insert to schedule ready list */
+    rt_schedule_insert_thread(thread);
 
-	return RT_EOK;
+    return RT_EOK;
 }
 RTM_EXPORT(rt_thread_resume);
 
@@ -606,25 +625,25 @@ RTM_EXPORT(rt_thread_resume);
  */
 void rt_thread_timeout(void *parameter)
 {
-	struct rt_thread *thread;
+    struct rt_thread *thread;
 
-	thread = (struct rt_thread *)parameter;
+    thread = (struct rt_thread *)parameter;
 
-	/* thread check */
-	RT_ASSERT(thread != RT_NULL);
-	RT_ASSERT(thread->stat == RT_THREAD_SUSPEND);
+    /* thread check */
+    RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(thread->stat == RT_THREAD_SUSPEND);
 
-	/* set error number */
-	thread->error = -RT_ETIMEOUT;
+    /* set error number */
+    thread->error = -RT_ETIMEOUT;
 
-	/* remove from suspend list */
-	rt_list_remove(&(thread->tlist));
+    /* remove from suspend list */
+    rt_list_remove(&(thread->tlist));
 
-	/* insert to schedule ready list */
-	rt_schedule_insert_thread(thread);
+    /* insert to schedule ready list */
+    rt_schedule_insert_thread(thread);
 
-	/* do schedule */
-	rt_schedule();
+    /* do schedule */
+    rt_schedule();
 }
 RTM_EXPORT(rt_thread_timeout);
 
@@ -639,37 +658,39 @@ RTM_EXPORT(rt_thread_timeout);
  */
 rt_thread_t rt_thread_find(char *name)
 {
-	struct rt_object_information *information;
-	struct rt_object *object;
-	struct rt_list_node *node;
+    struct rt_object_information *information;
+    struct rt_object *object;
+    struct rt_list_node *node;
 
-	extern struct rt_object_information rt_object_container[];
+    extern struct rt_object_information rt_object_container[];
 
-	/* enter critical */
-	if (rt_thread_self() != RT_NULL)
-		rt_enter_critical();
+    /* enter critical */
+    if (rt_thread_self() != RT_NULL)
+        rt_enter_critical();
 
-	/* try to find device object */
-	information = &rt_object_container[RT_Object_Class_Thread];
-	for (node = information->object_list.next; node != &(information->object_list); node = node->next)
-	{
-		object = rt_list_entry(node, struct rt_object, list);
-		if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
-		{
-			/* leave critical */
-			if (rt_thread_self() != RT_NULL)
-				rt_exit_critical();
+    /* try to find device object */
+    information = &rt_object_container[RT_Object_Class_Thread];
+    for (node  = information->object_list.next;
+         node != &(information->object_list);
+         node  = node->next)
+    {
+        object = rt_list_entry(node, struct rt_object, list);
+        if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
+        {
+            /* leave critical */
+            if (rt_thread_self() != RT_NULL)
+                rt_exit_critical();
 
-			return (rt_thread_t)object;
-		}
-	}
+            return (rt_thread_t)object;
+        }
+    }
 
-	/* leave critical */
-	if (rt_thread_self() != RT_NULL)
-		rt_exit_critical();
+    /* leave critical */
+    if (rt_thread_self() != RT_NULL)
+        rt_exit_critical();
 
-	/* not found */
-	return RT_NULL;
+    /* not found */
+    return RT_NULL;
 }
 RTM_EXPORT(rt_thread_find);