Changeset aae7f1a1 in rtems


Ignore:
Timestamp:
Dec 22, 2008, 5:52:32 AM (10 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, master
Children:
063f66f8
Parents:
52cece8
Message:

Eliminate TRUE/FALSE.

Location:
cpukit/score/src
Files:
49 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/src/apimutex.c

    r52cece8 raae7f1a1  
    2727    maximum_mutexes,             /* maximum objects of this class */
    2828    sizeof( API_Mutex_Control ), /* size of this object's control block */
    29     FALSE,                       /* TRUE if the name is a string */
     29    false,                       /* true if the name is a string */
    3030    0                            /* maximum length of an object name */
    3131#if defined(RTEMS_MULTIPROCESSING)
    3232    ,
    33     TRUE,                        /* TRUE if this is a global object class */
     33    true,                        /* true if this is a global object class */
    3434    NULL                         /* Proxy extraction support callout */
    3535#endif
  • cpukit/score/src/apimutexallocate.c

    r52cece8 raae7f1a1  
    2525  CORE_mutex_Attributes attr =  {
    2626    CORE_MUTEX_NESTING_IS_ERROR,
    27     FALSE,
     27    false,
    2828    CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
    2929    0
  • cpukit/score/src/apimutexlock.c

    r52cece8 raae7f1a1  
    2828    &the_mutex->Mutex,
    2929    the_mutex->Object.id,
    30     TRUE,
     30    true,
    3131    0,
    3232    level
  • cpukit/score/src/corebarrierwait.c

    r52cece8 raae7f1a1  
    3434 *    the_barrier - pointer to barrier control block
    3535 *    id          - id of object to wait on
    36  *    wait        - TRUE if wait is allowed, FALSE otherwise
     36 *    wait        - true if wait is allowed, false otherwise
    3737 *    timeout     - number of ticks to wait (0 means forever)
    3838 *    api_barrier_mp_support - api dependent MP support actions
  • cpukit/score/src/coremsg.c

    r52cece8 raae7f1a1  
    4646 *
    4747 *  Output parameters:
    48  *    TRUE   - if the message queue is initialized
    49  *    FALSE  - if the message queue is NOT initialized
     48 *    true   - if the message queue is initialized
     49 *    false  - if the message queue is NOT initialized
    5050 */
    5151
  • cpukit/score/src/coremsgseize.c

    r52cece8 raae7f1a1  
    3737 *  This kernel routine dequeues a message, copies the message buffer to
    3838 *  a given destination buffer, and frees the message buffer to the
    39  *  inactive message pool.  The thread will be blocked if wait is TRUE,
     39 *  inactive message pool.  The thread will be blocked if wait is true,
    4040 *  otherwise an error will be given to the thread if no messages are available.
    4141 *
     
    4545 *    buffer            - pointer to message buffer to be filled
    4646 *    size_p            - pointer to the size of buffer to be filled
    47  *    wait              - TRUE if wait is allowed, FALSE otherwise
     47 *    wait              - true if wait is allowed, false otherwise
    4848 *    timeout           - time to wait for a message
    4949 *
  • cpukit/score/src/coremutexseize.c

    r52cece8 raae7f1a1  
    6666        the_mutex->holder,
    6767        executing->current_priority,
    68         FALSE
     68        false
    6969      );
    7070    }
  • cpukit/score/src/coremutexsurrender.c

    r52cece8 raae7f1a1  
    122122#ifdef __RTEMS_STRICT_ORDER_MUTEX__
    123123    if(the_mutex->queue.priority_before != holder->current_priority)
    124       _Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE);
     124      _Thread_Change_priority(holder,the_mutex->queue.priority_before,true);
    125125#endif
    126126    if ( holder->resource_count == 0 &&
    127127         holder->real_priority != holder->current_priority ) {
    128       _Thread_Change_priority( holder, holder->real_priority, TRUE );
     128      _Thread_Change_priority( holder, holder->real_priority, true );
    129129    }
    130130  }
     
    175175                the_thread,
    176176                the_mutex->Attributes.priority_ceiling,
    177                 FALSE
     177                false
    178178              );
    179179          }
  • cpukit/score/src/coresemseize.c

    r52cece8 raae7f1a1  
    3838 *    the_semaphore - pointer to semaphore control block
    3939 *    id            - id of object to wait on
    40  *    wait          - TRUE if wait is allowed, FALSE otherwise
     40 *    wait          - true if wait is allowed, false otherwise
    4141 *    timeout       - number of ticks to wait (0 means forever)
    4242 *
  • cpukit/score/src/coretod.c

    r52cece8 raae7f1a1  
    4343
    4444  /* TOD has not been set */
    45   _TOD_Is_set = FALSE;
     45  _TOD_Is_set = false;
    4646  _TOD_Activate();
    4747}
  • cpukit/score/src/coretodset.c

    r52cece8 raae7f1a1  
    5555  /* POSIX format TOD (timespec) */
    5656  _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
    57   _TOD_Is_set = TRUE;
     57  _TOD_Is_set = true;
    5858
    5959  _TOD_Activate();
  • cpukit/score/src/heapfree.c

    r52cece8 raae7f1a1  
    3232 *
    3333 *  Output parameters:
    34  *    TRUE  - if starting_address is valid heap address
    35  *    FALSE - if starting_address is invalid heap address
     34 *    true  - if starting_address is valid heap address
     35 *    false - if starting_address is invalid heap address
    3636 */
    3737
     
    5151       starting_address, (void *)the_heap->start, (void *)the_heap->final ) ) {
    5252    _HAssert(starting_address != NULL);
    53     return( FALSE );
     53    return( false );
    5454  }
    5555
     
    5757
    5858  if ( !_Heap_Is_block_in( the_heap, the_block ) ) {
    59     _HAssert( FALSE );
    60     return( FALSE );
     59    _HAssert( false );
     60    return( false );
    6161  }
    6262
     
    6565
    6666  if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
    67     _HAssert( FALSE );
    68     return( FALSE );
     67    _HAssert( false );
     68    return( false );
    6969  }
    7070
    7171  if ( !_Heap_Is_prev_used( next_block ) ) {
    72     _HAssert( FALSE );
    73     return( FALSE );
     72    _HAssert( false );
     73    return( false );
    7474  }
    7575
     
    8383
    8484    if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {
    85       _HAssert( FALSE );
    86       return( FALSE );
     85      _HAssert( false );
     86      return( false );
    8787    }
    8888
     
    9090       must have been used. */
    9191    if ( !_Heap_Is_prev_used ( prev_block) ) {
    92       _HAssert( FALSE );
    93       return( FALSE );
     92      _HAssert( false );
     93      return( false );
    9494    }
    9595
     
    134134  stats->frees += 1;
    135135
    136   return( TRUE );
     136  return( true );
    137137}
  • cpukit/score/src/heapsizeofuserarea.c

    r52cece8 raae7f1a1  
    2626 *  This kernel routine sets '*size' to the size of the block of memory
    2727 *  which begins at 'starting_address'.
    28  *  It returns TRUE if the 'starting_address' is in the heap, and FALSE
     28 *  It returns true if the 'starting_address' is in the heap, and false
    2929 *  otherwise.
    3030 *
     
    3636 *  Output parameters:
    3737 *    size  - size of area filled in
    38  *    TRUE  - if starting_address is valid heap address
    39  *    FALSE - if starting_address is invalid heap address
     38 *    true  - if starting_address is valid heap address
     39 *    false - if starting_address is invalid heap address
    4040 */
    4141
     
    5252  if ( !_Addresses_Is_in_range(
    5353         starting_address, (void *)the_heap->start, (void *)the_heap->final ) )
    54     return( FALSE );
     54    return( false );
    5555
    5656  _Heap_Start_of_block( the_heap, starting_address, &the_block );
     
    5858  _HAssert(_Heap_Is_block_in( the_heap, the_block ));
    5959  if ( !_Heap_Is_block_in( the_heap, the_block ) )
    60     return( FALSE );
     60    return( false );
    6161
    6262  the_size   = _Heap_Block_size( the_block );
     
    6969    !_Heap_Is_prev_used( next_block )
    7070  )
    71     return( FALSE );
     71    return( false );
    7272
    7373  /* 'starting_address' could be greater than 'the_block' address plus
     
    8383    + HEAP_BLOCK_HEADER_OFFSET;
    8484
    85   return( TRUE );
     85  return( true );
    8686}
    8787
  • cpukit/score/src/heapwalk.c

    r52cece8 raae7f1a1  
    3333 *    the_heap  - pointer to heap header
    3434 *    source    - a numeric indicator of the invoker of this routine
    35  *    do_dump   - when TRUE print the information
     35 *    do_dump   - when true print the information
    3636 *
    3737 *  Output parameters: NONE
     
    5252  int passes = 0;
    5353
    54   do_dump = FALSE;
     54  do_dump = false;
    5555  /*
    5656   * We don't want to allow walking the heap until we have
     
    6161/*
    6262  if ( !_System_state_Is_up( _System_state_Get() ) )
    63     return TRUE;
     63    return true;
    6464*/
    6565
     
    6767    source = the_heap->stats.instance;
    6868
    69   if (do_dump == TRUE)
     69  if (do_dump == true)
    7070    printk("\nPASS: %d start %p final %p first %p last %p begin %p end %p\n",
    7171      source, the_block, end,
     
    165165
    166166  if(do_dump && error)
    167     _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
     167    _Internal_error_Occurred( INTERNAL_ERROR_CORE, true, 0xffff0000 );
    168168
    169169  return error;
  • cpukit/score/src/interr.c

    r52cece8 raae7f1a1  
    6262
    6363  /* will not return from this routine */
    64   while (TRUE);
     64  while (true);
    6565}
  • cpukit/score/src/isr.c

    r52cece8 raae7f1a1  
    3535void _ISR_Handler_initialization( void )
    3636{
    37   _ISR_Signals_to_thread_executing = FALSE;
     37  _ISR_Signals_to_thread_executing = false;
    3838
    3939  _ISR_Nest_level = 0;
     
    5252    _Internal_error_Occurred(
    5353      INTERNAL_ERROR_CORE,
    54       TRUE,
     54      true,
    5555      INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL
    5656    );
  • cpukit/score/src/mpci.c

    r52cece8 raae7f1a1  
    5959    _Internal_error_Occurred(
    6060      INTERNAL_ERROR_CORE,
    61       TRUE,
     61      true,
    6262      INTERNAL_ERROR_NO_MPCI
    6363    );
     
    128128    CPU_ALL_TASKS_ARE_FP,
    129129    PRIORITY_MINIMUM,
    130     FALSE,       /* no preempt */
     130    false,       /* no preempt */
    131131    THREAD_CPU_BUDGET_ALGORITHM_NONE,
    132132    NULL,        /* no budget algorithm callout */
     
    191191    _Internal_error_Occurred(
    192192      INTERNAL_ERROR_CORE,
    193       TRUE,
     193      true,
    194194      INTERNAL_ERROR_OUT_OF_PACKETS
    195195    );
     
    376376
    377377    _Thread_Disable_dispatch();
    378     _CORE_semaphore_Seize( &_MPCI_Semaphore, 0, TRUE, WATCHDOG_NO_TIMEOUT );
     378    _CORE_semaphore_Seize( &_MPCI_Semaphore, 0, true, WATCHDOG_NO_TIMEOUT );
    379379    _Thread_Enable_dispatch();
    380380
     
    395395        _Internal_error_Occurred(
    396396          INTERNAL_ERROR_CORE,
    397           TRUE,
     397          true,
    398398          INTERNAL_ERROR_BAD_PACKET
    399399        );
     
    498498        _Internal_error_Occurred(
    499499          INTERNAL_ERROR_CORE,
    500           TRUE,
     500          true,
    501501          INTERNAL_ERROR_INCONSISTENT_MP_INFORMATION
    502502        );
  • cpukit/score/src/objectinitializeinformation.c

    r52cece8 raae7f1a1  
    3939 *    maximum             - maximum objects of this class
    4040 *    size                - size of this object's control block
    41  *    is_string           - TRUE if names for this object are strings
     41 *    is_string           - true if names for this object are strings
    4242 *    maximum_name_length - maximum length of each object's name
    4343 *    When multiprocessing is configured,
    44  *      supports_global     - TRUE if this is a global object class
     44 *      supports_global     - true if this is a global object class
    4545 *      extract_callout     - pointer to threadq extract callout
    4646 *
     
    9797
    9898  information->auto_extend =
    99         (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
     99        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
    100100  maximum                 &= ~OBJECTS_UNLIMITED_OBJECTS;
    101101
  • cpukit/score/src/objectmp.c

    r52cece8 raae7f1a1  
    4343    _Internal_error_Occurred(
    4444      INTERNAL_ERROR_CORE,
    45       TRUE,
     45      true,
    4646      INTERNAL_ERROR_INVALID_NODE
    4747    );
     
    109109  if ( _Objects_MP_Is_null_global_object( the_global_object ) ) {
    110110
    111     if ( is_fatal_error == FALSE )
    112       return FALSE;
     111    if ( is_fatal_error == false )
     112      return false;
    113113
    114114    _Internal_error_Occurred(
    115115      INTERNAL_ERROR_CORE,
    116       TRUE,
     116      true,
    117117      INTERNAL_ERROR_OUT_OF_GLOBAL_OBJECTS
    118118    );
     
    122122  _Objects_MP_Open( information, the_global_object, the_name, the_id );
    123123
    124   return TRUE;
     124  return true;
    125125}
    126126
     
    159159  _Internal_error_Occurred(
    160160    INTERNAL_ERROR_CORE,
    161     TRUE,
     161    true,
    162162    INTERNAL_ERROR_INVALID_GLOBAL_ID
    163163  );
  • cpukit/score/src/objectnametoid.c

    r52cece8 raae7f1a1  
    6363#endif
    6464
    65   /* ASSERT: information->is_string == FALSE */
     65  /* ASSERT: information->is_string == false */
    6666
    6767  if ( !id )
     
    7171    return OBJECTS_INVALID_NAME;
    7272
    73   search_local_node = FALSE;
     73  search_local_node = false;
    7474
    7575  if ( information->maximum != 0 &&
     
    7878       _Objects_Is_local_node( node )
    7979      ))
    80    search_local_node = TRUE;
     80   search_local_node = true;
    8181
    8282  if ( search_local_node ) {
  • cpukit/score/src/objectnametoidstring.c

    r52cece8 raae7f1a1  
    5959  uint32_t                   name_length;
    6060
    61   /* ASSERT: information->is_string == TRUE */
     61  /* ASSERT: information->is_string == true */
    6262
    6363  if ( !id )
  • cpukit/score/src/objectsetname.c

    r52cece8 raae7f1a1  
    4646    d = _Workspace_Allocate( length );
    4747    if ( !d )
    48       return FALSE;
     48      return false;
    4949
    5050    if ( the_object->name.name_p ) {
     
    6565  }
    6666
    67   return TRUE;
     67  return true;
    6868}
  • cpukit/score/src/thread.c

    r52cece8 raae7f1a1  
    6666    _Internal_error_Occurred(
    6767      INTERNAL_ERROR_CORE,
    68       TRUE,
     68      true,
    6969      INTERNAL_ERROR_BAD_STACK_HOOK
    7070    );
    7171
    72   _Context_Switch_necessary = FALSE;
     72  _Context_Switch_necessary = false;
    7373  _Thread_Executing         = NULL;
    7474  _Thread_Heir              = NULL;
     
    109109    sizeof( Thread_Control ),
    110110                                /* size of this object's control block */
    111     TRUE,                       /* TRUE if names for this object are strings */
     111    true,                       /* true if names for this object are strings */
    112112    8                           /* maximum length of each object's name */
    113113#if defined(RTEMS_MULTIPROCESSING)
    114114    ,
    115     FALSE,                      /* TRUE if this is a global object class */
     115    false,                      /* true if this is a global object class */
    116116    NULL                        /* Proxy extraction support callout */
    117117#endif
  • cpukit/score/src/threadblockingoperationcancel.c

    r52cece8 raae7f1a1  
    4646      _Internal_error_Occurred(
    4747        INTERNAL_ERROR_CORE,
    48         TRUE,
     48        true,
    4949        INTERNAL_ERROR_IMPLEMENTATION_BLOCKING_OPERATION_CANCEL
    5050      );
  • cpukit/score/src/threadchangepriority.c

    r52cece8 raae7f1a1  
    4141 *    the_thread   - pointer to thread control block
    4242 *    new_priority - ultimate priority
    43  *    prepend_it   - TRUE if the thread should be prepended to the chain
     43 *    prepend_it   - true if the thread should be prepended to the chain
    4444 *
    4545 *  Output parameters:  NONE
     
    7171       _Thread_Is_executing( the_thread ) &&
    7272       new_priority >= the_thread->current_priority )
    73     prepend_it = TRUE;
     73    prepend_it = true;
    7474*/
    7575
     
    138138  if ( !_Thread_Is_executing_also_the_heir() &&
    139139       _Thread_Executing->is_preemptible )
    140     _Context_Switch_necessary = TRUE;
     140    _Context_Switch_necessary = true;
    141141  _ISR_Enable( level );
    142142}
  • cpukit/score/src/threadclearstate.c

    r52cece8 raae7f1a1  
    9090          if ( _Thread_Executing->is_preemptible ||
    9191               the_thread->current_priority == 0 )
    92             _Context_Switch_necessary = TRUE;
     92            _Context_Switch_necessary = true;
    9393        }
    9494      }
  • cpukit/score/src/threadcreateidle.c

    r52cece8 raae7f1a1  
    6464    CPU_IDLE_TASK_IS_FP,
    6565    PRIORITY_MAXIMUM,
    66     TRUE,        /* preemptable */
     66    true,        /* preemptable */
    6767    THREAD_CPU_BUDGET_ALGORITHM_NONE,
    6868    NULL,        /* no budget algorithm callout */
  • cpukit/score/src/threaddispatch.c

    r52cece8 raae7f1a1  
    8989  executing   = _Thread_Executing;
    9090  _ISR_Disable( level );
    91   while ( _Context_Switch_necessary == TRUE ) {
     91  while ( _Context_Switch_necessary == true ) {
    9292    heir = _Thread_Heir;
    9393    _Thread_Dispatch_disable_level = 1;
    94     _Context_Switch_necessary = FALSE;
     94    _Context_Switch_necessary = false;
    9595    _Thread_Executing = heir;
    9696#if __RTEMS_ADA__
  • cpukit/score/src/threadevaluatemode.c

    r52cece8 raae7f1a1  
    4646  if ( !_States_Is_ready( executing->current_state ) ||
    4747       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    48     _Context_Switch_necessary = TRUE;
    49     return TRUE;
     48    _Context_Switch_necessary = true;
     49    return true;
    5050  }
    5151
    52   return FALSE;
     52  return false;
    5353}
  • cpukit/score/src/threadhandler.c

    r52cece8 raae7f1a1  
    186186  _Internal_error_Occurred(
    187187    INTERNAL_ERROR_CORE,
    188     TRUE,
     188    true,
    189189    INTERNAL_ERROR_THREAD_EXITTED
    190190  );
  • cpukit/score/src/threadinitialize.c

    r52cece8 raae7f1a1  
    8282
    8383    if ( !actual_stack_size || actual_stack_size < stack_size )
    84       return FALSE;                     /* stack allocation failed */
     84      return false;                     /* stack allocation failed */
    8585
    8686    stack = the_thread->Start.stack;
    87     the_thread->Start.core_allocated_stack = TRUE;
     87    the_thread->Start.core_allocated_stack = true;
    8888  } else {
    8989    stack = stack_area;
    9090    actual_stack_size = stack_size;
    91     the_thread->Start.core_allocated_stack = FALSE;
     91    the_thread->Start.core_allocated_stack = false;
    9292  }
    9393
     
    108108    if ( !fp_area ) {
    109109      _Thread_Stack_Free( the_thread );
    110       return FALSE;
     110      return false;
    111111    }
    112112    fp_area = _Context_Fp_start( fp_area, 0 );
     
    152152      _Thread_Stack_Free( the_thread );
    153153
    154       return FALSE;
     154      return false;
    155155    }
    156156  } else
     
    239239    _Thread_Stack_Free( the_thread );
    240240
    241     return FALSE;
    242   }
    243 
    244   return TRUE;
     241    return false;
     242  }
     243
     244  return true;
    245245
    246246}
  • cpukit/score/src/threadmp.c

    r52cece8 raae7f1a1  
    9393  _Internal_error_Occurred(
    9494    INTERNAL_ERROR_CORE,
    95     TRUE,
     95    true,
    9696    INTERNAL_ERROR_OUT_OF_PROXIES
    9797  );
  • cpukit/score/src/threadqextractpriority.c

    r52cece8 raae7f1a1  
    3636 *    the_thread_queue - pointer to a threadq header
    3737 *    the_thread       - pointer to a thread control block
    38  *    requeuing        - TRUE if requeuing and should not alter timeout or state
     38 *    requeuing        - true if requeuing and should not alter timeout or state
    3939 *
    4040 *  Output parameters: NONE
  • cpukit/score/src/threadqextractwithproxy.c

    r52cece8 raae7f1a1  
    6262    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
    6363
    64     return TRUE;
     64    return true;
    6565  }
    66   return FALSE;
     66  return false;
    6767}
  • cpukit/score/src/threadqrequeue.c

    r52cece8 raae7f1a1  
    6666    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
    6767      _Thread_queue_Enter_critical_section( tq );
    68       _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
     68      _Thread_queue_Extract_priority_helper( tq, the_thread, true );
    6969      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
    7070    }
  • cpukit/score/src/threadready.c

    r52cece8 raae7f1a1  
    7373
    7474  if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible )
    75     _Context_Switch_necessary = TRUE;
     75    _Context_Switch_necessary = true;
    7676
    7777  _ISR_Enable( level );
  • cpukit/score/src/threadresettimeslice.c

    r52cece8 raae7f1a1  
    7070      _Thread_Heir = (Thread_Control *) ready->first;
    7171
    72     _Context_Switch_necessary = TRUE;
     72    _Context_Switch_necessary = true;
    7373
    7474  _ISR_Enable( level );
  • cpukit/score/src/threadrestart.c

    r52cece8 raae7f1a1  
    6262      _Thread_Restart_self();
    6363
    64     return TRUE;
     64    return true;
    6565  }
    6666
    67   return FALSE;
     67  return false;
    6868}
  • cpukit/score/src/threadresume.c

    r52cece8 raae7f1a1  
    6363  _ISR_Disable( level );
    6464
    65   if ( force == TRUE )
     65  if ( force == true )
    6666    the_thread->suspend_count = 0;
    6767  else
     
    9090        if ( _Thread_Executing->is_preemptible ||
    9191             the_thread->current_priority == 0 )
    92           _Context_Switch_necessary = TRUE;
     92          _Context_Switch_necessary = true;
    9393      }
    9494    }
  • cpukit/score/src/threadrotatequeue.c

    r52cece8 raae7f1a1  
    3939 *  and place it immediatly at the rear of this chain.  Reset timeslice
    4040 *  and yield the processor functions both use this routine, therefore if
    41  *  reset is TRUE and this is the only thread on the chain then the
     41 *  reset is true and this is the only thread on the chain then the
    4242 *  timeslice counter is reset.  The heir THREAD will be updated if the
    4343 *  running is also the currently the heir.
     
    8585
    8686  if ( executing != _Thread_Heir )
    87     _Context_Switch_necessary = TRUE;
     87    _Context_Switch_necessary = true;
    8888
    8989  _ISR_Enable( level );
  • cpukit/score/src/threadsetstate.c

    r52cece8 raae7f1a1  
    8282
    8383  if ( _Thread_Is_executing( the_thread ) )
    84     _Context_Switch_necessary = TRUE;
     84    _Context_Switch_necessary = true;
    8585
    8686  _ISR_Enable( level );
  • cpukit/score/src/threadstartmultitasking.c

    r52cece8 raae7f1a1  
    6262  _System_state_Set( SYSTEM_STATE_UP );
    6363
    64   _Context_Switch_necessary = FALSE;
     64  _Context_Switch_necessary = false;
    6565
    6666  _Thread_Executing = _Thread_Heir;
  • cpukit/score/src/threadsuspend.c

    r52cece8 raae7f1a1  
    8181
    8282  if ( _Thread_Is_executing( the_thread ) )
    83     _Context_Switch_necessary = TRUE;
     83    _Context_Switch_necessary = true;
    8484
    8585  _ISR_Enable( level );
  • cpukit/score/src/threadyieldprocessor.c

    r52cece8 raae7f1a1  
    3838 *  and place it immediatly at the rear of this chain.  Reset timeslice
    3939 *  and yield the processor functions both use this routine, therefore if
    40  *  reset is TRUE and this is the only thread on the chain then the
     40 *  reset is true and this is the only thread on the chain then the
    4141 *  timeslice counter is reset.  The heir THREAD will be updated if the
    4242 *  running is also the currently the heir.
     
    6868      if ( _Thread_Is_heir( executing ) )
    6969        _Thread_Heir = (Thread_Control *) ready->first;
    70       _Context_Switch_necessary = TRUE;
     70      _Context_Switch_necessary = true;
    7171    }
    7272    else if ( !_Thread_Is_heir( executing ) )
    73       _Context_Switch_necessary = TRUE;
     73      _Context_Switch_necessary = true;
    7474
    7575  _ISR_Enable( level );
  • cpukit/score/src/timespecgreaterthan.c

    r52cece8 raae7f1a1  
    3030{
    3131  if ( lhs->tv_sec > rhs->tv_sec )
    32     return TRUE;
     32    return true;
    3333
    3434  if ( lhs->tv_sec < rhs->tv_sec )
    35     return FALSE;
     35    return false;
    3636
    3737  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
    3838  if ( lhs->tv_nsec > rhs->tv_nsec )
    39     return TRUE;
     39    return true;
    4040
    41   return FALSE;
     41  return false;
    4242}
  • cpukit/score/src/timespecisvalid.c

    r52cece8 raae7f1a1  
    2929{
    3030  if ( !time )
    31     return FALSE;
     31    return false;
    3232
    3333  if ( time->tv_sec < 0 )
    34     return FALSE;
     34    return false;
    3535
    3636  if ( time->tv_nsec < 0 )
    37     return FALSE;
     37    return false;
    3838
    3939  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
    40     return FALSE;
     40    return false;
    4141
    42   return TRUE;
     42  return true;
    4343}
  • cpukit/score/src/timespeclessthan.c

    r52cece8 raae7f1a1  
    3030{
    3131  if ( lhs->tv_sec < rhs->tv_sec )
    32     return TRUE;
     32    return true;
    3333
    3434  if ( lhs->tv_sec > rhs->tv_sec )
    35     return FALSE;
     35    return false;
    3636
    3737  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
    3838  if ( lhs->tv_nsec < rhs->tv_nsec )
    39     return TRUE;
     39    return true;
    4040
    41   return FALSE;
     41  return false;
    4242}
  • cpukit/score/src/userextthreadcreate.c

    r52cece8 raae7f1a1  
    4242      );
    4343      if ( !status )
    44         return FALSE;
     44        return false;
    4545    }
    4646  }
    4747
    48   return TRUE;
     48  return true;
    4949}
  • cpukit/score/src/wkspace.c

    r52cece8 raae7f1a1  
    3939    _Internal_error_Occurred(
    4040      INTERNAL_ERROR_CORE,
    41       TRUE,
     41      true,
    4242      INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
    4343    );
     
    5656    _Internal_error_Occurred(
    5757      INTERNAL_ERROR_CORE,
    58       TRUE,
     58      true,
    5959      INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
    6060    );
     
    9595    _Internal_error_Occurred(
    9696      INTERNAL_ERROR_CORE,
    97       TRUE,
     97      true,
    9898      INTERNAL_ERROR_WORKSPACE_ALLOCATION
    9999    );
Note: See TracChangeset for help on using the changeset viewer.