fixed coding style in src/scheduler.c

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

src/scheduler.c

@@ -12,15 +12,15 @@
  * 2006-03-17     Bernard      the first version
  * 2006-04-28     Bernard      fix the scheduler algorthm
  * 2006-04-30     Bernard      add SCHEDULER_DEBUG
- * 2006-05-27     Bernard      fix the scheduler algorthm for same priority thread
- *                             schedule
+ * 2006-05-27     Bernard      fix the scheduler algorthm for same priority
+ *                             thread schedule
  * 2006-06-04     Bernard      rewrite the scheduler algorithm
  * 2006-08-03     Bernard      add hook support
  * 2006-09-05     Bernard      add 32 priority level support
  * 2006-09-24     Bernard      add rt_system_scheduler_start function
  * 2009-09-16     Bernard      fix _rt_scheduler_stack_check
  * 2010-04-11     yi.qiu       add module feature
- * 2010-07-13     Bernard      fix the maximal number of rt_scheduler_lock_nest 
+ * 2010-07-13     Bernard      fix the maximal number of rt_scheduler_lock_nest
  *                             issue found by kuronca
  * 2010-12-13     Bernard      add defunct list initialization even if not use heap.
  * 2011-05-10     Bernard      clean scheduler debug log.
@@ -83,9 +83,10 @@ static void (*rt_scheduler_hook)(struct rt_thread *from, struct rt_thread *to);
  *
  * @param hook the hook function
  */
-void rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread *to))
+void
+rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread *to))
 {
-	rt_scheduler_hook = hook;
+    rt_scheduler_hook = hook;
 }
 
 /*@}*/
@@ -94,28 +95,29 @@ void rt_scheduler_sethook(void (*hook)(struct rt_thread *from, struct rt_thread
 #ifdef RT_USING_OVERFLOW_CHECK
 static void _rt_scheduler_stack_check(struct rt_thread *thread)
 {
-	RT_ASSERT(thread != RT_NULL);
-
-	if ((rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr ||
-			(rt_uint32_t)thread->sp >
-			(rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size)
-	{
-		rt_uint32_t level;
-
-		rt_kprintf("thread:%s stack overflow\n", thread->name);
-		#ifdef RT_USING_FINSH
-		{
-			extern long list_thread(void);
-			list_thread();
-		}
-		#endif
-		level = rt_hw_interrupt_disable();
-		while (level);
-	}
-	else if ((rt_uint32_t)thread->sp <= ((rt_uint32_t)thread->stack_addr + 32))
-	{
-		rt_kprintf("warning: %s stack is close to end of stack address.\n", thread->name);
-	}
+    RT_ASSERT(thread != RT_NULL);
+
+    if ((rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr ||
+        (rt_uint32_t)thread->sp >
+        (rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size)
+    {
+        rt_uint32_t level;
+
+        rt_kprintf("thread:%s stack overflow\n", thread->name);
+        #ifdef RT_USING_FINSH
+        {
+            extern long list_thread(void);
+            list_thread();
+        }
+        #endif
+        level = rt_hw_interrupt_disable();
+        while (level);
+    }
+    else if ((rt_uint32_t)thread->sp <= ((rt_uint32_t)thread->stack_addr + 32))
+    {
+        rt_kprintf("warning: %s stack is close to end of stack address.\n",
+                   thread->name);
+    }
 }
 #endif
 
@@ -125,31 +127,31 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread)
  */
 void rt_system_scheduler_init(void)
 {
-	register rt_base_t offset;
+    register rt_base_t offset;
 
-	rt_scheduler_lock_nest = 0;
+    rt_scheduler_lock_nest = 0;
 
-	RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n",
+    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("start scheduler: max priority 0x%02x\n",
                                       RT_THREAD_PRIORITY_MAX));
 
-	for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
-	{
-		rt_list_init(&rt_thread_priority_table[offset]);
-	}
+    for (offset = 0; offset < RT_THREAD_PRIORITY_MAX; offset ++)
+    {
+        rt_list_init(&rt_thread_priority_table[offset]);
+    }
 
-	rt_current_priority = RT_THREAD_PRIORITY_MAX - 1;
-	rt_current_thread = RT_NULL;
+    rt_current_priority = RT_THREAD_PRIORITY_MAX - 1;
+    rt_current_thread = RT_NULL;
 
-	/* initialize ready priority group */
-	rt_thread_ready_priority_group = 0;
+    /* initialize ready priority group */
+    rt_thread_ready_priority_group = 0;
 
 #if RT_THREAD_PRIORITY_MAX > 32
-	/* initialize ready table */
-	rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table));
+    /* initialize ready table */
+    rt_memset(rt_thread_ready_table, 0, sizeof(rt_thread_ready_table));
 #endif
 
-	/* initialize thread defunct */
-	rt_list_init(&rt_thread_defunct);
+    /* initialize thread defunct */
+    rt_list_init(&rt_thread_defunct);
 }
 
 /**
@@ -159,48 +161,50 @@ void rt_system_scheduler_init(void)
  */
 void rt_system_scheduler_start(void)
 {
-	register struct rt_thread *to_thread;
-	register rt_ubase_t highest_ready_priority;
+    register struct rt_thread *to_thread;
+    register rt_ubase_t highest_ready_priority;
 
 #if RT_THREAD_PRIORITY_MAX == 8
-	highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group];
+    highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group];
 #else
-	register rt_ubase_t number;
-	/* find out the highest priority task */
-	if (rt_thread_ready_priority_group & 0xff)
-	{
-		number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff];
-	}
-	else if (rt_thread_ready_priority_group & 0xff00)
-	{
-		number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8;
-	}
-	else if (rt_thread_ready_priority_group & 0xff0000)
-	{
-		number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16;
-	}
-	else
-	{
-		number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24;
-	}
+    register rt_ubase_t number;
+    /* find out the highest priority task */
+    if (rt_thread_ready_priority_group & 0xff)
+    {
+        number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff];
+    }
+    else if (rt_thread_ready_priority_group & 0xff00)
+    {
+        number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8;
+    }
+    else if (rt_thread_ready_priority_group & 0xff0000)
+    {
+        number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16;
+    }
+    else
+    {
+        number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24;
+    }
 
 #if RT_THREAD_PRIORITY_MAX > 32
-	highest_ready_priority = (number << 3) + rt_lowest_bitmap[rt_thread_ready_table[number]];
+    highest_ready_priority = (number << 3) +
+                             rt_lowest_bitmap[rt_thread_ready_table[number]];
 #else
-	highest_ready_priority = number;
+    highest_ready_priority = number;
 #endif
 #endif
 
-	/* get switch to thread */
-	to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
-					struct rt_thread, tlist);
+    /* get switch to thread */
+    to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
+                              struct rt_thread,
+                              tlist);
 
-	rt_current_thread = to_thread;
+    rt_current_thread = to_thread;
 
-	/* switch to new thread */
-	rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp);
+    /* switch to new thread */
+    rt_hw_context_switch_to((rt_uint32_t)&to_thread->sp);
 
-	/* never come back */
+    /* never come back */
 }
 
 /**
@@ -215,85 +219,89 @@ void rt_system_scheduler_start(void)
  */
 void rt_schedule(void)
 {
-	rt_base_t level;
-	struct rt_thread *to_thread;
-	struct rt_thread *from_thread;
+    rt_base_t level;
+    struct rt_thread *to_thread;
+    struct rt_thread *from_thread;
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
 
-	/* check the scheduler is enabled or not */
-	if (rt_scheduler_lock_nest == 0)
-	{
-		register rt_ubase_t highest_ready_priority;
+    /* check the scheduler is enabled or not */
+    if (rt_scheduler_lock_nest == 0)
+    {
+        register rt_ubase_t highest_ready_priority;
 
 #if RT_THREAD_PRIORITY_MAX == 8
-		highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group];
+        highest_ready_priority = rt_lowest_bitmap[rt_thread_ready_priority_group];
 #else
-		register rt_ubase_t number;
-		/* find out the highest priority task */
-		if (rt_thread_ready_priority_group & 0xff)
-		{
-			number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff];
-		}
-		else if (rt_thread_ready_priority_group & 0xff00)
-		{
-			number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8;
-		}
-		else if (rt_thread_ready_priority_group & 0xff0000)
-		{
-			number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16;
-		}
-		else
-		{
-			number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24;
-		}
+        register rt_ubase_t number;
+        /* find out the highest priority task */
+        if (rt_thread_ready_priority_group & 0xff)
+        {
+            number = rt_lowest_bitmap[rt_thread_ready_priority_group & 0xff];
+        }
+        else if (rt_thread_ready_priority_group & 0xff00)
+        {
+            number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 8) & 0xff] + 8;
+        }
+        else if (rt_thread_ready_priority_group & 0xff0000)
+        {
+            number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 16) & 0xff] + 16;
+        }
+        else
+        {
+            number = rt_lowest_bitmap[(rt_thread_ready_priority_group >> 24) & 0xff] + 24;
+        }
 
 #if RT_THREAD_PRIORITY_MAX > 32
-		highest_ready_priority = (number << 3) + rt_lowest_bitmap[rt_thread_ready_table[number]];
+        highest_ready_priority = (number << 3) +
+                                 rt_lowest_bitmap[rt_thread_ready_table[number]];
 #else
-		highest_ready_priority = number;
+        highest_ready_priority = number;
 #endif
 #endif
-		/* get switch to thread */
-		to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
-						struct rt_thread, tlist);
-
-		/* if the destination thread is not the same as current thread */
-		if (to_thread != rt_current_thread)
-		{
-			rt_current_priority = highest_ready_priority;
-			from_thread = rt_current_thread;
-			rt_current_thread = to_thread;
-
-			RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread));
-
-			/* switch to new thread */
-			RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
+        /* get switch to thread */
+        to_thread = rt_list_entry(rt_thread_priority_table[highest_ready_priority].next,
+                                  struct rt_thread,
+                                  tlist);
+
+        /* if the destination thread is not the same as current thread */
+        if (to_thread != rt_current_thread)
+        {
+            rt_current_priority = highest_ready_priority;
+            from_thread         = rt_current_thread;
+            rt_current_thread   = to_thread;
+
+            RT_OBJECT_HOOK_CALL(rt_scheduler_hook, (from_thread, to_thread));
+
+            /* switch to new thread */
+            RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
                          ("[%d]switch to priority#%d thread:%s\n",
                           rt_interrupt_nest,
                           highest_ready_priority,
                           to_thread->name));
 
 #ifdef RT_USING_OVERFLOW_CHECK
-			_rt_scheduler_stack_check(to_thread);
+            _rt_scheduler_stack_check(to_thread);
 #endif
 
-			if (rt_interrupt_nest == 0)
-			{
-				rt_hw_context_switch((rt_uint32_t)&from_thread->sp, (rt_uint32_t)&to_thread->sp);
-			}
-			else
-			{
-				RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n"));
-
-				rt_hw_context_switch_interrupt((rt_uint32_t)&from_thread->sp, (rt_uint32_t)&to_thread->sp);
-			}
-		}
-	}
-
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
+            if (rt_interrupt_nest == 0)
+            {
+                rt_hw_context_switch((rt_uint32_t)&from_thread->sp,
+                                     (rt_uint32_t)&to_thread->sp);
+            }
+            else
+            {
+                RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("switch in interrupt\n"));
+
+                rt_hw_context_switch_interrupt((rt_uint32_t)&from_thread->sp,
+                                               (rt_uint32_t)&to_thread->sp);
+            }
+        }
+    }
+
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
 }
 
 /*
@@ -305,25 +313,26 @@ void rt_schedule(void)
  */
 void rt_schedule_insert_thread(struct rt_thread *thread)
 {
-	register rt_base_t temp;
+    register rt_base_t temp;
 
-	RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(thread != RT_NULL);
 
-	/* disable interrupt */
-	temp = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
 
-	/* change stat */
-	thread->stat = RT_THREAD_READY;
+    /* change stat */
+    thread->stat = RT_THREAD_READY;
 
-	/* insert thread to ready list */
-	rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]), &(thread->tlist));
+    /* insert thread to ready list */
+    rt_list_insert_before(&(rt_thread_priority_table[thread->current_priority]),
+                          &(thread->tlist));
 
-	/* set priority mask */
+    /* set priority mask */
 #if RT_THREAD_PRIORITY_MAX <= 32
-	RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%s], the priority: %d\n", 
+    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("insert thread[%s], the priority: %d\n", 
                                       thread->name, thread->current_priority));
 #else
-	RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
+    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
                  ("insert thread[%s], the priority: %d 0x%x %d\n", 
                   thread->name,
                   thread->number,
@@ -332,12 +341,12 @@ void rt_schedule_insert_thread(struct rt_thread *thread)
 #endif
 
 #if RT_THREAD_PRIORITY_MAX > 32
-	rt_thread_ready_table[thread->number] |= thread->high_mask;
+    rt_thread_ready_table[thread->number] |= thread->high_mask;
 #endif
-	rt_thread_ready_priority_group |= thread->number_mask;
+    rt_thread_ready_priority_group |= thread->number_mask;
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(temp);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
 }
 
 /*
@@ -349,18 +358,18 @@ void rt_schedule_insert_thread(struct rt_thread *thread)
  */
 void rt_schedule_remove_thread(struct rt_thread *thread)
 {
-	register rt_base_t temp;
+    register rt_base_t temp;
 
-	RT_ASSERT(thread != RT_NULL);
+    RT_ASSERT(thread != RT_NULL);
 
-	/* disable interrupt */
-	temp = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    temp = rt_hw_interrupt_disable();
 
 #if RT_THREAD_PRIORITY_MAX <= 32
-	RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%s], the priority: %d\n", 
+    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER, ("remove thread[%s], the priority: %d\n", 
                                       thread->name, thread->current_priority));
 #else
-	RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
+    RT_DEBUG_LOG(RT_DEBUG_SCHEDULER,
                  ("remove thread[%s], the priority: %d 0x%x %d\n", 
                   thread->name,
                   thread->number,
@@ -368,23 +377,23 @@ void rt_schedule_remove_thread(struct rt_thread *thread)
                   thread->high_mask));
 #endif
 
-	/* remove thread from ready list */
-	rt_list_remove(&(thread->tlist));
-	if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority])))
-	{
+    /* remove thread from ready list */
+    rt_list_remove(&(thread->tlist));
+    if (rt_list_isempty(&(rt_thread_priority_table[thread->current_priority])))
+    {
 #if RT_THREAD_PRIORITY_MAX > 32
-		rt_thread_ready_table[thread->number] &= ~thread->high_mask;
-		if (rt_thread_ready_table[thread->number] == 0)
-		{
-			rt_thread_ready_priority_group &= ~thread->number_mask;
-		}
+        rt_thread_ready_table[thread->number] &= ~thread->high_mask;
+        if (rt_thread_ready_table[thread->number] == 0)
+        {
+            rt_thread_ready_priority_group &= ~thread->number_mask;
+        }
 #else
-		rt_thread_ready_priority_group &= ~thread->number_mask;
+        rt_thread_ready_priority_group &= ~thread->number_mask;
 #endif
-	}
+    }
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(temp);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(temp);
 }
 
 /**
@@ -392,17 +401,19 @@ void rt_schedule_remove_thread(struct rt_thread *thread)
  */
 void rt_enter_critical(void)
 {
-	register rt_base_t level;
+    register rt_base_t level;
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
 
-	/* the maximal number of nest is RT_UINT16_MAX, which is big 
-	 * enough and does not check here */
-	rt_scheduler_lock_nest ++;
+    /*
+     * the maximal number of nest is RT_UINT16_MAX, which is big
+     * enough and does not check here
+     */
+    rt_scheduler_lock_nest ++;
 
-	/* enable interrupt */
-	rt_hw_interrupt_enable(level);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(level);
 }
 
 /**
@@ -410,26 +421,26 @@ void rt_enter_critical(void)
  */
 void rt_exit_critical(void)
 {
-	register rt_base_t level;
-
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
-
-	rt_scheduler_lock_nest --;
-
-	if (rt_scheduler_lock_nest <= 0)
-	{
-		rt_scheduler_lock_nest = 0;
-		/* enable interrupt */
-		rt_hw_interrupt_enable(level);
-
-		rt_schedule();
-	}
-	else
-	{
-		/* enable interrupt */
-		rt_hw_interrupt_enable(level);
-	}
+    register rt_base_t level;
+
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
+
+    rt_scheduler_lock_nest --;
+
+    if (rt_scheduler_lock_nest <= 0)
+    {
+        rt_scheduler_lock_nest = 0;
+        /* enable interrupt */
+        rt_hw_interrupt_enable(level);
+
+        rt_schedule();
+    }
+    else
+    {
+        /* enable interrupt */
+        rt_hw_interrupt_enable(level);
+    }
 }
 
 /*@}*/