Changeset 6abdd89 in rtems


Ignore:
Timestamp:
Jun 14, 2021, 7:57:51 AM (7 weeks ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
master
Children:
98cef40
Parents:
fad01e6c
git-author:
Sebastian Huber <sebastian.huber@…> (06/14/21 07:57:51)
git-committer:
Sebastian Huber <sebastian.huber@…> (06/15/21 08:39:47)
Message:

Use a common phrase for pointer parameters

Mention the type of the pointer in the parameter description. Use the
more general term "object" instead of "variable".

Update #3993.

Location:
cpukit/include/rtems
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • cpukit/include/rtems/io.h

    rfad01e6c r6abdd89  
    195195 * @param driver_table is the device driver address table.
    196196 *
    197  * @param[out] registered_major is the pointer to a device major number
    198  *   variable.  When the directive call is successful, the device major number
    199  *   of the registered device will be stored in this variable.
     197 * @param[out] registered_major is the pointer to an
     198 *   ::rtems_device_major_number object.  When the directive call is
     199 *   successful, the device major number of the registered device will be
     200 *   stored in this object.
    200201 *
    201202 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
  • cpukit/include/rtems/rtems/barrier.h

    rfad01e6c r6abdd89  
    8989 *   release barrier.
    9090 *
    91  * @param id is the pointer to an object identifier variable.  When the
    92  *   directive call is successful, the identifier of the created barrier will
    93  *   be stored in this variable.
     91 * @param id is the pointer to an ::rtems_id object.  When the directive call
     92 *   is successful, the identifier of the created barrier will be stored in
     93 *   this object.
    9494 *
    9595 * This directive creates a barrier which resides on the local node.  The
     
    179179 * @param name is the object name to look up.
    180180 *
    181  * @param[out] id is the pointer to an object identifier variable.  When the
    182  *   directive call is successful, the object identifier of an object with the
    183  *   specified name will be stored in this variable.
     181 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     182 *   call is successful, the object identifier of an object with the specified
     183 *   name will be stored in this object.
    184184 *
    185185 * This directive obtains a barrier identifier associated with the barrier name
     
    319319 * @param id is the barrier identifier.
    320320 *
    321  * @param[out] released is the pointer to an integer variable.  When the
     321 * @param[out] released is the pointer to an uint32_t object.  When the
    322322 *   directive call is successful, the number of released tasks will be stored
    323  *   in this variable.
     323 *   in this object.
    324324 *
    325325 * This directive releases the barrier specified by ``id``.  All tasks waiting
  • cpukit/include/rtems/rtems/clock.h

    rfad01e6c r6abdd89  
    145145 * @brief Gets the time of day associated with the current CLOCK_REALTIME.
    146146 *
    147  * @param time_of_day is the pointer to a RTEMS time of day variable.  When the
     147 * @param time_of_day is the pointer to an rtems_time_of_day object.  When the
    148148 *   directive call is successful, the time of day associated with the
    149149 *   CLOCK_REALTIME at some point during the directive call will be stored in
    150  *   this variable.
     150 *   this object.
    151151 *
    152152 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    178178 *   the current CLOCK_REALTIME.
    179179 *
    180  * @param[out] time_of_day is the pointer to a timeval structure variable.
    181  *   When the directive call is successful, the seconds and microseconds
    182  *   elapsed since the Unix epoch and the CLOCK_REALTIME at some point during
    183  *   the directive call will be stored in this variable.
     180 * @param[out] time_of_day is the pointer to a struct timeval object.  When the
     181 *   directive call is successful, the seconds and microseconds elapsed since
     182 *   the Unix epoch and the CLOCK_REALTIME at some point during the directive
     183 *   call will be stored in this object.
    184184 *
    185185 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    211211 *   CLOCK_REALTIME.
    212212 *
    213  * @param[out] seconds_since_rtems_epoch is the pointer to an interval
    214  *   variable.  When the directive call is successful, the seconds elapsed
    215  *   since the RTEMS epoch and the CLOCK_REALTIME at some point during the
    216  *   directive call will be stored in this variable.
     213 * @param[out] seconds_since_rtems_epoch is the pointer to an ::rtems_interval
     214 *   object.  When the directive call is successful, the seconds elapsed since
     215 *   the RTEMS epoch and the CLOCK_REALTIME at some point during the directive
     216 *   call will be stored in this object.
    217217 *
    218218 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    307307 *   the system initialization using CLOCK_MONOTONIC.
    308308 *
    309  * @param[out] uptime is the pointer to a timeval structure variable.  When the
     309 * @param[out] uptime is the pointer to a struct timeval object.  When the
    310310 *   directive call is successful, the seconds and nanoseconds elapsed since
    311311 *   some time point during the system initialization and some point during the
    312  *   directive call using CLOCK_MONOTONIC will be stored in this variable.
     312 *   directive call using CLOCK_MONOTONIC will be stored in this object.
    313313 *
    314314 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    337337 *   during the system initialization using CLOCK_MONOTONIC.
    338338 *
    339  * @param[out] uptime is the pointer to a timeval structure variable.  The
    340  *   seconds and microseconds elapsed since some time point during the system
     339 * @param[out] uptime is the pointer to a struct timeval object.  The seconds
     340 *   and microseconds elapsed since some time point during the system
    341341 *   initialization and some point during the directive call using
    342  *   CLOCK_MONOTONIC will be stored in this variable.  The pointer shall be
     342 *   CLOCK_MONOTONIC will be stored in this object.  The pointer shall be
    343343 *   valid, otherwise the behaviour is undefined.
    344344 *
  • cpukit/include/rtems/rtems/dpmem.h

    rfad01e6c r6abdd89  
    9090 * @param length is the length in bytes of the memory area.
    9191 *
    92  * @param[out] id is the pointer to an object identifier variable.  When the
    93  *   directive call is successful, the identifier of the created port will be
    94  *   stored in this variable.
     92 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     93 *   call is successful, the identifier of the created port will be stored in
     94 *   this object.
    9595 *
    9696 * This directive creates a port which resides on the local node.  The port has
     
    161161 * @param name is the object name to look up.
    162162 *
    163  * @param[out] id is the pointer to an object identifier variable.  When the
    164  *   directive call is successful, the object identifier of an object with the
    165  *   specified name will be stored in this variable.
     163 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     164 *   call is successful, the object identifier of an object with the specified
     165 *   name will be stored in this object.
    166166 *
    167167 * This directive obtains a port identifier associated with the port name
     
    252252 * @param external is the external address to convert.
    253253 *
    254  * @param[out] internal is the pointer to a pointer variable.  When the
     254 * @param[out] internal is the pointer to a ``void`` pointer object.  When the
    255255 *   directive call is successful, the external address associated with the
    256  *   internal address will be stored in this variable.
     256 *   internal address will be stored in this object.
    257257 *
    258258 * This directive converts a dual-ported memory address from external to
     
    298298 * @param internal is the internal address to convert.
    299299 *
    300  * @param[out] external is the pointer to a pointer variable.  When the
     300 * @param[out] external is the pointer to a ``void`` pointer object.  When the
    301301 *   directive call is successful, the external address associated with the
    302  *   internal address will be stored in this variable.
     302 *   internal address will be stored in this object.
    303303 *
    304304 * This directive converts a dual-ported memory address from internal to
  • cpukit/include/rtems/rtems/intr.h

    rfad01e6c r6abdd89  
    156156 * @param vector is the interrupt vector number.
    157157 *
    158  * @param[out] old_isr_handler is the pointer to an ::rtems_isr_entry variable.
     158 * @param[out] old_isr_handler is the pointer to an ::rtems_isr_entry object.
    159159 *   When the directive call is successful, the previous interrupt service
    160160 *   routine established for this interrupt vector will be stored in this
    161  *   variable.
     161 *   object.
    162162 *
    163163 * This directive establishes an interrupt service routine (ISR) for the
  • cpukit/include/rtems/rtems/message.h

    rfad01e6c r6abdd89  
    152152 * @param attribute_set is the attribute set of the message queue.
    153153 *
    154  * @param[out] id is the pointer to an object identifier variable.  When the
    155  *   directive call is successful, the identifier of the created message queue
    156  *   will be stored in this variable.
     154 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     155 *   call is successful, the identifier of the created message queue will be
     156 *   stored in this object.
    157157 *
    158158 * This directive creates a message queue which resides on the local node.  The
     
    289289 * @param config is the message queue configuration.
    290290 *
    291  * @param[out] id is the pointer to an object identifier variable.  When the
    292  *   directive call is successful, the identifier of the constructed message
    293  *   queue will be stored in this variable.
     291 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     292 *   call is successful, the identifier of the constructed message queue will
     293 *   be stored in this object.
    294294 *
    295295 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    389389 * @param node is the node or node set to search for a matching object.
    390390 *
    391  * @param[out] id is the pointer to an object identifier variable.  When the
    392  *   directive call is successful, the object identifier of an object with the
    393  *   specified name will be stored in this variable.
     391 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     392 *   call is successful, the object identifier of an object with the specified
     393 *   name will be stored in this object.
    394394 *
    395395 * This directive obtains a message queue identifier associated with the
     
    648648 * @param size is the size in bytes of the message buffer to broadcast.
    649649 *
    650  * @param[out] count is the pointer to an uint32_t variable.  When the
    651  *   directive call is successful, the number of unblocked tasks will be stored
    652  *   in this variable.
     650 * @param[out] count is the pointer to an uint32_t object.  When the directive
     651 *   call is successful, the number of unblocked tasks will be stored in this
     652 *   object.
    653653 *
    654654 * This directive causes all tasks that are waiting at the queue specified by
     
    714714 *   specify the size of the buffer.
    715715 *
    716  * @param size is the pointer to a size_t variable.  When the directive call is
    717  *   successful, the size in bytes of the received messages will be stored in
    718  *   this variable.  This parameter cannot be used to specify the size of the
     716 * @param[out] size is the pointer to a size_t object.  When the directive call
     717 *   is successful, the size in bytes of the received messages will be stored
     718 *   in this object.  This parameter cannot be used to specify the size of the
    719719 *   buffer.
    720720 *
     
    820820 * @param id is the queue identifier.
    821821 *
    822  * @param[out] count is the pointer to an uint32_t variable.  When the
    823  *   directive call is successful, the number of pending messages will be
    824  *   stored in this variable.
     822 * @param[out] count is the pointer to an uint32_t object.  When the directive
     823 *   call is successful, the number of pending messages will be stored in this
     824 *   object.
    825825 *
    826826 * This directive returns the number of messages pending on the queue specified
     
    862862 * @param id is the queue identifier.
    863863 *
    864  * @param[out] count is the pointer to an uint32_t variable.  When the
    865  *   directive call is successful, the number of unblocked tasks will be stored
    866  *   in this variable.
     864 * @param[out] count is the pointer to an uint32_t object.  When the directive
     865 *   call is successful, the number of unblocked tasks will be stored in this
     866 *   object.
    867867 *
    868868 * This directive removes all pending messages from the queue specified by
  • cpukit/include/rtems/rtems/object.h

    rfad01e6c r6abdd89  
    305305 * @param id is the object identifier to get the name.
    306306 *
    307  * @param[out] name is the pointer to an object name variable.  When the
     307 * @param[out] name is the pointer to an ::rtems_name object.  When the
    308308 *   directive call is successful, the object name associated with the object
    309  *   identifier will be stored in this variable.
     309 *   identifier will be stored in this object.
    310310 *
    311311 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    731731 *   information.
    732732 *
    733  * @param info is the pointer to an object class information variable.  When
    734  *   the directive call is successful, the object class information of the
    735  *   class of the API will be stored in this variable.
     733 * @param[out] info is the pointer to an rtems_object_api_class_information
     734 *   object.  When the directive call is successful, the object class
     735 *   information of the class of the API will be stored in this object.
    736736 *
    737737 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
  • cpukit/include/rtems/rtems/part.h

    rfad01e6c r6abdd89  
    113113 * @param attribute_set is the attribute set of the partition.
    114114 *
    115  * @param[out] id is the pointer to an object identifier variable.  When the
    116  *   directive call is successful, the identifier of the created partition will
    117  *   be stored in this variable.
     115 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     116 *   call is successful, the identifier of the created partition will be stored
     117 *   in this object.
    118118 *
    119119 * This directive creates a partition of fixed size buffers from a physically
     
    253253 * @param node is the node or node set to search for a matching object.
    254254 *
    255  * @param[out] id is the pointer to an object identifier variable.  When the
    256  *   directive call is successful, the object identifier of an object with the
    257  *   specified name will be stored in this variable.
     255 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     256 *   call is successful, the object identifier of an object with the specified
     257 *   name will be stored in this object.
    258258 *
    259259 * This directive obtains a partition identifier associated with the partition
     
    389389 * @param id is the partition identifier.
    390390 *
    391  * @param[out] buffer is the pointer to a buffer pointer variable.  When the
     391 * @param[out] buffer is the pointer to a ``void`` pointer object.  When the
    392392 *   directive call is successful, the pointer to the allocated buffer will be
    393  *   stored in this variable.
     393 *   stored in this object.
    394394 *
    395395 * This directive allows a buffer to be obtained from the partition specified
  • cpukit/include/rtems/rtems/ratemon.h

    rfad01e6c r6abdd89  
    229229 * @param name is the object name of the period.
    230230 *
    231  * @param[out] id is the pointer to an object identifier variable.  When the
    232  *   directive call is successful, the identifier of the created period will be
    233  *   stored in this variable.
     231 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     232 *   call is successful, the identifier of the created period will be stored in
     233 *   this object.
    234234 *
    235235 * This directive creates a period which resides on the local node.  The period
     
    286286 * @param name is the object name to look up.
    287287 *
    288  * @param[out] id is the pointer to an object identifier variable.  When the
    289  *   directive call is successful, the object identifier of an object with the
    290  *   specified name will be stored in this variable.
     288 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     289 *   call is successful, the object identifier of an object with the specified
     290 *   name will be stored in this object.
    291291 *
    292292 * This directive obtains a period identifier associated with the period name
     
    468468 * @param id is the rate monotonic period identifier.
    469469 *
    470  * @param[out] status is the pointer to a rtems_rate_monotonic_period_status
    471  *   variable.  When the directive call is successful, the detailed period
    472  *   status will be stored in this variable.
     470 * @param[out] status is the pointer to an rtems_rate_monotonic_period_status
     471 *   object.  When the directive call is successful, the detailed period status
     472 *   will be stored in this object.
    473473 *
    474474 * This directive returns the detailed status of the rate monotonic period
     
    529529 * @param id is the rate monotonic period identifier.
    530530 *
    531  * @param[out] status is the pointer to a
    532  *   rtems_rate_monotonic_period_statistics variable.  When the directive call
    533  *   is successful, the period statistics will be stored in this variable.
     531 * @param[out] status is the pointer to an
     532 *   rtems_rate_monotonic_period_statistics object.  When the directive call is
     533 *   successful, the period statistics will be stored in this object.
    534534 *
    535535 * This directive returns the statistics of the rate monotonic period specified
  • cpukit/include/rtems/rtems/region.h

    rfad01e6c r6abdd89  
    8888 * @param segment is the begin address of the segment.
    8989 *
    90  * @param[out] size is the pointer to a uintptr_t variable.  When the directive
     90 * @param[out] size is the pointer to a uintptr_t object.  When the directive
    9191 *   call is successful, the size of the segment in bytes will be stored in
    92  *   this variable.
     92 *   this object.
    9393 *
    9494 * This directive obtains the size in bytes of the segment specified by
     
    149149 * @param attribute_set is the attribute set of the region.
    150150 *
    151  * @param[out] id is the pointer to an object identifier variable.  When the
    152  *   directive call is successful, the identifier of the created region will be
    153  *   stored in this variable.
     151 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     152 *   call is successful, the identifier of the created region will be stored in
     153 *   this object.
    154154 *
    155155 * This directive creates a region which resides on the local node.  The region
     
    243243 * @param name is the object name to look up.
    244244 *
    245  * @param[out] id is the pointer to an object identifier variable.  When the
    246  *   directive call is successful, the object identifier of an object with the
    247  *   specified name will be stored in this variable.
     245 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     246 *   call is successful, the object identifier of an object with the specified
     247 *   name will be stored in this object.
    248248 *
    249249 * This directive obtains a region identifier associated with the region name
     
    401401 *   set.  Use #RTEMS_NO_TIMEOUT to wait potentially forever.
    402402 *
    403  * @param segment is the pointer to a void pointer variable.  When the
     403 * @param[out] segment is the pointer to a ``void`` pointer object.  When the
    404404 *   directive call is successful, the begin address of the allocated segment
    405  *   will be stored in this variable.
     405 *   will be stored in this object.
    406406 *
    407407 * This directive gets a segment from the region specified by ``id``.
     
    559559 * @param size is the requested new size of the segment.
    560560 *
    561  * @param[out] old_size is the pointer to an uintptr_t variable.  When the
     561 * @param[out] old_size is the pointer to an uintptr_t object.  When the
    562562 *   directive call is successful, the old size of the segment will be stored
    563  *   in this variable.
     563 *   in this object.
    564564 *
    565565 * This directive is used to increase or decrease the size of the ``segment``
     
    614614 * @param id is the region identifier.
    615615 *
    616  * @param[out] the_info is the pointer to a Heap_Information_block variable.
     616 * @param[out] the_info is the pointer to a Heap_Information_block object.
    617617 *   When the directive call is successful, the information of the region will
    618  *   be stored in this variable.
     618 *   be stored in this object.
    619619 *
    620620 * This directive is used to obtain information about the used and free memory
     
    669669 * @param id is the region identifier.
    670670 *
    671  * @param[out] the_info is the pointer to a Heap_Information_block variable.
     671 * @param[out] the_info is the pointer to a Heap_Information_block object.
    672672 *   When the directive call is successful, the free information of the region
    673  *   will be stored in this variable.
     673 *   will be stored in this object.
    674674 *
    675675 * This directive is used to obtain information about the free memory in the
  • cpukit/include/rtems/rtems/sem.h

    rfad01e6c r6abdd89  
    9696 *   the attribute set.
    9797 *
    98  * @param[out] id is the pointer to an object identifier variable.  When the
    99  *   directive call is successful, the identifier of the created semaphore will
    100  *   be stored in this variable.
     98 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     99 *   call is successful, the identifier of the created semaphore will be stored
     100 *   in this object.
    101101 *
    102102 * This directive creates a semaphore which resides on the local node.  The
     
    273273 * @param node is the node or node set to search for a matching object.
    274274 *
    275  * @param[out] id is the pointer to an object identifier variable.  When the
    276  *   directive call is successful, the object identifier of an object with the
    277  *   specified name will be stored in this variable.
     275 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     276 *   call is successful, the object identifier of an object with the specified
     277 *   name will be stored in this object.
    278278 *
    279279 * This directive obtains a semaphore identifier associated with the semaphore
     
    738738 *   scheduler.
    739739 *
    740  * @param[out] old_priority is the pointer to a task priority variable.  When
    741  *   the directive call is successful, the old priority of the semaphore
    742  *   corresponding to the specified scheduler will be stored in this variable.
     740 * @param[out] old_priority is the pointer to an ::rtems_task_priority object.
     741 *   When the directive call is successful, the old priority of the semaphore
     742 *   corresponding to the specified scheduler will be stored in this object.
    743743 *
    744744 * This directive sets the priority of the semaphore specified by
  • cpukit/include/rtems/rtems/support.h

    rfad01e6c r6abdd89  
    229229 * @param bytes is the number of bytes to allocated.
    230230 *
    231  * @param[out] pointer is the pointer to a pointer variable.  When the
     231 * @param[out] pointer is the pointer to a ``void`` pointer object.  When the
    232232 *   directive call is successful, the begin address of the allocated memory
    233  *   area will be stored in this variable.
     233 *   area will be stored in this object.
    234234 *
    235235 * @return Returns true, if the allocation was successful, otherwise false.
     
    287287 * @brief Gets information about the RTEMS Workspace.
    288288 *
    289  * @param the_info is the pointer to a heap information variable.  When the
    290  *   directive call is successful, the heap information will be stored in this
    291  *   variable.
     289 * @param[out] the_info is the pointer to a Heap_Information_block object.
     290 *   When the directive call is successful, the heap information will be stored
     291 *   in this object.
    292292 *
    293293 * @return Returns true, if getting the information was successful, otherwise
  • cpukit/include/rtems/rtems/tasks.h

    rfad01e6c r6abdd89  
    450450 * @param name is the scheduler name to look up.
    451451 *
    452  * @param[out] id is the pointer to an object identifier variable.  When the
    453  *   directive call is successful, the identifier of the scheduler will be
    454  *   stored in this variable.
     452 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     453 *   call is successful, the identifier of the scheduler will be stored in this
     454 *   object.
    455455 *
    456456 * This directive obtains a scheduler identifier associated with the scheduler
     
    492492 * @param cpu_index is the processor index to identify the scheduler.
    493493 *
    494  * @param[out] id is the pointer to an object identifier variable.  When the
    495  *   directive call is successful, the identifier of the scheduler will be
    496  *   stored in this variable.
     494 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     495 *   call is successful, the identifier of the scheduler will be stored in this
     496 *   object.
    497497 *
    498498 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    526526 * @brief Identifies a scheduler by the processor set.
    527527 *
    528  * @param cpusetsize is the size of the referenced processor set variable in
    529  *   bytes.  This value shall be positive.
    530  *
    531  * @param cpuset is the pointer to a processor set variable.  The referenced
    532  *   processor set will be used to identify the scheduler.
    533  *
    534  * @param[out] id is the pointer to an object identifier variable.  When the
    535  *   directive call is successful, the identifier of the scheduler will be
    536  *   stored in this variable.
     528 * @param cpusetsize is the size of the processor set referenced by ``cpuset``
     529 *   in bytes.  The size shall be positive.
     530 *
     531 * @param cpuset is the pointer to a cpu_set_t.  The referenced processor set
     532 *   will be used to identify the scheduler.
     533 *
     534 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     535 *   call is successful, the identifier of the scheduler will be stored in this
     536 *   object.
    537537 *
    538538 * The scheduler is selected according to the highest numbered online processor
     
    578578 * @param scheduler_id is the scheduler identifier.
    579579 *
    580  * @param[out] priority is the pointer to a task priority variable.  The
    581  *   maximum priority of the scheduler will be stored in this variable, if the
    582  *   operation is successful.
     580 * @param[out] priority is the pointer to an ::rtems_task_priority object.
     581 *   When the directive the maximum priority of the scheduler will be stored in
     582 *   this object.
    583583 *
    584584 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    615615 * @param priority is the Classic API task priority to map.
    616616 *
    617  * @param[out] posix_priority is the pointer to a POSIX thread priority
    618  *   variable.  When the directive call is successful, the POSIX thread
    619  *   priority value corresponding to the specified Classic API task priority
    620  *   value will be stored in this variable.
     617 * @param[out] posix_priority is the pointer to an ``int`` object.  When the
     618 *   directive call is successful, the POSIX thread priority value
     619 *   corresponding to the specified Classic API task priority value will be
     620 *   stored in this object.
    621621 *
    622622 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    656656 * @param posix_priority is the POSIX thread priority to map.
    657657 *
    658  * @param[out] priority is the pointer to a Classic API task priority variable.
     658 * @param[out] priority is the pointer to an ::rtems_task_priority object.
    659659 *   When the directive call is successful, the Classic API task priority value
    660660 *   corresponding to the specified POSIX thread priority value will be stored
    661  *   in this variable.
     661 *   in this object.
    662662 *
    663663 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    765765 * @param scheduler_id is the scheduler identifier.
    766766 *
    767  * @param cpusetsize is the size of the referenced processor set variable in
    768  *   bytes.
    769  *
    770  * @param[out] cpuset is the pointer to a processor set variable.  When the
    771  *   directive call is successful, the processor set of the scheduler will be
    772  *   stored in this variable.  A set bit in the processor set means that the
    773  *   corresponding processor is owned by the scheduler, otherwise the bit is
    774  *   cleared.
     767 * @param cpusetsize is the size of the processor set referenced by ``cpuset``
     768 *   in bytes.
     769 *
     770 * @param[out] cpuset is the pointer to a cpu_set_t object.  When the directive
     771 *   call is successful, the processor set of the scheduler will be stored in
     772 *   this object.  A set bit in the processor set means that the corresponding
     773 *   processor is owned by the scheduler, otherwise the bit is cleared.
    775774 *
    776775 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    910909 * @param attribute_set is the attribute set of the task.
    911910 *
    912  * @param[out] id is the pointer to an object identifier variable.  When the
    913  *   directive call is successful, the identifier of the created task will be
    914  *   stored in this variable.
     911 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     912 *   call is successful, the identifier of the created task will be stored in
     913 *   this object.
    915914 *
    916915 * This directive creates a task which resides on the local node.  The task has
     
    11461145 * @param config is the task configuration.
    11471146 *
    1148  * @param[out] id is the pointer to an object identifier variable.  When the
    1149  *   directive call is successful, the identifier of the constructed task will
    1150  *   be stored in this variable.
     1147 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     1148 *   call is successful, the identifier of the constructed task will be stored
     1149 *   in this object.
    11511150 *
    11521151 * @retval ::RTEMS_SUCCESSFUL The requested operation was successful.
     
    12601259 * @param node is the node or node set to search for a matching object.
    12611260 *
    1262  * @param[out] id is the pointer to an object identifier variable.  When the
    1263  *   directive call is successful, the object identifier of an object with the
    1264  *   specified name will be stored in this variable.
     1261 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     1262 *   call is successful, the object identifier of an object with the specified
     1263 *   name will be stored in this object.
    12651264 *
    12661265 * This directive obtains a task identifier associated with the task name
     
    17491748 *   get the current priority.
    17501749 *
    1751  * @param[out] old_priority is the pointer to an ::rtems_task_priority
    1752  *   variable.  When the directive call is successful, the current or previous
    1753  *   priority of the task with respect to its home scheduler will be stored in
    1754  *   this variable.
     1750 * @param[out] old_priority is the pointer to an ::rtems_task_priority object.
     1751 *   When the directive call is successful, the current or previous priority of
     1752 *   the task with respect to its home scheduler will be stored in this object.
    17551753 *
    17561754 * This directive manipulates the priority of the task specified by ``id``.
     
    18241822 * @param scheduler_id is the scheduler identifier.
    18251823 *
    1826  * @param[out] priority is the pointer to an ::rtems_task_priority variable.
     1824 * @param[out] priority is the pointer to an ::rtems_task_priority object.
    18271825 *   When the directive call is successful, the current priority of the task
    1828  *   with respect to the specified scheduler will be stored in this variable.
     1826 *   with respect to the specified scheduler will be stored in this object.
    18291827 *
    18301828 * This directive returns the current priority in ``priority`` of the task
     
    18871885 *   mode of the calling task is not changed.
    18881886 *
    1889  * @param previous_mode_set is the pointer to a mode variable.  When the
     1887 * @param previous_mode_set is the pointer to an ::rtems_mode object.  When the
    18901888 *   directive call is successful, the mode of the task before any mode changes
    1891  *   done by the directive call will be stored in this variable.
     1889 *   done by the directive call will be stored in this object.
    18921890 *
    18931891 * This directive queries and optionally manipulates the execution mode of the
     
    20872085 *   to specify the calling task.
    20882086 *
    2089  * @param[out] scheduler_id is the pointer to an ::rtems_id variable.  When the
     2087 * @param[out] scheduler_id is the pointer to an ::rtems_id object.  When the
    20902088 *   directive call is successful, the identifier of the home scheduler of the
    2091  *   task will be stored in this variable.
     2089 *   task will be stored in this object.
    20922090 *
    20932091 * This directive returns the identifier of the home scheduler of the task
     
    22032201 *   specify the calling task.
    22042202 *
    2205  * @param cpusetsize is the size of the referenced processor set variable in
    2206  *   bytes.
    2207  *
    2208  * @param[out] cpuset is the pointer to a processor set variable.  When the
    2209  *   directive call is successful, the processor affinity set of the task will
    2210  *   be stored in this variable.  A set bit in the processor set means that the
     2203 * @param cpusetsize is the size of the processor set referenced by ``cpuset``
     2204 *   in bytes.
     2205 *
     2206 * @param[out] cpuset is the pointer to a cpu_set_t object.  When the directive
     2207 *   call is successful, the processor affinity set of the task will be stored
     2208 *   in this object.  A set bit in the processor set means that the
    22112209 *   corresponding processor is in the processor affinity set of the task,
    22122210 *   otherwise the bit is cleared.
     
    22222220 *   specified by ``id``.
    22232221 *
    2224  * @retval ::RTEMS_INVALID_SIZE The provided processor set was too small for
    2225  *   the processor affinity set of the task.
     2222 * @retval ::RTEMS_INVALID_SIZE The size specified by ``cpusetsize`` of the
     2223 *   processor set was too small for the processor affinity set of the task.
    22262224 *
    22272225 * @retval ::RTEMS_ILLEGAL_ON_REMOTE_OBJECT The task resided on a remote node.
     
    22572255 *   specify the calling task.
    22582256 *
    2259  * @param cpusetsize is the size of the referenced processor set variable in
    2260  *   bytes.
    2261  *
    2262  * @param cpuset is the pointer to a processor set variable.  The processor set
     2257 * @param cpusetsize is the size of the processor set referenced by ``cpuset``
     2258 *   in bytes.
     2259 *
     2260 * @param[out] cpuset is the pointer to a cpu_set_t object.  The processor set
    22632261 *   defines the new processor affinity set of the task.  A set bit in the
    22642262 *   processor set means that the corresponding processor shall be in the
  • cpukit/include/rtems/rtems/timer.h

    rfad01e6c r6abdd89  
    192192 * @param id is the timer identifier.
    193193 *
    194  * @param[out] the_info is the pointer to a timer information variable.  When
    195  *   the directive call is successful, the information about the timer will be
    196  *   stored in this variable.
     194 * @param[out] the_info is the pointer to an rtems_timer_information object.
     195 *   When the directive call is successful, the information about the timer
     196 *   will be stored in this object.
    197197 *
    198198 * This directive returns information about the timer.
     
    268268 * @param name is the object name of the timer.
    269269 *
    270  * @param[out] id is the pointer to an object identifier variable.  When the
    271  *   directive call is successful, the identifier of the created timer will be
    272  *   stored in this variable.
     270 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     271 *   call is successful, the identifier of the created timer will be stored in
     272 *   this object.
    273273 *
    274274 * This directive creates a timer which resides on the local node.  The timer
     
    327327 * @param name is the object name to look up.
    328328 *
    329  * @param[out] id is the pointer to an object identifier variable.  When the
    330  *   directive call is successful, the object identifier of an object with the
    331  *   specified name will be stored in this variable.
     329 * @param[out] id is the pointer to an ::rtems_id object.  When the directive
     330 *   call is successful, the object identifier of an object with the specified
     331 *   name will be stored in this object.
    332332 *
    333333 * This directive obtains a timer identifier associated with the timer name
Note: See TracChangeset for help on using the changeset viewer.