Changeset a0ed4ed in rtems


Ignore:
Timestamp:
Apr 18, 2004, 6:13:55 AM (16 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
429ba3b
Parents:
50f32b11
Message:

Remove stray white spaces.

Location:
cpukit/score
Files:
55 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/include/rtems/debug.h

    r50f32b11 ra0ed4ed  
    22 *
    33 *  This include file contains the information pertaining to the debug
    4  *  support within RTEMS.  It is currently cast in the form of a 
     4 *  support within RTEMS.  It is currently cast in the form of a
    55 *  Manager since it is externally accessible.
    66 *
  • cpukit/score/include/rtems/score/apiext.h

    r50f32b11 ra0ed4ed  
    3131             );
    3232
    33  
     33
    3434typedef struct {
    3535  Chain_Node                      Node;
  • cpukit/score/include/rtems/score/apimutex.h

    r50f32b11 ra0ed4ed  
    22 *
    33 *  This include file contains all the constants and structures associated
    4  *  with the API Mutex Handler.  This handler is used by API level 
     4 *  with the API Mutex Handler.  This handler is used by API level
    55 *  routines to manage mutual exclusion.
    66 *
  • cpukit/score/include/rtems/score/coremsg.h

    r50f32b11 ra0ed4ed  
    4242 *
    4343 *  NOTE:  The buffer field is normally longer than a single uint32_t  .
    44  *         but since messages are variable length we just make a ptr to 1. 
     44 *         but since messages are variable length we just make a ptr to 1.
    4545 */
    4646
     
    101101
    102102/*
    103  *  The following defines the control block used to manage the 
     103 *  The following defines the control block used to manage the
    104104 *  attributes of each message queue.
    105105 */
     
    118118
    119119/*
    120  *  The following defines the control block used to manage each 
     120 *  The following defines the control block used to manage each
    121121 *  counting message_queue.
    122122 */
     
    277277 *  DESCRIPTION:
    278278 *
    279  *  This kernel routine inserts the specified message into the 
     279 *  This kernel routine inserts the specified message into the
    280280 *  message queue.  It is assumed that the message has been filled
    281281 *  in before this routine is called.
  • cpukit/score/include/rtems/score/coremutex.h

    r50f32b11 ra0ed4ed  
    33 *  This include file contains all the constants and structures associated
    44 *  with the Mutex Handler.  A mutex is an enhanced version of the standard
    5  *  Dijkstra binary semaphore used to provide synchronization and mutual 
     5 *  Dijkstra binary semaphore used to provide synchronization and mutual
    66 *  exclusion capabilities.
    77 *
     
    102102
    103103/*
    104  *  The following defines the control block used to manage the 
     104 *  The following defines the control block used to manage the
    105105 *  attributes of each mutex.
    106106 */
  • cpukit/score/include/rtems/score/coresem.h

    r50f32b11 ra0ed4ed  
    6060
    6161/*
    62  *  The following defines the control block used to manage the 
     62 *  The following defines the control block used to manage the
    6363 *  attributes of each semaphore.
    6464 */
     
    7070
    7171/*
    72  *  The following defines the control block used to manage each 
     72 *  The following defines the control block used to manage each
    7373 *  counting semaphore.
    7474 */
  • cpukit/score/include/rtems/score/heap.h

    r50f32b11 ra0ed4ed  
    246246 *    the_info  - pointer to information block
    247247 *
    248  *  Output parameters: 
     248 *  Output parameters:
    249249 *    *the_info - status information
    250250 *    return 0=success, otherwise heap is corrupt.
  • cpukit/score/include/rtems/score/interr.h

    r50f32b11 ra0ed4ed  
    22 *
    33 *  This include file contains constants and prototypes related
    4  *  to the Internal Error Handler. 
     4 *  to the Internal Error Handler.
    55 *
    66 *
  • cpukit/score/include/rtems/score/mpci.h

    r50f32b11 ra0ed4ed  
    153153 */
    154154
    155 SCORE_EXTERN MPCI_Packet_processor 
     155SCORE_EXTERN MPCI_Packet_processor
    156156               _MPCI_Packet_processors[MP_PACKET_CLASSES_LAST+1];
    157157
     
    164164 */
    165165
    166 void _MPCI_Handler_initialization( 
     166void _MPCI_Handler_initialization(
    167167  MPCI_Control            *users_mpci_table,
    168168  uint32_t                 timeout_status
     
    173173 *
    174174 *  DESCRIPTION:
    175  * 
     175 *
    176176 *  This routine creates the packet receive server used in MP systems.
    177177 */
     
    199199 */
    200200
    201 void _MPCI_Register_packet_processor( 
     201void _MPCI_Register_packet_processor(
    202202  MP_packet_Classes      the_class,
    203203  MPCI_Packet_processor  the_packet_processor
  • cpukit/score/include/rtems/score/object.h

    r50f32b11 ra0ed4ed  
    33 *  This include file contains all the constants and structures associated
    44 *  with the Object Handler.  This Handler provides mechanisms which
    5  *  can be used to initialize and manipulate all objects which have 
     5 *  can be used to initialize and manipulate all objects which have
    66 *  ids.
    77 *
     
    479479 *  This function implements the common portion of the object Id
    480480 *  to name directives.  This function returns the name
    481  *  associated with object id. 
     481 *  associated with object id.
    482482 *
    483483 *  NOTE:
     
    505505 *  and the_object is undefined.
    506506 *
    507  *  NOTE: _Objects_Get returns with dispatching disabled for 
     507 *  NOTE: _Objects_Get returns with dispatching disabled for
    508508 *        local and remote objects.
    509509 *        _Objects_Get_isr_disable returns with dispatching
  • cpukit/score/include/rtems/score/objectmp.h

    r50f32b11 ra0ed4ed  
    5353 *  DESCRIPTION:
    5454 *
    55  *  This routine place the specified global object in the 
    56  *  specified information table. 
     55 *  This routine place the specified global object in the
     56 *  specified information table.
    5757 */
    5858
  • cpukit/score/include/rtems/score/priority.h

    r50f32b11 ra0ed4ed  
    5959
    6060SCORE_EXTERN volatile Priority_Bit_map_control _Priority_Major_bit_map;
    61 SCORE_EXTERN Priority_Bit_map_control 
     61SCORE_EXTERN Priority_Bit_map_control
    6262               _Priority_Bit_map[16] CPU_STRUCTURE_ALIGNMENT;
    6363
  • cpukit/score/include/rtems/score/states.h

    r50f32b11 ra0ed4ed  
    3939#define STATES_DELAYING                        0x00008 /* wait for timeout */
    4040#define STATES_WAITING_FOR_TIME                0x00010 /* wait for TOD */
    41 #define STATES_WAITING_FOR_BUFFER              0x00020 
     41#define STATES_WAITING_FOR_BUFFER              0x00020
    4242#define STATES_WAITING_FOR_SEGMENT             0x00040
    4343#define STATES_WAITING_FOR_MESSAGE             0x00080
  • cpukit/score/include/rtems/score/sysstate.h

    r50f32b11 ra0ed4ed  
    4141
    4242/*
    43  *  The following variable indicates whether or not this is 
     43 *  The following variable indicates whether or not this is
    4444 *  an multiprocessing system.
    4545 */
  • cpukit/score/include/rtems/score/thread.h

    r50f32b11 ra0ed4ed  
    3838 *
    3939 *  NOTE:  This cannot always be right.  Some APIs have void
    40  *         tasks/threads, others return pointers, others may 
     40 *         tasks/threads, others return pointers, others may
    4141 *         return a numeric value.  Hopefully a pointer is
    4242 *         always at least as big as an uint32_t  . :)
     
    142142  /*
    143143   *  NOTE: The following assumes that all API return codes can be
    144    *        treated as an uint32_t  . 
     144   *        treated as an uint32_t  .
    145145   */
    146146  uint32_t              return_code;     /* status for thread awakened   */
     
    249249/*
    250250 *  The following context area contains the context of the "thread"
    251  *  which invoked the start multitasking routine.  This context is 
     251 *  which invoked the start multitasking routine.  This context is
    252252 *  restored as the last action of the stop multitasking routine.  Thus
    253253 *  control of the processor can be returned to the environment
     
    382382/*
    383383 *  _Thread_Stack_Allocate
    384  * 
     384 *
    385385 *  DESCRIPTION:
    386386 *
     
    609609void _Thread_Yield_processor( void );
    610610
    611 /* 
     611/*
    612612 *  _Thread_Rotate_Ready_Queue
    613  * 
    614  *  DESCRIPTION:
    615  * 
     613 *
     614 *  DESCRIPTION:
     615 *
    616616 *  This routine is invoked to rotate the ready queue for the
    617617 *  given priority.  It can be used to yeild the processor
     
    728728 *
    729729 *  This routine evaluates the current scheduling information for the
    730  *  system and determines if a context switch is required.  This 
     730 *  system and determines if a context switch is required.  This
    731731 *  is usually called after changing an execution mode such as preemptability
    732732 *  for a thread.
  • cpukit/score/include/rtems/score/threadq.h

    r50f32b11 ra0ed4ed  
    5353             );
    5454
    55 SCORE_EXTERN Thread_queue_Extract_callout 
     55SCORE_EXTERN Thread_queue_Extract_callout
    5656  _Thread_queue_Extract_table[ OBJECTS_CLASSES_LAST + 1 ];
    5757#endif
     
    106106 *
    107107 *  This routine extracts the_thread from the_thread_queue
    108  *  and ensures that if there is a proxy for this task on 
     108 *  and ensures that if there is a proxy for this task on
    109109 *  another node, it is also dealt with.
    110110 */
  • cpukit/score/include/rtems/score/tqdata.h

    r50f32b11 ra0ed4ed  
    5353 *  manages a distinct set of task priorities.  The number of chains
    5454 *  is determined by TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS.
    55  *  The following set must be consistent. 
     55 *  The following set must be consistent.
    5656 *
    5757 *  The set below configures 4 headers -- each contains 64 priorities.
     
    6262 */
    6363
    64 #define TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS 4   
     64#define TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS 4
    6565#define TASK_QUEUE_DATA_PRIORITIES_PER_HEADER      64
    6666#define TASK_QUEUE_DATA_REVERSE_SEARCH_MASK        0x20
  • cpukit/score/include/rtems/score/wkspace.h

    r50f32b11 ra0ed4ed  
    11/*  wkspace.h
    22 *
    3  *  This include file contains information related to the 
     3 *  This include file contains information related to the
    44 *  RAM Workspace.  This Handler provides mechanisms which can be used to
    55 *  define, initialize and manipulate the workspace.
  • cpukit/score/include/rtems/system.h

    r50f32b11 ra0ed4ed  
    3131
    3232/*
    33  *  The cpu options include file defines all cpu dependent 
     33 *  The cpu options include file defines all cpu dependent
    3434 *  parameters for this build of RTEMS.  It must be included
    3535 *  first so the basic macro definitions are in place.
     
    4141 *  The following ensures that all data is declared in the space
    4242 *  of the initialization routine for either the Initialization Manager
    43  *  or the initialization file for the appropriate API.  It is 
     43 *  or the initialization file for the appropriate API.  It is
    4444 *  referenced as "external" in every other file.
    4545 */
  • cpukit/score/src/coremsg.c

    r50f32b11 ra0ed4ed  
    7777       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
    7878
    79   the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 
     79  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
    8080     _Workspace_Allocate( message_buffering_required );
    8181
  • cpukit/score/src/coremsgflushsupp.c

    r50f32b11 ra0ed4ed  
    6666   *
    6767   *  (1) The thread queue of pending senders is a logical extension
    68    *  of the pending message queue.  In this case, it should be 
     68   *  of the pending message queue.  In this case, it should be
    6969   *  flushed using the _Thread_queue_Flush() service with a status
    7070   *  such as CORE_MESSAGE_QUEUE_SENDER_FLUSHED (which currently does
     
    8181   *  pending messages.
    8282   *
    83    *  For now, though, we are very happy to have a small routine with 
     83   *  For now, though, we are very happy to have a small routine with
    8484   *  fixed execution time that only deals with pending messages.
    8585   */
  • cpukit/score/src/coremsgflushwait.c

    r50f32b11 ra0ed4ed  
    5353   *  IF there are no pending messages,
    5454   *  THEN threads may be blocked waiting to RECEIVE a message,
    55    * 
     55   *
    5656   *  IF the pending message queue is full
    5757   *  THEN threads may be blocked waiting to SEND a message
  • cpukit/score/src/coremsginsert.c

    r50f32b11 ra0ed4ed  
    9797   */
    9898
    99   if ( the_message_queue->number_of_pending_messages == 1 && 
     99  if ( the_message_queue->number_of_pending_messages == 1 &&
    100100       the_message_queue->notify_handler )
    101101    (*the_message_queue->notify_handler)( the_message_queue->notify_argument );
  • cpukit/score/src/coremsgseize.c

    r50f32b11 ra0ed4ed  
    9898
    9999    /*
    100      *  There was a thread waiting to send a message.  This code 
    101      *  puts the messages in the message queue on behalf of the 
     100     *  There was a thread waiting to send a message.  This code
     101     *  puts the messages in the message queue on behalf of the
    102102     *  waiting task.
    103103     */
  • cpukit/score/src/coremsgsubmit.c

    r50f32b11 ra0ed4ed  
    152152  /*
    153153   *  WARNING!! executing should NOT be used prior to this point.
    154    *  Thus the unusual choice to open a new scope and declare 
     154   *  Thus the unusual choice to open a new scope and declare
    155155   *  it as a variable.  Doing this emphasizes how dangerous it
    156156   *  would be to use this variable prior to here.
    157157   */
    158158
    159   { 
     159  {
    160160    Thread_Control  *executing = _Thread_Executing;
    161161
  • cpukit/score/src/coremutex.c

    r50f32b11 ra0ed4ed  
    3131 *  structure according to the values passed.
    3232 *
    33  *  Input parameters: 
     33 *  Input parameters:
    3434 *    the_mutex             - the mutex control block to initialize
    3535 *    the_mutex_attributes  - the mutex attributes specified at create time
     
    4646{
    4747
    48 /* Add this to the RTEMS environment later ????????? 
     48/* Add this to the RTEMS environment later ?????????
    4949  rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
    5050                initial_lock == CORE_MUTEX_UNLOCKED );
  • cpukit/score/src/coremutexseize.c

    r50f32b11 ra0ed4ed  
    8181  ISR_Level           *level_p
    8282)
    83 { 
     83{
    8484  Thread_Control   *executing;
    8585  ISR_Level         level = *level_p;
  • cpukit/score/src/coremutexsurrender.c

    r50f32b11 ra0ed4ed  
    6060   *  discipline.  But Priority Ceiling or Priority Inheritance mutexes
    6161   *  must be released by the thread which acquired them.
    62    */ 
     62   */
    6363
    6464  if ( the_mutex->Attributes.only_owner_release ) {
     
    6969  /* XXX already unlocked -- not right status */
    7070
    71   if ( !the_mutex->nest_count ) 
     71  if ( !the_mutex->nest_count )
    7272    return CORE_MUTEX_STATUS_SUCCESSFUL;
    7373
     
    101101  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
    102102       _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
    103     if ( holder->resource_count == 0 && 
     103    if ( holder->resource_count == 0 &&
    104104         holder->real_priority != holder->current_priority ) {
    105105      _Thread_Change_priority( holder, holder->real_priority, TRUE );
     
    118118      ( *api_mutex_mp_support)( the_thread, id );
    119119
    120     } else 
     120    } else
    121121#endif
    122122    {
  • cpukit/score/src/heapextend.c

    r50f32b11 ra0ed4ed  
    9494  the_heap->final = new_final;
    9595
    96   old_final->front_flag = 
     96  old_final->front_flag =
    9797  new_final->back_flag  = _Heap_Build_flag( size, HEAP_BLOCK_USED );
    9898  new_final->front_flag = HEAP_DUMMY_FLAG;
  • cpukit/score/src/heapgetinfo.c

    r50f32b11 ra0ed4ed  
    2727 *    the_info  - pointer for information to be returned
    2828 *
    29  *  Output parameters: 
     29 *  Output parameters:
    3030 *    *the_info  - contains information about heap
    3131 *    return 0=success, otherwise heap is corrupt.
  • cpukit/score/src/mpci.c

    r50f32b11 ra0ed4ed  
    3636 */
    3737
    38 void _MPCI_Handler_initialization( 
     38void _MPCI_Handler_initialization(
    3939  MPCI_Control            *users_mpci_table,
    4040  uint32_t                 timeout_status
  • cpukit/score/src/objectallocate.c

    r50f32b11 ra0ed4ed  
    3939)
    4040{
    41   Objects_Control *the_object = 
     41  Objects_Control *the_object =
    4242    (Objects_Control *) _Chain_Get( &information->Inactive );
    4343
  • cpukit/score/src/objectallocatebyindex.c

    r50f32b11 ra0ed4ed  
    3131 *  DESCRIPTION:
    3232 *
    33  *  This function allocates the object control block 
    34  *  specified by the index from the inactive chain of 
     33 *  This function allocates the object control block
     34 *  specified by the index from the inactive chain of
    3535 *  free object control blocks.
    3636 */
     
    6262    _Chain_Extract( &the_object->Node );
    6363
    64     return the_object;   
    65   }   
     64    return the_object;
     65  }
    6666
    6767  /*
  • cpukit/score/src/objectclearname.c

    r50f32b11 ra0ed4ed  
    4242  uint32_t   *name_ptr = (uint32_t   *) name;
    4343
    44   for ( index=0 ; index < maximum ; index++ ) 
     44  for ( index=0 ; index < maximum ; index++ )
    4545    *name_ptr++ = 0;
    4646}
  • cpukit/score/src/objectextendinformation.c

    r50f32b11 ra0ed4ed  
    8585    Objects_Control **local_table;
    8686    uint32_t          maximum;
    87     void             *old_tables;   
     87    void             *old_tables;
    8888
    8989    /*
     
    131131      object_blocks = (void**)
    132132        _Workspace_Allocate_or_fatal_error(
    133           block_count * 
     133          block_count *
    134134             (sizeof(void *) + sizeof(uint32_t  ) + sizeof(Objects_Name *)) +
    135135          ((maximum + minimum_index) * sizeof(Objects_Control *))
     
    210210    information->maximum = maximum;
    211211    information->maximum_id = _Objects_Build_id(
    212         information->the_api, 
     212        information->the_api,
    213213        information->the_class,
    214214        _Objects_Local_node,
     
    229229
    230230  if ( information->auto_extend ) {
    231     information->object_blocks[ block ] = 
     231    information->object_blocks[ block ] =
    232232      _Workspace_Allocate(
    233233        (information->allocation_size * information->name_length) +
     
    239239  }
    240240  else {
    241     information->object_blocks[ block ] = 
     241    information->object_blocks[ block ] =
    242242      _Workspace_Allocate_or_fatal_error(
    243243        (information->allocation_size * information->name_length) +
     
    272272
    273273    the_object->id = _Objects_Build_id(
    274         information->the_api, 
     274        information->the_api,
    275275        information->the_class,
    276276        _Objects_Local_node,
  • cpukit/score/src/objectfree.c

    r50f32b11 ra0ed4ed  
    4747    uint32_t    block;
    4848
    49     block = 
     49    block =
    5050      _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id );
    5151    block /= information->allocation_size;
  • cpukit/score/src/objectget.c

    r50f32b11 ra0ed4ed  
    6363#endif
    6464
    65    if ( information->maximum >= index ) { 
     65   if ( information->maximum >= index ) {
    6666    _Thread_Disable_dispatch();
    6767    if ( (the_object = information->local_table[ index ]) != NULL ) {
  • cpukit/score/src/objectgetnoprotection.c

    r50f32b11 ra0ed4ed  
    6363#endif
    6464
    65    if ( information->maximum >= index ) { 
     65   if ( information->maximum >= index ) {
    6666    if ( (the_object = information->local_table[ index ]) != NULL ) {
    6767      *location = OBJECTS_LOCAL;
     
    7373  *location = OBJECTS_ERROR;
    7474
    75 /* 
     75/*
    7676 *  Not supported for multiprocessing
    7777 */
  • cpukit/score/src/objectinitializeinformation.c

    r50f32b11 ra0ed4ed  
    3737 *    is_string           - TRUE if names for this object are strings
    3838 *    maximum_name_length - maximum length of each object's name
    39  *    When multiprocessing is configured, 
     39 *    When multiprocessing is configured,
    4040 *      supports_global     - TRUE if this is a global object class
    4141 *      extract_callout     - pointer to threadq extract callout if MP
     
    6767
    6868  information->the_api            = the_api;
    69   information->the_class          = the_class; 
    70   information->is_string          = is_string; 
     69  information->the_class          = the_class;
     70  information->is_string          = is_string;
    7171
    7272  information->local_table        = 0;
     
    125125
    126126  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
    127     name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 
     127    name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
    128128                  ~(OBJECTS_NAME_ALIGNMENT-1);
    129129
  • cpukit/score/src/threadchangepriority.c

    r50f32b11 ra0ed4ed  
    6666  /*
    6767   *  Techically, the prepend should conditional on the thread lowering
    68    *  its priority but that does allow cxd2004 of the acvc 2.0.1 to 
     68   *  its priority but that does allow cxd2004 of the acvc 2.0.1 to
    6969   *  pass with rtems 4.0.0.  This should change when gnat redoes its
    7070   *  priority scheme.
     
    7272/*
    7373  if ( prepend_it &&
    74        _Thread_Is_executing( the_thread ) && 
     74       _Thread_Is_executing( the_thread ) &&
    7575       new_priority >= the_thread->current_priority )
    7676    prepend_it = TRUE;
  • cpukit/score/src/threadclearstate.c

    r50f32b11 ra0ed4ed  
    5959
    6060    if ( current_state & state ) {
    61       current_state = 
     61      current_state =
    6262      the_thread->current_state = _States_Clear( state, current_state );
    6363
  • cpukit/score/src/threadhandler.c

    r50f32b11 ra0ed4ed  
    4242 *
    4343 *  On entry, it is assumed all interrupts are blocked and that this
    44  *  routine needs to set the initial isr level.  This may or may not 
     44 *  routine needs to set the initial isr level.  This may or may not
    4545 *  actually be needed by the context switch routine and as a result
    4646 *  interrupts may already be at there proper level.  Either way,
    4747 *  setting the initial isr level properly here is safe.
    48  * 
     48 *
    4949 *  Currently this is only really needed for the posix port,
    5050 *  ref: _Context_Switch in unix/cpu.c
     
    121121  switch ( executing->Start.prototype ) {
    122122    case THREAD_START_NUMERIC:
    123       executing->Wait.return_argument = 
     123      executing->Wait.return_argument =
    124124        (*(Thread_Entry_numeric) executing->Start.entry_point)(
    125125          executing->Start.numeric_argument
     
    133133      break;
    134134    case THREAD_START_BOTH_POINTER_FIRST:
    135       executing->Wait.return_argument = 
    136          (*(Thread_Entry_both_pointer_first) executing->Start.entry_point)( 
     135      executing->Wait.return_argument =
     136         (*(Thread_Entry_both_pointer_first) executing->Start.entry_point)(
    137137           executing->Start.pointer_argument,
    138138           executing->Start.numeric_argument
     
    140140      break;
    141141    case THREAD_START_BOTH_NUMERIC_FIRST:
    142       executing->Wait.return_argument = 
    143          (*(Thread_Entry_both_numeric_first) executing->Start.entry_point)( 
     142      executing->Wait.return_argument =
     143         (*(Thread_Entry_both_numeric_first) executing->Start.entry_point)(
    144144           executing->Start.numeric_argument,
    145145           executing->Start.pointer_argument
     
    151151   *  In the switch above, the return code from the user thread body
    152152   *  was placed in return_argument.  This assumed that if it returned
    153    *  anything (which is not supporting in all APIs), then it would be 
     153   *  anything (which is not supporting in all APIs), then it would be
    154154   *  able to fit in a (void *).
    155155   */
  • cpukit/score/src/threadinitialize.c

    r50f32b11 ra0ed4ed  
    7777    actual_stack_size = _Thread_Stack_Allocate( the_thread, actual_stack_size );
    7878
    79     if ( !actual_stack_size ) 
     79    if ( !actual_stack_size )
    8080      return FALSE;                     /* stack allocation failed */
    8181
     
    140140      return FALSE;
    141141    }
    142   } else 
     142  } else
    143143    extensions_area = NULL;
    144144
  • cpukit/score/src/threadqdequeuefifo.c

    r50f32b11 ra0ed4ed  
    6868
    6969    return the_thread;
    70   } 
     70  }
    7171
    7272  switch ( the_thread_queue->sync_state ) {
  • cpukit/score/src/threadqenqueuefifo.c

    r50f32b11 ra0ed4ed  
    5555
    5656  switch ( sync_state ) {
    57     case THREAD_QUEUE_SYNCHRONIZED: 
     57    case THREAD_QUEUE_SYNCHRONIZED:
    5858      /*
    5959       *  This should never happen.  It indicates that someone did not
     
    6262      break;
    6363
    64     case THREAD_QUEUE_NOTHING_HAPPENED: 
     64    case THREAD_QUEUE_NOTHING_HAPPENED:
    6565      _Chain_Append_unprotected(
    6666        &the_thread_queue->Queues.Fifo,
     
    7070      return;
    7171
    72     case THREAD_QUEUE_TIMEOUT: 
     72    case THREAD_QUEUE_TIMEOUT:
    7373      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
    7474      _ISR_Enable( level );
  • cpukit/score/src/threadqextractwithproxy.c

    r50f32b11 ra0ed4ed  
    2727 *
    2828 *  This routine extracts the_thread from the_thread_queue
    29  *  and ensures that if there is a proxy for this task on 
     29 *  and ensures that if there is a proxy for this task on
    3030 *  another node, it is also dealt with.
    3131 *
     
    4949      the_information = _Objects_Get_information( the_thread->Wait.id );
    5050
    51       proxy_extract_callout = 
     51      proxy_extract_callout =
    5252        (Objects_Thread_queue_Extract_callout) the_information->extract;
    5353
  • cpukit/score/src/threadready.c

    r50f32b11 ra0ed4ed  
    6868  heir = _Thread_Heir;
    6969
    70   if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 
     70  if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible )
    7171    _Context_Switch_necessary = TRUE;
    7272
  • cpukit/score/src/threadresume.c

    r50f32b11 ra0ed4ed  
    7171  current_state = the_thread->current_state;
    7272  if ( current_state & STATES_SUSPENDED ) {
    73     current_state = 
     73    current_state =
    7474    the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
    7575
  • cpukit/score/src/threadrotatequeue.c

    r50f32b11 ra0ed4ed  
    3939 *  running is also the currently the heir.
    4040 *
    41  *  Input parameters: 
     41 *  Input parameters:
    4242 *      Priority of the queue we wish to modify.
    4343 *
     
    4949 */
    5050
    51 void _Thread_Rotate_Ready_Queue( 
     51void _Thread_Rotate_Ready_Queue(
    5252  Priority_Control  priority
    5353)
  • cpukit/score/src/threadstackallocate.c

    r50f32b11 ra0ed4ed  
    6464     *  stack control block because it is later used in the free sequence.
    6565     *
    66      *  Thus it is the responsibility of the CPU dependent code to 
    67      *  get and keep the stack adjust factor, the stack alignment, and 
     66     *  Thus it is the responsibility of the CPU dependent code to
     67     *  get and keep the stack adjust factor, the stack alignment, and
    6868     *  the context initialization sequence in sync.
    6969     */
  • cpukit/score/src/threadstartmultitasking.c

    r50f32b11 ra0ed4ed  
    5151{
    5252  /*
    53    *  The system is now multitasking and completely initialized. 
    54    *  This system thread now either "goes away" in a single processor 
     53   *  The system is now multitasking and completely initialized.
     54   *  This system thread now either "goes away" in a single processor
    5555   *  system or "turns into" the server thread in an MP system.
    5656   */
  • cpukit/score/src/threadtickletimeslice.c

    r50f32b11 ra0ed4ed  
    5353
    5454  /*
    55    *  If the thread is not preemptible or is not ready, then 
     55   *  If the thread is not preemptible or is not ready, then
    5656   *  just return.
    5757   */
  • cpukit/score/src/watchdoginsert.c

    r50f32b11 ra0ed4ed  
    7575
    7676     /*
    77       *  If you experience problems comment out the _ISR_Flash line. 
     77      *  If you experience problems comment out the _ISR_Flash line.
    7878      *  3.2.0 was the first release with this critical section redesigned.
    7979      *  Under certain circumstances, the PREVIOUS critical section algorithm
    8080      *  used around this flash point allowed interrupts to execute
    81       *  which violated the design assumptions.  The critical section 
     81      *  which violated the design assumptions.  The critical section
    8282      *  mechanism used here WAS redesigned to address this.
    8383      */
  • cpukit/score/src/watchdogremove.c

    r50f32b11 ra0ed4ed  
    3939      break;
    4040
    41     case WATCHDOG_BEING_INSERTED: 
     41    case WATCHDOG_BEING_INSERTED:
    4242
    4343      /*
  • cpukit/score/src/watchdogtickle.c

    r50f32b11 ra0ed4ed  
    4040  /*
    4141   * See the comment in watchdoginsert.c and watchdogadjust.c
    42    * about why it's safe not to declare header a pointer to 
     42   * about why it's safe not to declare header a pointer to
    4343   * volatile data - till, 2003/7
    4444   */
     
    7070         /*
    7171          *  This state indicates that the watchdog is not on any chain.
    72           *  Thus, it is NOT on a chain being tickled.  This case should 
     72          *  Thus, it is NOT on a chain being tickled.  This case should
    7373          *  never occur.
    7474          */
Note: See TracChangeset for help on using the changeset viewer.