Changeset 05279b84 in rtems


Ignore:
Timestamp:
Apr 17, 2004, 1:32:13 PM (16 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
50f32b11
Parents:
3b2c473
Message:

Remove stray white spaces.

Location:
cpukit/score
Files:
74 edited

Legend:

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

    r3b2c473 r05279b84  
    7171 *  This routine disables the specified types of debug checks.
    7272 */
    73  
     73
    7474void rtems_debug_disable (
    7575  rtems_debug_control  to_be_disabled
    7676);
    77  
     77
    7878/*
    7979 *
  • cpukit/score/include/rtems/score/apiext.h

    r3b2c473 r05279b84  
    2424 *  can add an extension to the system initialization thread.
    2525 */
    26  
     26
    2727typedef void (*API_extensions_Predriver_hook)(void);
    2828typedef void (*API_extensions_Postdriver_hook)(void);
     
    3030                 Thread_Control *
    3131             );
    32  
     32
    3333 
    3434typedef struct {
     
    4242 *  This is the list of API extensions to the system initialization.
    4343 */
    44  
     44
    4545SCORE_EXTERN Chain_Control _API_extensions_List;
    4646
     
    5353 *
    5454 */
    55  
     55
    5656void _API_extensions_Initialization( void );
    57  
     57
    5858/*
    5959 *  _API_extensions_Add
     
    6363 *  XXX
    6464 */
    65  
     65
    6666void _API_extensions_Add(
    6767  API_extensions_Control *the_extension
     
    7575 *  XXX
    7676 */
    77  
     77
    7878void _API_extensions_Run_predriver( void );
    7979
  • cpukit/score/include/rtems/score/apimutex.h

    r3b2c473 r05279b84  
    110110      &(_the_mutex)->Mutex, (_the_mutex)->Object.id, TRUE, 0, (_level) ); \
    111111  } while (0)
    112  
     112
    113113/*
    114114 *  _API_Mutex_Unlock
  • cpukit/score/include/rtems/score/bitfield.h

    r3b2c473 r05279b84  
    6262};
    6363#endif
    64  
     64
    6565#endif
    6666
  • cpukit/score/include/rtems/score/chain.h

    r3b2c473 r05279b84  
    8686 *  _Chain_Get_first_unprotected
    8787 */
    88  
     88
    8989#ifndef RTEMS_INLINES
    9090Chain_Node *_Chain_Get_first_unprotected(
  • cpukit/score/include/rtems/score/coremsg.h

    r3b2c473 r05279b84  
    1313 *  $Id$
    1414 */
    15  
     15
    1616#ifndef __RTEMS_CORE_MESSAGE_QUEUE_h
    1717#define __RTEMS_CORE_MESSAGE_QUEUE_h
    18  
     18
    1919#ifdef __cplusplus
    2020extern "C" {
     
    2626#include <rtems/score/priority.h>
    2727#include <rtems/score/watchdog.h>
    28  
     28
    2929/*
    3030 *  The following type defines the callout which the API provides
    3131 *  to support global/multiprocessor operations on message_queues.
    3232 */
    33  
     33
    3434typedef void ( *CORE_message_queue_API_mp_support_callout )(
    3535                 Thread_Control *,
     
    4444 *         but since messages are variable length we just make a ptr to 1. 
    4545 */
    46  
     46
    4747typedef struct {
    4848    uint32_t    size;
    4949    uint32_t    buffer[1];
    5050} CORE_message_queue_Buffer;
    51  
     51
    5252/*
    5353 *  The following records define the organization of a message
    5454 *  buffer.
    5555 */
    56  
     56
    5757typedef struct {
    5858  Chain_Node                 Node;
     
    8282#define  CORE_MESSAGE_QUEUE_SEND_REQUEST   INT_MAX
    8383#define  CORE_MESSAGE_QUEUE_URGENT_REQUEST INT_MIN
    84  
     84
    8585typedef int CORE_message_queue_Submit_types;
    8686
     
    8888 *  Core Message queue handler return statuses.
    8989 */
    90  
     90
    9191typedef enum {
    9292  CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL,
     
    108108  CORE_message_queue_Disciplines  discipline;
    109109}   CORE_message_queue_Attributes;
    110  
     110
    111111/*
    112112 *  The following defines the type for a Notification handler.  A notification
     
    121121 *  counting message_queue.
    122122 */
    123  
     123
    124124typedef struct {
    125125  Thread_queue_Control               Wait_queue;
     
    149149  uint32_t                       maximum_message_size
    150150);
    151  
     151
    152152/*
    153153 *  _CORE_message_queue_Close
     
    158158 *  flushing the message_queue's task wait queue.
    159159 */
    160  
     160
    161161void _CORE_message_queue_Close(
    162162  CORE_message_queue_Control *the_message_queue,
     
    187187 *  them to the inactive message chain.
    188188 */
    189  
     189
    190190uint32_t   _CORE_message_queue_Flush_support(
    191191  CORE_message_queue_Control *the_message_queue
    192192);
    193  
     193
    194194/*
    195195 *  _CORE_message_queue_Flush_waiting_threads
     
    215215 *
    216216 */
    217  
     217
    218218CORE_message_queue_Status _CORE_message_queue_Broadcast(
    219219  CORE_message_queue_Control                *the_message_queue,
     
    238238 *
    239239 */
    240  
     240
    241241CORE_message_queue_Status _CORE_message_queue_Submit(
    242242  CORE_message_queue_Control                *the_message_queue,
     
    262262 *  NOTE: Returns message priority via return are in TCB.
    263263 */
    264  
     264
    265265void _CORE_message_queue_Seize(
    266266  CORE_message_queue_Control      *the_message_queue,
     
    295295}
    296296#endif
    297  
     297
    298298#endif
    299299/*  end of include file */
  • cpukit/score/include/rtems/score/coremutex.h

    r3b2c473 r05279b84  
    1515 *  $Id$
    1616 */
    17  
     17
    1818#ifndef __RTEMS_CORE_MUTEX_h
    1919#define __RTEMS_CORE_MUTEX_h
    20  
     20
    2121#ifdef __cplusplus
    2222extern "C" {
     
    2929#include <rtems/score/interr.h>
    3030#include <rtems/score/sysstate.h>
    31  
     31
    3232/*
    3333 *  The following type defines the callout which the API provides
    3434 *  to support global/multiprocessor operations on mutexes.
    3535 */
    36  
     36
    3737typedef void ( *CORE_mutex_API_mp_support_callout )(
    3838                 Thread_Control *,
     
    5454 *  Mutex handler return statuses.
    5555 */
    56  
     56
    5757typedef enum {
    5858  CORE_MUTEX_STATUS_SUCCESSFUL,
     
    9393  CORE_MUTEX_NESTING_BLOCKS
    9494}  CORE_mutex_Nesting_behaviors;
    95  
     95
    9696/*
    9797 *  Locked and unlocked values
     
    112112  Priority_Control             priority_ceiling;
    113113}   CORE_mutex_Attributes;
    114  
     114
    115115/*
    116116 *  The following defines the control block used to manage each mutex.
    117117 */
    118  
     118
    119119typedef struct {
    120120  Thread_queue_Control    Wait_queue;
     
    140140  uint32_t                      initial_lock
    141141);
    142  
     142
    143143/*
    144144 *  _CORE_mutex_Seize
     
    210210  CORE_mutex_API_mp_support_callout  api_mutex_mp_support
    211211);
    212  
     212
    213213/*
    214214 *  _CORE_mutex_Flush
     
    219219 *  wait queue.
    220220 */
    221  
     221
    222222void _CORE_mutex_Flush(
    223223  CORE_mutex_Control         *the_mutex,
     
    225225  uint32_t                    status
    226226);
    227  
     227
    228228#include <rtems/score/coremutex.inl>
    229229#endif
     
    232232}
    233233#endif
    234  
     234
    235235#endif
    236236/*  end of include file */
  • cpukit/score/include/rtems/score/coresem.h

    r3b2c473 r05279b84  
    1515 *  $Id$
    1616 */
    17  
     17
    1818#ifndef __RTEMS_CORE_COUNTING_SEMAPHORE_h
    1919#define __RTEMS_CORE_COUNTING_SEMAPHORE_h
    20  
     20
    2121#ifdef __cplusplus
    2222extern "C" {
     
    2727#include <rtems/score/priority.h>
    2828#include <rtems/score/watchdog.h>
    29  
     29
    3030/*
    3131 *  The following type defines the callout which the API provides
    3232 *  to support global/multiprocessor operations on semaphores.
    3333 */
    34  
     34
    3535typedef void ( *CORE_semaphore_API_mp_support_callout )(
    3636                 Thread_Control *,
     
    5050 *  Core Semaphore handler return statuses.
    5151 */
    52  
     52
    5353typedef enum {
    5454  CORE_SEMAPHORE_STATUS_SUCCESSFUL,
     
    6868  CORE_semaphore_Disciplines  discipline;
    6969}   CORE_semaphore_Attributes;
    70  
     70
    7171/*
    7272 *  The following defines the control block used to manage each
    7373 *  counting semaphore.
    7474 */
    75  
     75
    7676typedef struct {
    7777  Thread_queue_Control        Wait_queue;
     
    9393  uint32_t                      initial_value
    9494);
    95  
     95
    9696/*
    9797 *  _CORE_semaphore_Seize
     
    111111  Watchdog_Interval        timeout
    112112);
    113  
     113
    114114/*
    115115 *  _CORE_semaphore_Surrender
     
    127127  CORE_semaphore_API_mp_support_callout  api_semaphore_mp_support
    128128);
    129  
     129
    130130/*
    131131 *  _CORE_semaphore_Flush
     
    150150}
    151151#endif
    152  
     152
    153153#endif
    154154/*  end of include file */
  • cpukit/score/include/rtems/score/heap.h

    r3b2c473 r05279b84  
    4545    HEAP_GET_INFORMATION_BLOCK_ERROR
    4646}  Heap_Get_information_status;
    47        
     47
    4848/*
    4949 *  Information block returned by _Heap_Get_information
  • cpukit/score/include/rtems/score/interr.h

    r3b2c473 r05279b84  
    6161 *  This type holds the fatal error information.
    6262 */
    63  
     63
    6464typedef struct {
    6565  Internal_errors_Source  the_source;
  • cpukit/score/include/rtems/score/isr.h

    r3b2c473 r05279b84  
    6161 *  the cpu can vector.
    6262 */
    63  
     63
    6464#define ISR_NUMBER_OF_VECTORS                CPU_INTERRUPT_NUMBER_OF_VECTORS
    6565
     
    167167 *  This routine returns the current interrupt level.
    168168 */
    169  
     169
    170170#define _ISR_Get_level() \
    171171        _CPU_ISR_Get_level()
    172  
     172
    173173/*
    174174 *  _ISR_Set_level
  • cpukit/score/include/rtems/score/mpci.h

    r3b2c473 r05279b84  
    3333 *  the system threads.
    3434 */
    35  
     35
    3636#define MPCI_RECEIVE_SERVER_STACK_SIZE \
    3737  ( STACK_MINIMUM_SIZE + \
     
    101101
    102102typedef void (*MPCI_Packet_processor)( MP_packet_Prefix * );
    103  
     103
    104104/*
    105105 *  The following enumerated type defines the list of
    106106 *  internal MP operations.
    107107 */
    108  
     108
    109109typedef enum {
    110110  MPCI_PACKETS_SYSTEM_VERIFY  =  0
    111111}   MPCI_Internal_Remote_operations;
    112  
     112
    113113/*
    114114 *  The following data structure defines the packet used to perform
    115115 *  remote event operations.
    116116 */
    117  
     117
    118118typedef struct {
    119119  MP_packet_Prefix                 Prefix;
     
    139139 *  configuration information.
    140140 */
    141  
     141
    142142SCORE_EXTERN MPCI_Control *_MPCI_table;
    143143
     
    145145 *  The following points to the MPCI Receive Server.
    146146 */
    147  
     147
    148148SCORE_EXTERN Thread_Control *_MPCI_Receive_server_tcb;
    149149
     
    198198 *  designated object class.
    199199 */
    200  
     200
    201201void _MPCI_Register_packet_processor(
    202202  MP_packet_Classes      the_class,
    203203  MPCI_Packet_processor  the_packet_processor
    204  
    205 );
    206  
     204
     205);
     206
    207207/*
    208208 *  _MPCI_Get_packet
     
    301301 *
    302302 */
    303  
     303
    304304Thread _MPCI_Receive_server(
    305305  uint32_t   ignored
     
    314314 *  XXX
    315315 */
    316  
     316
    317317void _MPCI_Announce ( void );
    318318
     
    325325 *  process operation can be performed on another node.
    326326 */
    327  
     327
    328328void _MPCI_Internal_packets_Send_process_packet (
    329329   MPCI_Internal_Remote_operations operation
    330330);
    331  
     331
    332332/*
    333333 *  _MPCI_Internal_packets_Send_request_packet
     
    341341 *  packets to be sent by this manager.
    342342 */
    343  
     343
    344344/*
    345345 *  _MPCI_Internal_packets_Send_response_packet
     
    353353 *  packets to be sent by this manager.
    354354 */
    355  
     355
    356356/*
    357357 *
     
    363363 *  the request from another node.
    364364 */
    365  
     365
    366366void _MPCI_Internal_packets_Process_packet (
    367367  MP_packet_Prefix *the_packet_prefix
    368368);
    369  
     369
    370370/*
    371371 *  _MPCI_Internal_packets_Send_object_was_deleted
     
    380380 *  deleted by this manager.
    381381 */
    382  
     382
    383383/*
    384384 *  _MPCI_Internal_packets_Send_extract_proxy
     
    393393 *  deleted by this manager.
    394394 */
    395  
     395
    396396/*
    397397 *  _MPCI_Internal_packets_Get_packet
     
    401401 *  This routine is used to obtain a internal threads mp packet.
    402402 */
    403  
     403
    404404 MPCI_Internal_packet *_MPCI_Internal_packets_Get_packet ( void );
    405405
  • cpukit/score/include/rtems/score/object.h

    r3b2c473 r05279b84  
    378378 *  This method zeroes out the name.
    379379 */
    380  
     380
    381381void _Objects_Clear_name(
    382382  void       *name,
  • cpukit/score/include/rtems/score/objectmp.h

    r3b2c473 r05279b84  
    5656 *  specified information table. 
    5757 */
    58  
     58
    5959void _Objects_MP_Open (
    6060  Objects_Information *information,
  • cpukit/score/include/rtems/score/priority.h

    r3b2c473 r05279b84  
    7474 *  These may simply be pass throughs to CPU dependent routines.
    7575 */
    76  
     76
    7777#if ( CPU_USE_GENERIC_BITFIELD_CODE == FALSE )
    7878
    7979#define _Priority_Mask( _bit_number ) \
    8080  _CPU_Priority_Mask( _bit_number )
    81  
     81
    8282#define _Priority_Bits_index( _priority ) \
    8383  _CPU_Priority_bits_index( _priority )
    8484
    8585#endif
    86  
     86
    8787#ifndef __RTEMS_APPLICATION__
    8888#include <rtems/score/priority.inl>
  • cpukit/score/include/rtems/score/sysstate.h

    r3b2c473 r05279b84  
    4444 *  an multiprocessing system.
    4545 */
    46  
     46
    4747SCORE_EXTERN boolean _System_state_Is_multiprocessing;
    4848
  • cpukit/score/include/rtems/score/thread.h

    r3b2c473 r05279b84  
    232232
    233233SCORE_EXTERN void *rtems_ada_self;
    234  
     234
    235235/*
    236236 *  The following defines the information control block used to
    237237 *  manage this class of objects.
    238238 */
    239  
     239
    240240SCORE_EXTERN Objects_Information _Thread_Internal_information;
    241  
     241
    242242/*
    243243 *  The following define the thread control pointers used to access
    244244 *  and manipulate the idle thread.
    245245 */
    246  
     246
    247247SCORE_EXTERN Thread_Control *_Thread_Idle;
    248248
     
    254254 *  which initiated the system.
    255255 */
    256  
     256
    257257SCORE_EXTERN Context_Control _Thread_BSP_context;
    258  
     258
    259259/*
    260260 *  The following declares the dispatch critical section nesting
     
    349349 *  WARNING!! No thread should be created before this one.
    350350 */
    351  
     351
    352352void _Thread_Create_idle( void );
    353353
     
    454454 *  thread competes with all other threads for CPU time.
    455455 */
    456  
     456
    457457boolean _Thread_Start(
    458458  Thread_Control           *the_thread,
     
    472472 *  original starting point.
    473473 */
    474  
     474
    475475/* XXX multiple task arg profiles */
    476  
     476
    477477boolean _Thread_Restart(
    478478  Thread_Control           *the_thread,
     
    489489 *  not restart it.
    490490 */
    491  
     491
    492492void _Thread_Reset(
    493493  Thread_Control      *the_thread,
     
    505505 *  operations on this thread are allowed.
    506506 */
    507  
     507
    508508void _Thread_Close(
    509509  Objects_Information  *information,
     
    741741 *         subroutine call.
    742742 */
    743  
     743
    744744#ifndef RTEMS_INLINES
    745745Thread_Control *_Thread_Get (
     
    756756 *  This routine is the body of the system idle thread.
    757757 */
    758  
     758
    759759#if (CPU_PROVIDES_IDLE_THREAD_BODY == FALSE)
    760760Thread _Thread_Idle_body(
     
    771771 *  invokes the specified routine.
    772772 */
    773  
     773
    774774typedef void (*rtems_per_thread_routine)( Thread_Control * );
    775775
  • cpukit/score/include/rtems/score/threadq.h

    r3b2c473 r05279b84  
    3030 *  Constant for indefinite wait.
    3131 */
    32  
     32
    3333#define THREAD_QUEUE_WAIT_FOREVER  WATCHDOG_NO_TIMEOUT
    3434
     
    4747 *  extracted from the remote queue).
    4848 */
    49  
     49
    5050#if 0
    5151typedef void ( *Thread_queue_Extract_callout )(
     
    109109 *  another node, it is also dealt with.
    110110 */
    111  
     111
    112112boolean _Thread_queue_Extract_with_proxy(
    113113  Thread_Control       *the_thread
  • cpukit/score/include/rtems/score/tqdata.h

    r3b2c473 r05279b84  
    3939 *  queue was in the synchronization window.
    4040 */
    41  
     41
    4242typedef enum {
    4343  THREAD_QUEUE_SYNCHRONIZED,
  • cpukit/score/include/rtems/score/userext.h

    r3b2c473 r05279b84  
    3232 *  the system as a whole.
    3333 */
    34  
     34
    3535typedef void User_extensions_routine;
    36  
     36
    3737typedef boolean ( *User_extensions_thread_create_extension )(
    3838                 Thread_Control *,
    3939                 Thread_Control *
    4040             );
    41  
     41
    4242typedef User_extensions_routine ( *User_extensions_thread_delete_extension )(
    4343                 Thread_Control *,
    4444                 Thread_Control *
    4545             );
    46  
     46
    4747typedef User_extensions_routine ( *User_extensions_thread_start_extension )(
    4848                 Thread_Control *,
    4949                 Thread_Control *
    5050             );
    51  
     51
    5252typedef User_extensions_routine ( *User_extensions_thread_restart_extension )(
    5353                 Thread_Control *,
    5454                 Thread_Control *
    5555             );
    56  
     56
    5757typedef User_extensions_routine ( *User_extensions_thread_switch_extension )(
    5858                 Thread_Control *,
    5959                 Thread_Control *
    6060             );
    61  
     61
    6262typedef User_extensions_routine (
    6363                                *User_extensions_thread_post_switch_extension )(
    6464                 Thread_Control *
    6565             );
    66  
     66
    6767typedef User_extensions_routine ( *User_extensions_thread_begin_extension )(
    6868                 Thread_Control *
    6969             );
    70  
     70
    7171typedef User_extensions_routine ( *User_extensions_thread_exitted_extension )(
    7272                 Thread_Control *
    7373             );
    74  
     74
    7575typedef User_extensions_routine ( *User_extensions_fatal_extension )(
    7676                 Internal_errors_Source  /* the_source  */,
     
    7979             );
    8080
    81  
     81
    8282typedef struct {
    8383  User_extensions_thread_create_extension       thread_create;
  • cpukit/score/include/rtems/score/wkspace.h

    r3b2c473 r05279b84  
    3939 *  This routine performs the initialization necessary for this handler.
    4040 */
    41  
     41
    4242void _Workspace_Handler_initialization(
    4343  void       *starting_address,
  • cpukit/score/include/rtems/seterr.h

    r3b2c473 r05279b84  
    99 *  $Id$
    1010 */
    11  
     11
    1212#ifndef __RTEMS_SET_ERRNO_h
    1313#define __RTEMS_SET_ERRNO_h
    14  
     14
    1515#define rtems_set_errno_and_return_minus_one( _error ) \
    1616  do { errno = (_error); return -1; } while(0)
  • cpukit/score/src/apiext.c

    r3b2c473 r05279b84  
    2121 *  _API_extensions_Initialization
    2222 */
    23  
     23
    2424void _API_extensions_Initialization( void )
    2525{
    2626 _Chain_Initialize_empty( &_API_extensions_List );
    2727}
    28  
     28
    2929/*PAGE
    3030 *
    3131 *  _API_extensions_Add
    3232 */
    33  
     33
    3434void _API_extensions_Add(
    3535  API_extensions_Control *the_extension
     
    4848  Chain_Node             *the_node;
    4949  API_extensions_Control *the_extension;
    50  
     50
    5151  for ( the_node = _API_extensions_List.first ;
    5252        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
    5353        the_node = the_node->next ) {
    54  
     54
    5555    the_extension = (API_extensions_Control *) the_node;
    56  
     56
    5757    if ( the_extension->predriver_hook )
    5858      (*the_extension->predriver_hook)();
     
    6969  Chain_Node             *the_node;
    7070  API_extensions_Control *the_extension;
    71  
     71
    7272  for ( the_node = _API_extensions_List.first ;
    7373        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
    7474        the_node = the_node->next ) {
    75  
     75
    7676    the_extension = (API_extensions_Control *) the_node;
    77  
     77
    7878    if ( the_extension->postdriver_hook )
    7979      (*the_extension->postdriver_hook)();
     
    9090  Chain_Node             *the_node;
    9191  API_extensions_Control *the_extension;
    92  
     92
    9393  for ( the_node = _API_extensions_List.first ;
    9494        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
    9595        the_node = the_node->next ) {
    96  
     96
    9797    the_extension = (API_extensions_Control *) the_node;
    98  
     98
    9999    if ( the_extension->postswitch_hook )
    100100      (*the_extension->postswitch_hook)( _Thread_Executing );
  • cpukit/score/src/coremsg.c

    r3b2c473 r05279b84  
    6363  the_message_queue->maximum_message_size       = maximum_message_size;
    6464  _CORE_message_queue_Set_notify( the_message_queue, NULL, NULL );
    65  
     65
    6666  /*
    6767   * round size up to multiple of a ptr for chain init
    6868   */
    69  
     69
    7070  allocated_message_size = maximum_message_size;
    7171  if (allocated_message_size & (sizeof(uint32_t  ) - 1)) {
     
    7373      allocated_message_size &= ~(sizeof(uint32_t  ) - 1);
    7474  }
    75    
     75
    7676  message_buffering_required = maximum_pending_messages *
    7777       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
    78  
     78
    7979  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
    8080     _Workspace_Allocate( message_buffering_required );
    81  
     81
    8282  if (the_message_queue->message_buffers == 0)
    8383    return FALSE;
    84  
     84
    8585  _Chain_Initialize (
    8686    &the_message_queue->Inactive_messages,
     
    8989    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
    9090  );
    91  
     91
    9292  _Chain_Initialize_empty( &the_message_queue->Pending_messages );
    93  
     93
    9494  _Thread_queue_Initialize(
    9595    &the_message_queue->Wait_queue,
  • cpukit/score/src/coremsgclose.c

    r3b2c473 r05279b84  
    4444 *  Output parameters:  NONE
    4545 */
    46  
     46
    4747void _CORE_message_queue_Close(
    4848  CORE_message_queue_Control *the_message_queue,
     
    6868   *  the flush satisfying any blocked senders as a side-effect.
    6969   */
    70  
     70
    7171  if ( the_message_queue->number_of_pending_messages != 0 )
    7272    (void) _CORE_message_queue_Flush_support( the_message_queue );
  • cpukit/score/src/coremsgflush.c

    r3b2c473 r05279b84  
    4343 *    returns - the number of messages flushed from the queue
    4444 */
    45  
     45
    4646uint32_t   _CORE_message_queue_Flush(
    4747  CORE_message_queue_Control *the_message_queue
  • cpukit/score/src/coremsgflushwait.c

    r3b2c473 r05279b84  
    4343 *    returns - the number of messages flushed from the queue
    4444 */
    45  
     45
    4646void _CORE_message_queue_Flush_waiting_threads(
    4747  CORE_message_queue_Control *the_message_queue
  • cpukit/score/src/coremsgsubmit.c

    r3b2c473 r05279b84  
    7676   *  Is there a thread currently waiting on this message queue?
    7777   */
    78      
     78
    7979  if ( the_message_queue->number_of_pending_messages == 0 ) {
    8080    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
     
    8787      *(uint32_t   *)the_thread->Wait.return_argument_1 = size;
    8888      the_thread->Wait.count = submit_type;
    89    
     89
    9090#if defined(RTEMS_MULTIPROCESSING)
    9191      if ( !_Objects_Is_local_id( the_thread->Object.id ) )
  • cpukit/score/src/coremutexseize.c

    r3b2c473 r05279b84  
    8484  Thread_Control   *executing;
    8585  ISR_Level         level = *level_p;
    86  
     86
    8787  /* disabled when you get here */
    88    
     88
    8989  executing = _Thread_Executing;
    9090  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
  • cpukit/score/src/coremutexsurrender.c

    r3b2c473 r05279b84  
    111111#if defined(RTEMS_MULTIPROCESSING)
    112112    if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
    113      
     113
    114114      the_mutex->holder     = NULL;
    115115      the_mutex->holder_id  = the_thread->Object.id;
  • cpukit/score/src/coresemflush.c

    r3b2c473 r05279b84  
    4141 *  Output parameters:  NONE
    4242 */
    43  
     43
    4444void _CORE_semaphore_Flush(
    4545  CORE_semaphore_Control     *the_semaphore,
     
    4848)
    4949{
    50  
     50
    5151  _Thread_queue_Flush(
    5252    &the_semaphore->Wait_queue,
     
    5454    status
    5555  );
    56  
     56
    5757}
  • cpukit/score/src/heapallocate.c

    r3b2c473 r05279b84  
    5555  excess   = size % the_heap->page_size;
    5656  the_size = size + the_heap->page_size + HEAP_BLOCK_USED_OVERHEAD;
    57  
     57
    5858  if ( excess )
    5959    the_size += the_heap->page_size - excess;
     
    9191    ptr = _Heap_Start_of_user_area( the_block );
    9292  }
    93  
     93
    9494  /*
    9595   * round ptr up to a multiple of page size
    9696   * Have to save the bump amount in the buffer so that free can figure it out
    9797   */
    98  
     98
    9999  offset = the_heap->page_size - (((uint32_t  ) ptr) & (the_heap->page_size - 1));
    100100  ptr = _Addresses_Add_offset( ptr, offset );
  • cpukit/score/src/heapextend.c

    r3b2c473 r05279b84  
    4242  Heap_Block        *the_block;
    4343  uint32_t          *p;
    44  
     44
    4545  /*
    4646   *  The overhead was taken from the original heap memory.
     
    107107  p++;
    108108  _Heap_Free( the_heap, p );
    109  
     109
    110110  return HEAP_EXTEND_SUCCESSFUL;
    111111}
  • cpukit/score/src/heapgetinfo.c

    r3b2c473 r05279b84  
    6868
    6969  while (notdone) {
    70      
     70
    7171      /*
    7272       * Accumulate size
     
    8080        the_info->used_size += _Heap_Block_size(the_block);
    8181      }
    82    
     82
    8383      /*
    8484       * Handle the last block
  • cpukit/score/src/heapsizeofuserarea.c

    r3b2c473 r05279b84  
    4646
    4747  the_block = _Heap_User_block_at( starting_address );
    48  
     48
    4949  if ( !_Heap_Is_block_in( the_heap, the_block ) ||
    5050        _Heap_Is_block_free( the_block ) )
  • cpukit/score/src/heapwalk.c

    r3b2c473 r05279b84  
    8989    if (error && (passes > 10))
    9090        abort();
    91    
     91
    9292    if (do_dump == TRUE) {
    9393      printf("PASS: %d  Block @ 0x%p   Back %d,   Front %d",
  • cpukit/score/src/iterateoverthreads.c

    r3b2c473 r05279b84  
    2525  Thread_Control      *the_thread;
    2626  Objects_Information *information;
    27  
     27
    2828  for ( api_index = 1 ;
    2929        api_index <= OBJECTS_APIS_LAST ;
     
    3535      for ( i=1 ; i <= information->maximum ; i++ ) {
    3636        the_thread = (Thread_Control *)information->local_table[ i ];
    37  
     37
    3838        if ( !the_thread )
    3939          continue;
    40  
     40
    4141        (*routine)(the_thread);
    4242      }
    4343    }
    4444  }
    45  
     45
    4646}
  • cpukit/score/src/mpci.c

    r3b2c473 r05279b84  
    5858   *  Register the MP Process Packet routine.
    5959   */
    60  
     60
    6161  _MPCI_Register_packet_processor(
    6262    MP_PACKET_MPCI_INTERNAL,
     
    104104
    105105  _MPCI_Receive_server_tcb = _Thread_Internal_allocate();
    106  
     106
    107107  _Thread_Initialize(
    108108    &_Thread_Internal_information,
     
    118118    _MPCI_Internal_name
    119119  );
    120  
     120
    121121  _Thread_Start(
    122122    _MPCI_Receive_server_tcb,
     
    148148 *  designated object class.
    149149 */
    150  
     150
    151151void _MPCI_Register_packet_processor(
    152152  MP_packet_Classes      the_class,
    153153  MPCI_Packet_processor  the_packet_processor
    154  
     154
    155155)
    156156{
     
    348348)
    349349{
    350  
     350
    351351  MP_packet_Prefix         *the_packet;
    352352  MPCI_Packet_processor     the_function;
    353353  Thread_Control           *executing;
    354  
     354
    355355  executing = _Thread_Executing;
    356356
    357357  for ( ; ; ) {
    358  
     358
    359359    executing->receive_packet = NULL;
    360360
     
    362362    _CORE_semaphore_Seize( &_MPCI_Semaphore, 0, TRUE, WATCHDOG_NO_TIMEOUT );
    363363    _Thread_Enable_dispatch();
    364  
     364
    365365    for ( ; ; ) {
    366366      the_packet = _MPCI_Receive_packet();
    367  
     367
    368368      if ( !the_packet )
    369369        break;
    370  
     370
    371371      executing->receive_packet = the_packet;
    372  
     372
    373373      if ( !_Mp_packet_Is_valid_packet_class ( the_packet->the_class ) )
    374374        break;
    375  
     375
    376376      the_function = _MPCI_Packet_processors[ the_packet->the_class ];
    377  
     377
    378378      if ( !the_function )
    379379        _Internal_error_Occurred(
     
    382382          INTERNAL_ERROR_BAD_PACKET
    383383        );
    384  
     384
    385385        (*the_function)( the_packet );
    386386    }
     
    395395 *
    396396 */
    397  
     397
    398398void _MPCI_Announce ( void )
    399399{
     
    408408 *
    409409 */
    410  
     410
    411411void _MPCI_Internal_packets_Send_process_packet (
    412412   MPCI_Internal_Remote_operations operation
     
    414414{
    415415  MPCI_Internal_packet *the_packet;
    416  
     416
    417417  switch ( operation ) {
    418  
     418
    419419    case MPCI_PACKETS_SYSTEM_VERIFY:
    420  
     420
    421421      the_packet                    = _MPCI_Internal_packets_Get_packet();
    422422      the_packet->Prefix.the_class  = MP_PACKET_MPCI_INTERNAL;
     
    424424      the_packet->Prefix.to_convert = sizeof ( MPCI_Internal_packet );
    425425      the_packet->operation         = operation;
    426  
     426
    427427      the_packet->maximum_nodes = _Objects_Maximum_nodes;
    428  
     428
    429429      the_packet->maximum_global_objects = _Objects_MP_Maximum_global_objects;
    430  
     430
    431431      _MPCI_Send_process_packet( MPCI_ALL_NODES, &the_packet->Prefix );
    432432      break;
    433433  }
    434434}
    435  
     435
    436436/*PAGE
    437437 *
     
    442442 *
    443443 */
    444  
     444
    445445/*PAGE
    446446 *
     
    451451 *
    452452 */
    453  
     453
    454454/*PAGE
    455455 *
     
    458458 *
    459459 */
    460  
     460
    461461void _MPCI_Internal_packets_Process_packet (
    462462  MP_packet_Prefix  *the_packet_prefix
     
    466466  uint32_t                    maximum_nodes;
    467467  uint32_t                    maximum_global_objects;
    468  
     468
    469469  the_packet = (MPCI_Internal_packet *) the_packet_prefix;
    470  
     470
    471471  switch ( the_packet->operation ) {
    472  
     472
    473473    case MPCI_PACKETS_SYSTEM_VERIFY:
    474  
     474
    475475      maximum_nodes          = the_packet->maximum_nodes;
    476476      maximum_global_objects = the_packet->maximum_global_objects;
    477477      if ( maximum_nodes != _Objects_Maximum_nodes ||
    478478           maximum_global_objects != _Objects_MP_Maximum_global_objects ) {
    479  
     479
    480480        _MPCI_Return_packet( the_packet_prefix );
    481  
     481
    482482        _Internal_error_Occurred(
    483483          INTERNAL_ERROR_CORE,
     
    486486        );
    487487      }
    488  
     488
    489489      _MPCI_Return_packet( the_packet_prefix );
    490  
     490
    491491      break;
    492492  }
    493493}
    494  
     494
    495495/*PAGE
    496496 *
     
    501501 *
    502502 */
    503  
     503
    504504/*PAGE
    505505 *
     
    510510 *
    511511 */
    512  
     512
    513513/*PAGE
    514514 *
     
    516516 *
    517517 */
    518  
     518
    519519MPCI_Internal_packet *_MPCI_Internal_packets_Get_packet ( void )
    520520{
  • cpukit/score/src/objectallocate.c

    r3b2c473 r05279b84  
    4747     *  extend information base.
    4848     */
    49  
     49
    5050    if ( !the_object ) {
    5151      _Objects_Extend_information( information );
    5252      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
    5353    }
    54  
     54
    5555    if ( the_object ) {
    5656      uint32_t   block;
    57    
     57
    5858      block = _Objects_Get_index( the_object->id ) -
    5959              _Objects_Get_index( information->minimum_id );
    6060      block /= information->allocation_size;
    61      
     61
    6262      information->inactive_per_block[ block ]--;
    6363      information->inactive--;
    6464    }
    6565  }
    66  
     66
    6767  return the_object;
    6868}
  • cpukit/score/src/objectallocatebyindex.c

    r3b2c473 r05279b84  
    5555     *    +  etc.
    5656     */
    57    
     57
    5858    the_object = (Objects_Control *) _Addresses_Add_offset(
    5959      information->object_blocks[ 0 ],
     
    6161    );
    6262    _Chain_Extract( &the_object->Node );
    63  
     63
    6464    return the_object;   
    6565  }   
  • cpukit/score/src/objectcomparenameraw.c

    r3b2c473 r05279b84  
    3131 *  XXX
    3232 */
    33  
     33
    3434boolean _Objects_Compare_name_raw(
    3535  void       *name_1,
     
    4343  uint32_t    tmp_length = length / OBJECTS_NAME_ALIGNMENT;
    4444#endif
    45  
     45
    4646  if ( name_1 == name_2 )
    4747    return TRUE;
  • cpukit/score/src/objectcomparenamestring.c

    r3b2c473 r05279b84  
    4141 *   returns  - TRUE on a match
    4242 */
    43  
     43
    4444boolean _Objects_Compare_name_string(
    4545  void       *name_1,
  • cpukit/score/src/objectcopynameraw.c

    r3b2c473 r05279b84  
    3131 *  XXX
    3232 */
    33  
     33
    3434void _Objects_Copy_name_raw(
    3535  void       *source,
     
    4141  uint32_t   *destination_p = (uint32_t   *) destination;
    4242  uint32_t    tmp_length = length / OBJECTS_NAME_ALIGNMENT;
    43  
     43
    4444  while ( tmp_length-- )
    4545    *destination_p++ = *source_p++;
  • cpukit/score/src/objectcopynamestring.c

    r3b2c473 r05279b84  
    3131 *  XXX
    3232 */
    33  
     33
    3434void _Objects_Copy_name_string(
    3535  void       *source,
     
    3939  uint8_t   *source_p = (uint8_t   *) source;
    4040  uint8_t   *destination_p = (uint8_t   *) destination;
    41  
     41
    4242  *destination_p = '\0';
    4343  if ( source_p ) {
  • cpukit/score/src/objectextendinformation.c

    r3b2c473 r05279b84  
    6060  index_base    = minimum_index;
    6161  block         = 0;
    62  
     62
    6363  if ( information->maximum < minimum_index )
    6464    block_count = 0;
    6565  else {
    6666    block_count = information->maximum / information->allocation_size;
    67  
     67
    6868    for ( ; block < block_count; block++ ) {
    6969      if ( information->object_blocks[ block ] == NULL )
     
    8686    uint32_t          maximum;
    8787    void             *old_tables;   
    88    
     88
    8989    /*
    9090     *  Growing the tables means allocating a new area, doing a copy and
     
    110110
    111111    block_count++;
    112    
     112
    113113    maximum = information->maximum + information->allocation_size;
    114114
     
    116116     *  Allocate the tables and break it up.
    117117     */
    118    
     118
    119119    if ( information->auto_extend ) {
    120120      object_blocks = (void**)
     
    141141     *
    142142     */
    143      
     143
    144144    inactive_per_block = (uint32_t   *) _Addresses_Add_offset(
    145145        object_blocks, block_count * sizeof(void*) );
     
    148148    local_table = (Objects_Control **) _Addresses_Add_offset(
    149149        name_table, block_count * sizeof(Objects_Name *) );
    150    
     150
    151151    /*
    152152     *  Take the block count down. Saves all the (block_count - 1)
     
    155155
    156156    block_count--;
    157    
     157
    158158    if ( information->maximum > minimum_index ) {
    159      
     159
    160160      /*
    161161       *  Copy each section of the table over. This has to be performed as
    162162       *  separate parts as size of each block has changed.
    163163       */
    164    
     164
    165165      memcpy( object_blocks,
    166166              information->object_blocks,
     
    185185      }
    186186    }
    187    
     187
    188188    /*
    189189     *  Initialise the new entries in the table.
    190190     */
    191    
     191
    192192    object_blocks[block_count] = NULL;
    193193    inactive_per_block[block_count] = 0;
     
    199199      local_table[ index ] = NULL;
    200200    }
    201    
     201
    202202    _ISR_Disable( level );
    203203
    204204    old_tables = information->object_blocks;
    205    
     205
    206206    information->object_blocks = object_blocks;
    207207    information->inactive_per_block = inactive_per_block;
     
    220220    if ( old_tables )
    221221      _Workspace_Free( old_tables );
    222    
     222
    223223    block_count++;
    224224  }
    225            
     225
    226226  /*
    227227   *  Allocate the name table, and the objects
     
    245245      );
    246246  }
    247  
     247
    248248  name_area = (Objects_Name *) _Addresses_Add_offset(
    249249    information->object_blocks[ block ],
     
    268268
    269269  index = index_base;
    270  
     270
    271271  while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
    272    
     272
    273273    the_object->id = _Objects_Build_id(
    274274        information->the_api,
     
    277277        index
    278278      );
    279      
     279
    280280    the_object->name = (void *) name_area;
    281281
     
    286286    index++;
    287287  }
    288  
     288
    289289  information->inactive_per_block[ block ] = information->allocation_size;
    290290  information->inactive += information->allocation_size;
  • cpukit/score/src/objectfree.c

    r3b2c473 r05279b84  
    4646  if ( information->auto_extend ) {
    4747    uint32_t    block;
    48    
     48
    4949    block =
    5050      _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id );
    5151    block /= information->allocation_size;
    52      
     52
    5353    information->inactive_per_block[ block ]++;
    5454    information->inactive++;
    55  
     55
    5656    /*
    5757     *  Check if the threshold level has been met of
  • cpukit/score/src/objectgetnext.c

    r3b2c473 r05279b84  
    6161    Objects_Control *object;
    6262    Objects_Id       next_id;
    63    
     63
    6464    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
    6565        next_id = information->minimum_id;
     
    7474            goto final;
    7575        }
    76        
     76
    7777        /* try to grab one */
    7878        object = _Objects_Get(information, next_id, location_p);
  • cpukit/score/src/objectidtoname.c

    r3b2c473 r05279b84  
    4242  Objects_Control     *the_object = (Objects_Control *) 0;
    4343  Objects_Locations    ignored_location;
    44  
     44
    4545  if ( !name )
    4646    return OBJECTS_INVALID_NAME;
     
    4949  if ( the_api && the_api > OBJECTS_APIS_LAST )
    5050    return OBJECTS_INVALID_ID;
    51  
     51
    5252  the_class = _Objects_Get_class( id );
    5353
     
    5555  if ( !information )
    5656    return OBJECTS_INVALID_ID;
    57  
     57
    5858  if ( information->is_string )
    5959    return OBJECTS_INVALID_ID;
  • cpukit/score/src/objectinitializeinformation.c

    r3b2c473 r05279b84  
    6969  information->the_class          = the_class;
    7070  information->is_string          = is_string;
    71  
     71
    7272  information->local_table        = 0;
    7373  information->name_table         = 0;
    7474  information->inactive_per_block = 0;
    7575  information->object_blocks      = 0;
    76  
     76
    7777  information->inactive           = 0;
    78  
     78
    7979  /*
    8080   *  Set the entry in the object information table.
     
    8888
    8989  information->size = size;
    90  
     90
    9191  /*
    9292   *  Are we operating in unlimited, or auto-extend mode
     
    9595  information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
    9696  maximum                 &= ~OBJECTS_UNLIMITED_OBJECTS;
    97  
     97
    9898  /*
    9999   *  The allocation unit is the maximum value
     
    131131
    132132  _Chain_Initialize_empty( &information->Inactive );
    133    
     133
    134134  /*
    135135   *  Initialize objects .. if there are any
     
    142142     *  extended.
    143143     */
    144    
     144
    145145    information->maximum = 0;
    146    
     146
    147147    /*
    148148     *  Always have the maximum size available so the current performance
     
    150150     *  number then a performance hit is taken.
    151151     */
    152    
     152
    153153    _Objects_Extend_information( information );
    154    
     154
    155155  }
    156156
  • cpukit/score/src/objectmp.c

    r3b2c473 r05279b84  
    5454 *
    5555 */
    56  
     56
    5757void _Objects_MP_Open (
    5858  Objects_Information *information,
     
    6464  the_global_object->Object.id = the_id;
    6565  the_global_object->name      = the_name;
    66  
     66
    6767  _Chain_Prepend(
    6868    &information->global_table[ _Objects_Get_node( the_id ) ],
  • cpukit/score/src/objectshrinkinformation.c

    r3b2c473 r05279b84  
    5757  index_base = _Objects_Get_index( information->minimum_id );
    5858  block_count = ( information->maximum - index_base ) / information->allocation_size;
    59  
     59
    6060  for ( block = 0; block < block_count; block++ ) {
    6161    if ( information->inactive_per_block[ block ] == information->allocation_size ) {
     
    6565       *       and remove elements.
    6666       */
    67      
     67
    6868      the_object = (Objects_Control *) information->Inactive.first;
    6969
     
    7777        if ((index >= index_base) &&
    7878            (index < (index_base + information->allocation_size))) {
    79          
     79
    8080          /*
    8181           *  Get the next node before the node is extracted
    8282           */
    83          
     83
    8484          extract_me = the_object;
    8585
     
    8888          else
    8989            the_object = NULL;
    90          
     90
    9191          _Chain_Extract( &extract_me->Node );
    9292        }
     
    107107
    108108      information->inactive -= information->allocation_size;
    109      
     109
    110110      return;
    111111    }
    112    
     112
    113113    index_base += information->allocation_size;
    114114  }
  • cpukit/score/src/thread.c

    r3b2c473 r05279b84  
    8888   *  Initialize this class of objects.
    8989   */
    90  
     90
    9191  _Objects_Initialize_information(
    9292    &_Thread_Internal_information,
  • cpukit/score/src/threadchangepriority.c

    r3b2c473 r05279b84  
    6363   *  append not a prepend.
    6464   */
    65  
     65
    6666  /*
    6767   *  Techically, the prepend should conditional on the thread lowering
     
    7676    prepend_it = TRUE;
    7777*/
    78                  
     78
    7979  _Thread_Set_transient( the_thread );
    8080
  • cpukit/score/src/threadclearstate.c

    r3b2c473 r05279b84  
    5757  _ISR_Disable( level );
    5858    current_state = the_thread->current_state;
    59    
     59
    6060    if ( current_state & state ) {
    6161      current_state =
  • cpukit/score/src/threadclose.c

    r3b2c473 r05279b84  
    3636 *  operations on this thread are allowed.
    3737 */
    38  
     38
    3939void _Thread_Close(
    4040  Objects_Information  *information,
     
    4343{
    4444  _User_extensions_Thread_delete( the_thread );
    45  
     45
    4646  _Objects_Close( information, &the_thread->Object );
    47  
     47
    4848  _Thread_Set_state( the_thread, STATES_TRANSIENT );
    49  
     49
    5050  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
    5151    if ( _Watchdog_Is_active( &the_thread->Timer ) )
  • cpukit/score/src/threadcreateidle.c

    r3b2c473 r05279b84  
    4444   *  _Workspace_Initialization.
    4545   */
    46  
     46
    4747  _Thread_Idle = _Thread_Internal_allocate();
    48  
     48
    4949  /*
    5050   *  Initialize the IDLE task.
    5151   */
    52  
     52
    5353#if (CPU_PROVIDES_IDLE_THREAD_BODY == TRUE)
    5454  idle = (void *) _CPU_Thread_Idle_body;
     
    5656  idle = (void *) _Thread_Idle_body;
    5757#endif
    58  
     58
    5959  if ( _CPU_Table.idle_task )
    6060    idle = _CPU_Table.idle_task;
    61  
     61
    6262  idle_task_stack_size =  _CPU_Table.idle_task_stack_size;
    6363  if ( idle_task_stack_size < STACK_MINIMUM_SIZE )
    6464    idle_task_stack_size = STACK_MINIMUM_SIZE;
    65  
     65
    6666  _Thread_Initialize(
    6767    &_Thread_Internal_information,
     
    7777    (Objects_Name) _Thread_Idle_name
    7878  );
    79  
     79
    8080  /*
    8181   *  WARNING!!! This is necessary to "kick" start the system and
    8282   *             MUST be done before _Thread_Start is invoked.
    8383   */
    84  
     84
    8585  _Thread_Heir      =
    8686  _Thread_Executing = _Thread_Idle;
    87  
     87
    8888  _Thread_Start(
    8989    _Thread_Idle,
     
    9393    0
    9494  );
    95  
     95
    9696}
  • cpukit/score/src/threaddispatch.c

    r3b2c473 r05279b84  
    138138    _API_extensions_Run_postswitch();
    139139  }
    140  
     140
    141141}
  • cpukit/score/src/threadget.c

    r3b2c473 r05279b84  
    4848  Objects_Information *information;
    4949  Thread_Control      *tp = (Thread_Control *) 0;
    50  
     50
    5151  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
    5252    _Thread_Disable_dispatch();
     
    5555    goto done;
    5656  }
    57  
     57
    5858  the_api = _Objects_Get_API( id );
    5959  if ( the_api && the_api > OBJECTS_APIS_LAST ) {
     
    6161    goto done;
    6262  }
    63  
     63
    6464  the_class = _Objects_Get_class( id );
    6565  if ( the_class != 1 ) {       /* threads are always first class :) */
     
    6767    goto done;
    6868  }
    69  
     69
    7070  information = _Objects_Information_table[ the_api ][ the_class ];
    71  
     71
    7272  if ( !information ) {
    7373    *location = OBJECTS_ERROR;
    7474    goto done;
    7575  }
    76  
     76
    7777  tp = (Thread_Control *) _Objects_Get( information, id, location );
    78  
     78
    7979done:
    8080  return tp;
  • cpukit/score/src/threadhandler.c

    r3b2c473 r05279b84  
    6969  extern void _main(void);
    7070#endif
    71  
     71
    7272  executing = _Thread_Executing;
    73  
     73
    7474  /*
    7575   * have to put level into a register for those cpu's that use
    7676   * inline asm here
    7777   */
    78  
     78
    7979  level = executing->Start.isr_level;
    8080  _ISR_Set_level(level);
     
    101101   * disabled until all 'begin' extensions complete.
    102102   */
    103  
     103
    104104  _User_extensions_Thread_begin( executing );
    105  
     105
    106106  /*
    107107   *  At this point, the dispatch disable level BETTER be 1.
     
    118118#endif
    119119
    120  
     120
    121121  switch ( executing->Start.prototype ) {
    122122    case THREAD_START_NUMERIC:
  • cpukit/score/src/threadidlebody.c

    r3b2c473 r05279b84  
    4040 *  Output parameters:  NONE
    4141 */
    42  
     42
    4343#if (CPU_PROVIDES_IDLE_THREAD_BODY == FALSE)
    4444Thread _Thread_Idle_body(
  • cpukit/score/src/threadinitialize.c

    r3b2c473 r05279b84  
    7676
    7777    actual_stack_size = _Thread_Stack_Allocate( the_thread, actual_stack_size );
    78  
     78
    7979    if ( !actual_stack_size )
    8080      return FALSE;                     /* stack allocation failed */
     
    9797   *  Allocate the floating point area for this thread
    9898   */
    99  
     99
    100100#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
    101101  if ( is_fp ) {
     
    118118   * Clear the libc reent hook.
    119119   */
    120  
     120
    121121  the_thread->libc_reent = NULL;
    122  
     122
    123123  /*
    124124   *  Allocate the extensions area for this thread
     
    142142  } else
    143143    extensions_area = NULL;
    144  
     144
    145145  the_thread->extensions = (void **) extensions_area;
    146146
     
    186186  the_thread->Start.initial_priority = priority;
    187187  the_thread->ticks_executed         = 0;
    188  
     188
    189189  _Thread_Set_priority( the_thread, priority );
    190190
     
    215215
    216216  return TRUE;
    217    
     217
    218218}
  • cpukit/score/src/threadqenqueuepriority.c

    r3b2c473 r05279b84  
    184184       */
    185185      break;
    186  
     186
    187187    case THREAD_QUEUE_NOTHING_HAPPENED:
    188188      /*
     
    190190       */
    191191      break;
    192  
     192
    193193    case THREAD_QUEUE_TIMEOUT:
    194194      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
    195195      _ISR_Enable( level );
    196196      break;
    197  
     197
    198198    case THREAD_QUEUE_SATISFIED:
    199199      if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
     
    205205      break;
    206206  }
    207  
     207
    208208  /*
    209209   *  Global objects with thread queue's should not be operated on from an
     
    211211   *  correctly.
    212212   */
    213  
     213
    214214  _Thread_Unblock( the_thread );
    215  
     215
    216216#if defined(RTEMS_MULTIPROCESSING)
    217217  if ( !_Objects_Is_local_id( the_thread->Object.id ) )
  • cpukit/score/src/threadqextractfifo.c

    r3b2c473 r05279b84  
    6969    _Thread_MP_Free_proxy( the_thread );
    7070#endif
    71  
     71
    7272}
  • cpukit/score/src/threadqextractwithproxy.c

    r3b2c473 r05279b84  
    3232 *  XXX
    3333 */
    34  
     34
    3535boolean _Thread_queue_Extract_with_proxy(
    3636  Thread_Control       *the_thread
  • cpukit/score/src/threadreset.c

    r3b2c473 r05279b84  
    3636 *  operations and this division helps support this.
    3737 */
    38  
     38
    3939void _Thread_Reset(
    4040  Thread_Control      *the_thread,
  • cpukit/score/src/threadrestart.c

    r3b2c473 r05279b84  
    3636 *  original starting point.
    3737 */
    38  
     38
    3939boolean _Thread_Restart(
    4040  Thread_Control      *the_thread,
     
    4444{
    4545  if ( !_States_Is_dormant( the_thread->current_state ) ) {
    46  
     46
    4747    _Thread_Set_transient( the_thread );
    4848
    4949    _Thread_Reset( the_thread, pointer_argument, numeric_argument );
    50  
     50
    5151    _Thread_Load_environment( the_thread );
    52  
     52
    5353    _Thread_Ready( the_thread );
    54  
     54
    5555    _User_extensions_Thread_restart( the_thread );
    56  
     56
    5757    if ( _Thread_Is_executing ( the_thread ) )
    5858      _Thread_Restart_self();
    59  
     59
    6060    return TRUE;
    6161  }
    62  
     62
    6363  return FALSE;
    6464}
  • cpukit/score/src/threadresume.c

    r3b2c473 r05279b84  
    5858
    5959  _ISR_Disable( level );
    60  
     60
    6161  if ( force == TRUE )
    6262    the_thread->suspend_count = 0;
  • cpukit/score/src/threadstackallocate.c

    r3b2c473 r05279b84  
    4343{
    4444  void *stack_addr = 0;
    45  
     45
    4646  if ( !_Stack_Is_enough( stack_size ) )
    4747    stack_size = STACK_MINIMUM_SIZE;
    48  
     48
    4949  /*
    5050   * Call ONLY the CPU table stack allocate hook, _or_ the
     
    7272    stack_addr = _Workspace_Allocate( stack_size );
    7373  }
    74  
     74
    7575  if ( !stack_addr )
    7676      stack_size = 0;
    77  
     77
    7878  the_thread->Start.stack = stack_addr;
    79  
     79
    8080  return stack_size;
    8181}
  • cpukit/score/src/threadstart.c

    r3b2c473 r05279b84  
    3636 *  thread competes with all other threads for CPU time.
    3737 */
    38  
     38
    3939boolean _Thread_Start(
    4040  Thread_Control       *the_thread,
     
    4646{
    4747  if ( _States_Is_dormant( the_thread->current_state ) ) {
    48  
     48
    4949    the_thread->Start.entry_point      = (Thread_Entry) entry_point;
    50    
     50
    5151    the_thread->Start.prototype        = the_prototype;
    5252    the_thread->Start.pointer_argument = pointer_argument;
    5353    the_thread->Start.numeric_argument = numeric_argument;
    54  
     54
    5555    _Thread_Load_environment( the_thread );
    56  
     56
    5757    _Thread_Ready( the_thread );
    58  
     58
    5959    _User_extensions_Thread_start( the_thread );
    60  
     60
    6161    return TRUE;
    6262  }
    63  
     63
    6464  return FALSE;
    65  
     65
    6666}
  • cpukit/score/src/threadstartmultitasking.c

    r3b2c473 r05279b84  
    7575    *       switch in the first thread if it is FP.
    7676    */
    77  
     77
    7878
    7979#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  • cpukit/score/src/userext.c

    r3b2c473 r05279b84  
    2929  User_extensions_Control *the_extension;
    3030  boolean                  status;
    31  
    32   for ( the_node = _User_extensions_List.first ;
    33         !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
    34         the_node = the_node->next ) {
    35  
    36     the_extension = (User_extensions_Control *) the_node;
    37  
     31
     32  for ( the_node = _User_extensions_List.first ;
     33        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
     34        the_node = the_node->next ) {
     35
     36    the_extension = (User_extensions_Control *) the_node;
     37
    3838    if ( the_extension->Callouts.thread_create != NULL ) {
    3939      status = (*the_extension->Callouts.thread_create)(
     
    4545    }
    4646  }
    47  
     47
    4848  return TRUE;
    4949}
     
    5353 *  _User_extensions_Thread_delete
    5454 */
    55  
     55
    5656void _User_extensions_Thread_delete (
    5757  Thread_Control *the_thread
     
    6060  Chain_Node              *the_node;
    6161  User_extensions_Control *the_extension;
    62  
     62
    6363  for ( the_node = _User_extensions_List.last ;
    6464        !_Chain_Is_head( &_User_extensions_List, the_node ) ;
    6565        the_node = the_node->previous ) {
    66  
    67     the_extension = (User_extensions_Control *) the_node;
    68  
     66
     67    the_extension = (User_extensions_Control *) the_node;
     68
    6969    if ( the_extension->Callouts.thread_delete != NULL )
    7070      (*the_extension->Callouts.thread_delete)(
     
    7474  }
    7575}
    76  
     76
    7777/*PAGE
    7878 *
     
    8080 *
    8181 */
    82  
     82
    8383void _User_extensions_Thread_start (
    8484  Thread_Control *the_thread
     
    8787  Chain_Node              *the_node;
    8888  User_extensions_Control *the_extension;
    89  
    90   for ( the_node = _User_extensions_List.first ;
    91         !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
    92         the_node = the_node->next ) {
    93  
    94     the_extension = (User_extensions_Control *) the_node;
    95  
     89
     90  for ( the_node = _User_extensions_List.first ;
     91        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
     92        the_node = the_node->next ) {
     93
     94    the_extension = (User_extensions_Control *) the_node;
     95
    9696    if ( the_extension->Callouts.thread_start != NULL )
    9797      (*the_extension->Callouts.thread_start)(
     
    101101  }
    102102}
    103  
     103
    104104/*PAGE
    105105 *
     
    107107 *
    108108 */
    109  
     109
    110110void _User_extensions_Thread_restart (
    111111  Thread_Control *the_thread
     
    114114  Chain_Node              *the_node;
    115115  User_extensions_Control *the_extension;
    116  
    117   for ( the_node = _User_extensions_List.first ;
    118         !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
    119         the_node = the_node->next ) {
    120  
    121     the_extension = (User_extensions_Control *) the_node;
    122  
     116
     117  for ( the_node = _User_extensions_List.first ;
     118        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
     119        the_node = the_node->next ) {
     120
     121    the_extension = (User_extensions_Control *) the_node;
     122
    123123    if ( the_extension->Callouts.thread_restart != NULL )
    124124      (*the_extension->Callouts.thread_restart)(
     
    128128  }
    129129}
    130  
     130
    131131/*PAGE
    132132 *
     
    134134 *
    135135 */
    136  
     136
    137137void _User_extensions_Thread_begin (
    138138  Thread_Control *executing
     
    141141  Chain_Node              *the_node;
    142142  User_extensions_Control *the_extension;
    143  
    144   for ( the_node = _User_extensions_List.first ;
    145         !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
    146         the_node = the_node->next ) {
    147  
    148     the_extension = (User_extensions_Control *) the_node;
    149  
     143
     144  for ( the_node = _User_extensions_List.first ;
     145        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
     146        the_node = the_node->next ) {
     147
     148    the_extension = (User_extensions_Control *) the_node;
     149
    150150    if ( the_extension->Callouts.thread_begin != NULL )
    151151      (*the_extension->Callouts.thread_begin)( executing );
    152152  }
    153153}
    154  
     154
    155155/*PAGE
    156156 *
    157157 *  _User_extensions_Thread_exitted
    158158 */
    159  
     159
    160160void _User_extensions_Thread_exitted (
    161161  Thread_Control *executing
     
    164164  Chain_Node              *the_node;
    165165  User_extensions_Control *the_extension;
    166  
     166
    167167  for ( the_node = _User_extensions_List.last ;
    168168        !_Chain_Is_head( &_User_extensions_List, the_node ) ;
    169169        the_node = the_node->previous ) {
    170  
    171     the_extension = (User_extensions_Control *) the_node;
    172  
     170
     171    the_extension = (User_extensions_Control *) the_node;
     172
    173173    if ( the_extension->Callouts.thread_exitted != NULL )
    174174      (*the_extension->Callouts.thread_exitted)( executing );
     
    180180 *  _User_extensions_Fatal
    181181 */
    182  
     182
    183183void _User_extensions_Fatal (
    184184  Internal_errors_Source  the_source,
     
    189189  Chain_Node              *the_node;
    190190  User_extensions_Control *the_extension;
    191  
     191
    192192  for ( the_node = _User_extensions_List.last ;
    193193        !_Chain_Is_head( &_User_extensions_List, the_node ) ;
    194194        the_node = the_node->previous ) {
    195  
    196     the_extension = (User_extensions_Control *) the_node;
    197  
     195
     196    the_extension = (User_extensions_Control *) the_node;
     197
    198198    if ( the_extension->Callouts.fatal != NULL )
    199199      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  • cpukit/score/src/watchdoginsert.c

    r3b2c473 r05279b84  
    3434  uint32_t           insert_isr_nest_level;
    3535  Watchdog_Interval  delta_interval;
    36  
     36
    3737
    3838  insert_isr_nest_level   = _ISR_Nest_level;
  • cpukit/score/src/watchdogremove.c

    r3b2c473 r05279b84  
    4040
    4141    case WATCHDOG_BEING_INSERTED: 
    42    
     42
    4343      /*
    4444       *  It is not actually on the chain so just change the state and
  • cpukit/score/src/wkspace.c

    r3b2c473 r05279b84  
    2424 *  _Workspace_Handler_initialization
    2525 */
    26  
     26
    2727void _Workspace_Handler_initialization(
    2828  void       *starting_address,
     
    3333  uint32_t    index;
    3434  uint32_t    memory_available;
    35  
     35
    3636  if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
    3737    _Internal_error_Occurred(
     
    4040      INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
    4141    );
    42  
     42
    4343  if ( _CPU_Table.do_zero_of_workspace ) {
    4444    for( zero_out_array  = (uint32_t   *) starting_address, index = 0 ;
     
    4747      zero_out_array[ index ] = 0;
    4848  }
    49  
     49
    5050  memory_available = _Heap_Initialize(
    5151    &_Workspace_Area,
     
    5454    CPU_HEAP_ALIGNMENT
    5555  );
    56  
     56
    5757  if ( memory_available == 0 )
    5858    _Internal_error_Occurred(
Note: See TracChangeset for help on using the changeset viewer.