VirtualBox

Changeset 57926 in vbox


Ignore:
Timestamp:
Sep 28, 2015 2:05:58 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
102898
Message:

IPRT: Doxygen clenaups (mostly).

Location:
trunk
Files:
41 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/asm-amd64-x86.h

    r57312 r57926  
    262262/**
    263263 * Sets the content of the GDTR CPU register.
    264  * @param   pIdtr   Where to load the GDTR contents from
     264 * @param   pGdtr   Where to load the GDTR contents from
    265265 */
    266266#if RT_INLINE_ASM_EXTERNAL

  • trunk/include/iprt/asm.h

    r57682 r57926  
    133133#endif
    134134
    135 /** @def RT_INLINE_DONT_USE_CMPXCHG8B
     135/** @def RT_INLINE_DONT_MIX_CMPXCHG8B_AND_PIC
    136136 * i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5493) screws up
    137137 * RTSemRWRequestWrite semsemrw-lockless-generic.cpp in release builds. PIC

  • trunk/include/iprt/asn1.h

    r57579 r57926  
    291291 * @param   pThisCore       Pointer to the ASN.1 core of the object to check out.
    292292 * @param   fFlags          See RTASN1_CHECK_SANITY_F_XXX.
    293  * @param   pszErrInfo      Where to return additional error details. Optional.
     293 * @param   pErrInfo        Where to return additional error details. Optional.
    294294 * @param   pszErrorTag     Tag for the additional error details.
    295295 */
    … …  
    772772 * Initializes an interger object to a default value.
    773773 * @returns VINF_SUCCESS.
    774  * @param   pBoolean            The integer object representation.
     774 * @param   pInteger            The integer object representation.
    775775 * @param   uValue              The default value (unsigned 64-bit).
    776776 * @param   pAllocator          The allocator (pro forma).
    … …  
    13501350 * Calls the destructor of the ASN.1 object.
    13511351 *
    1352  * @param   pAsn1Core           The IPRT representation of an ASN.1 object.
     1352 * @param   pThisCore           The IPRT representation of an ASN.1 object.
    13531353 */
    13541354RTDECL(void) RTAsn1VtDelete(PRTASN1CORE pThisCore);
    … …  
    14001400 * @param   pThisCore       Pointer to the ASN.1 core of the object to check out.
    14011401 * @param   fFlags          See RTASN1_CHECK_SANITY_F_XXX.
    1402  * @param   pszErrInfo      Where to return additional error details. Optional.
     1402 * @param   pErrInfo        Where to return additional error details. Optional.
    14031403 * @param   pszErrorTag     Tag for the additional error details.
    14041404 */
    … …  
    15861586 * @returns Pointer to the allocator info (for call in alloc parameter).
    15871587 * @param   pCursor             The cursor.
    1588  * @param   pAllocator          The allocation structure to initialize.
     1588 * @param   pAllocation         The allocation structure to initialize.
    15891589 */
    15901590RTDECL(PRTASN1ALLOCATION) RTAsn1CursorInitAllocation(PRTASN1CURSOR pCursor, PRTASN1ALLOCATION pAllocation);
    … …  
    19251925 * @param   pCursor             The cursor we're decoding from.
    19261926 * @param   fFlags              RTASN1CURSOR_GET_F_XXX.
    1927  * @param   pCtxTagCore         The output context tag object.
     1927 * @param   uExpectedTag        The expected tag.
     1928 * @param   pCtxTag             The output context tag object.
    19281929 * @param   pCtxTagCursor       The output cursor for the context tag content.
    19291930 * @param   pszErrorTag         Error tag, this will be associated with the

  • trunk/include/iprt/assert.h

    r56919 r57926  
    15901590    } while (0)
    15911591
    1592 /** @def AssertLogRelMsgFailedReturn
     1592/** @def AssertLogRelMsgFailedReturnStmt
    15931593 * An assertion failed, execute @a stmt and return @a rc.
    15941594 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
    … …  
    16221622    } while (0)
    16231623
    1624 /** @def AssertLogRelMsgFailedReturnVoid
     1624/** @def AssertLogRelMsgFailedReturnVoidStmt
    16251625 * An assertion failed, execute @a stmt and return void.
    16261626 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
    … …  
    20962096#define AssertRCReturn(rc, rcRet)   AssertMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
    20972097
    2098 /** @def AssertRCReturn
     2098/** @def AssertRCReturnStmt
    20992099 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
    21002100 * @a stmt and returns @a rcRet if it isn't.
    … …  
    21162116#define AssertRCReturnVoid(rc)      AssertMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
    21172117
    2118 /** @def AssertReturnVoidStmt
     2118/** @def AssertRCReturnVoidStmt
    21192119 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
    21202120 * execute the given statement/return if it isn't.

  • trunk/include/iprt/cdefs.h

    r57572 r57926  
    5959# define RT_ARCH_AMD64
    6060# define RT_ARCH_X86
     61# define RT_ARCH_SPARC
     62# define RT_ARCH_SPARC64
    6163# define IN_RING0
    6264# define IN_RING3
    … …  
    7375# define RT_LOCK_STRICT_ORDER
    7476# define RT_LOCK_NO_STRICT_ORDER
    75 # define Breakpoint
     77# define RT_BREAKPOINT
    7678# define RT_NO_DEPRECATED_MACROS
    7779# define RT_EXCEPTIONS_ENABLED
    … …  
    8183# define RT_COMPILER_WITH_80BIT_LONG_DOUBLE
    8284# define RT_NO_VISIBILITY_HIDDEN
     85# define RT_GCC_SUPPORTS_VISIBILITY_HIDDEN
     86# define RT_COMPILER_SUPPORTS_LAMBDA
    8387#endif /* DOXYGEN_RUNNING */
    8488
    … …  
    339343 */
    340344#ifndef RT_OPSYS
    341 # if defined(RT_OS_UNKNOWN)
     345# if defined(RT_OS_UNKNOWN) || defined(DOXYGEN_RUNNING)
    342346#  define RT_OPSYS RT_OPSYS_UNKNOWN
    343347# elif defined(RT_OS_AGNOSTIC)
    … …  
    14261430#define RT_CONCAT_HLP(a,b)          a##b
    14271431
    1428 /** @def RT_CONCAT
     1432/** @def RT_CONCAT3
    14291433 * Concatenate the expanded arguments without any extra spaces in between.
    14301434 *
    … …  
    14371441#define RT_CONCAT3_HLP(a,b,c)       a##b##c
    14381442
    1439 /** @def RT_CONCAT
     1443/** @def RT_CONCAT4
    14401444 * Concatenate the expanded arguments without any extra spaces in between.
    14411445 *

  • trunk/include/iprt/cdrom.h

    r53615 r57926  
    6464 * @param   phCdrom             Where to return the CDROM handle.
    6565 */
    66 RTDECL(int)         RTCdromOpen(const char *psz, uint32_t fFlags, PRTCDROM phCdrom);
     66RTDECL(int)         RTCdromOpen(const char *pszName, uint32_t fFlags, PRTCDROM phCdrom);
    6767
    6868/**
    … …  
    166166 *
    167167 * @returns IPRT status code.
    168  * @param   pszName             The CD-ROM name (path).
     168 * @param   iCdrom              The CD-ROM number.
    169169 * @param   fFlags              Open flags, see RTCDROM_O_XXX.
    170170 * @param   phCdrom             Where to return the CDROM handle .

  • trunk/include/iprt/condvar.h

    r57004 r57926  
    5454 *                              condition variable.
    5555 */
    56 RTDECL(int)  RTConvVarCreate(PRTCONDVAR phCondVar);
     56RTDECL(int)  RTCondVarCreate(PRTCONDVAR phCondVar);
    5757
    5858/**
    … …  
    7272 * @param   ...                 Format string arguments.
    7373 */
    74 RTDECL(int)  RTConvVarCreateEx(PRTCONDVAR phCondVar, uint32_t fFlags, RTLOCKVALCLASS hClass,
     74RTDECL(int)  RTCondVarCreateEx(PRTCONDVAR phCondVar, uint32_t fFlags, RTLOCKVALCLASS hClass,
    7575                               const char *pszNameFmt, ...) RT_IPRT_FORMAT_ATTR(4, 5);
    7676
    77 /** @name RTConvVarCreateEx flags
     77/** @name RTCondVarCreateEx flags
    7878 * @{ */
    7979/** Disables lock validation. */
    … …  
    8888 *                              is quietly ignored (VINF_SUCCESS).
    8989 */
    90 RTDECL(int)  RTConvVarDestroy(RTCONDVAR hCondVar);
     90RTDECL(int)  RTCondVarDestroy(RTCONDVAR hCondVar);
    9191
    9292/**
    … …  
    100100 *
    101101 * @returns iprt status code.
    102  * @param   hConvVar            The condition variable to signal.
    103  */
    104 RTDECL(int)  RTConvVarSignal(RTCONDVAR hCondVar);
     102 * @param   hCondVar            The condition variable to signal.
     103 */
     104RTDECL(int)  RTCondVarSignal(RTCONDVAR hCondVar);
    105105
    106106/**
    … …  
    114114 *
    115115 * @returns iprt status code.
    116  * @param   hConvVar            The condition variable to broadcast.
    117  */
    118 RTDECL(int)  RTConvVarBroadcast(RTCONDVAR hCondVar);
    119 
    120 /**
    121  * Wait for the condition variable to be signaled, resume on interruption.
    122  *
    123  * This function will resume if the wait is interrupted by an async system event
    124  * (like a unix signal) or similar.
    125  *
    126  * @returns iprt status code.
    127  *          Will not return VERR_INTERRUPTED.
    128  * @param   hConvVar            The condition variable to wait on.
     116 * @param   hCondVar            The condition variable to broadcast.
     117 */
     118RTDECL(int)  RTCondVarBroadcast(RTCONDVAR hCondVar);
     119
     120/**
     121 * Wait for the condition variable to be signaled, resume on interruption.
     122 *
     123 * This function will resume if the wait is interrupted by an async system event
     124 * (like a unix signal) or similar.
     125 *
     126 * @returns iprt status code.
     127 *          Will not return VERR_INTERRUPTED.
     128 * @param   hCondVar            The condition variable to wait on.
    129129 * @param   hMtx                The mutex to leave during the wait and which
    130130 *                              will be re-enter before returning.
    … …  
    132132 *                              RT_INDEFINITE_WAIT to wait forever.
    133133 */
    134 RTDECL(int)  RTConvVarMutexWait(RTCONDVAR hCondVar, RTSEMMUTEX hMtx, RTMSINTERVAL cMillies);
    135 
    136 /**
    137  * Wait for the condition variable to be signaled, return on interruption.
    138  *
    139  * This function will not resume the wait if interrupted.
    140  *
    141  * @returns iprt status code.
    142  * @param   hConvVar            The condition variable to wait on.
     134RTDECL(int)  RTCondVarMutexWait(RTCONDVAR hCondVar, RTSEMMUTEX hMtx, RTMSINTERVAL cMillies);
     135
     136/**
     137 * Wait for the condition variable to be signaled, return on interruption.
     138 *
     139 * This function will not resume the wait if interrupted.
     140 *
     141 * @returns iprt status code.
     142 * @param   hCondVar            The condition variable to wait on.
    143143 * @param   hMtx                The mutex to leave during the wait and which
    144144 *                              will be re-enter before returning.
    … …  
    146146 *                              RT_INDEFINITE_WAIT to wait forever.
    147147 */
    148 RTDECL(int)  RTConvVarMutexWaitNoResume(RTCONDVAR hCondVar, RTSEMMUTEX hMtx, RTMSINTERVAL cMillies);
    149 
    150 /**
    151  * Wait for the condition variable to be signaled, resume on interruption.
    152  *
    153  * This function will resume if the wait is interrupted by an async system event
    154  * (like a unix signal) or similar.
    155  *
    156  * @returns iprt status code.
    157  *          Will not return VERR_INTERRUPTED.
    158  * @param   hConvVar            The condition variable to wait on.
     148RTDECL(int)  RTCondVarMutexWaitNoResume(RTCONDVAR hCondVar, RTSEMMUTEX hMtx, RTMSINTERVAL cMillies);
     149
     150/**
     151 * Wait for the condition variable to be signaled, resume on interruption.
     152 *
     153 * This function will resume if the wait is interrupted by an async system event
     154 * (like a unix signal) or similar.
     155 *
     156 * @returns iprt status code.
     157 *          Will not return VERR_INTERRUPTED.
     158 * @param   hCondVar            The condition variable to wait on.
    159159 * @param   hRWSem              The read/write semaphore to write-leave during
    160160 *                              the wait and which will be re-enter in write
    … …  
    163163 *                              RT_INDEFINITE_WAIT to wait forever.
    164164 */
    165 RTDECL(int)  RTConvVarRWWriteWait(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
    166 
    167 /**
    168  * Wait for the condition variable to be signaled, return on interruption.
    169  *
    170  * This function will not resume the wait if interrupted.
    171  *
    172  * @returns iprt status code.
    173  * @param   hConvVar            The condition variable to wait on.
     165RTDECL(int)  RTCondVarRWWriteWait(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
     166
     167/**
     168 * Wait for the condition variable to be signaled, return on interruption.
     169 *
     170 * This function will not resume the wait if interrupted.
     171 *
     172 * @returns iprt status code.
     173 * @param   hCondVar            The condition variable to wait on.
    174174 * @param   hRWSem              The read/write semaphore to write-leave during
    175175 *                              the wait and which will be re-enter in write
    … …  
    178178 *                              RT_INDEFINITE_WAIT to wait forever.
    179179 */
    180 RTDECL(int)  RTConvVarRWWriteWaitNoResume(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
    181 
    182 /**
    183  * Wait for the condition variable to be signaled, resume on interruption.
    184  *
    185  * This function will resume if the wait is interrupted by an async system event
    186  * (like a unix signal) or similar.
    187  *
    188  * @returns iprt status code.
    189  *          Will not return VERR_INTERRUPTED.
    190  * @param   hConvVar            The condition variable to wait on.
     180RTDECL(int)  RTCondVarRWWriteWaitNoResume(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
     181
     182/**
     183 * Wait for the condition variable to be signaled, resume on interruption.
     184 *
     185 * This function will resume if the wait is interrupted by an async system event
     186 * (like a unix signal) or similar.
     187 *
     188 * @returns iprt status code.
     189 *          Will not return VERR_INTERRUPTED.
     190 * @param   hCondVar            The condition variable to wait on.
    191191 * @param   hRWSem              The read/write semaphore to read-leave during
    192192 *                              the wait and which will be re-enter in read mode
    … …  
    195195 *                              RT_INDEFINITE_WAIT to wait forever.
    196196 */
    197 RTDECL(int)  RTConvVarRWReadWait(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
    198 
    199 /**
    200  * Wait for the condition variable to be signaled, return on interruption.
    201  *
    202  * This function will not resume the wait if interrupted.
    203  *
    204  * @returns iprt status code.
    205  * @param   hConvVar            The condition variable to wait on.
     197RTDECL(int)  RTCondVarRWReadWait(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
     198
     199/**
     200 * Wait for the condition variable to be signaled, return on interruption.
     201 *
     202 * This function will not resume the wait if interrupted.
     203 *
     204 * @returns iprt status code.
     205 * @param   hCondVar            The condition variable to wait on.
    206206 * @param   hRWSem              The read/write semaphore to read-leave during
    207207 *                              the wait and which will be re-enter in read mode
    … …  
    210210 *                              RT_INDEFINITE_WAIT to wait forever.
    211211 */
    212 RTDECL(int)  RTConvVarRWReadWaitNoResume(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
    213 
    214 /**
    215  * Wait for the condition variable to be signaled, resume on interruption.
    216  *
    217  * This function will resume if the wait is interrupted by an async system event
    218  * (like a unix signal) or similar.
    219  *
    220  * @returns iprt status code.
    221  *          Will not return VERR_INTERRUPTED.
    222  * @param   hConvVar            The condition variable to wait on.
     212RTDECL(int)  RTCondVarRWReadWaitNoResume(RTCONDVAR hCondVar, RTSEMRW hRWSem, RTMSINTERVAL cMillies);
     213
     214/**
     215 * Wait for the condition variable to be signaled, resume on interruption.
     216 *
     217 * This function will resume if the wait is interrupted by an async system event
     218 * (like a unix signal) or similar.
     219 *
     220 * @returns iprt status code.
     221 *          Will not return VERR_INTERRUPTED.
     222 * @param   hCondVar            The condition variable to wait on.
    223223 * @param   pCritSect           The critical section to leave during the wait
    224224 *                              and which will be re-enter before returning.
    … …  
    226226 *                              RT_INDEFINITE_WAIT to wait forever.
    227227 */
    228 RTDECL(int)  RTConvVarCritSectWait(RTCONDVAR hCondVar, PRTCRITSECT pCritSect, RTMSINTERVAL cMillies);
    229 
    230 /**
    231  * Wait for the condition variable to be signaled, return on interruption.
    232  *
    233  * This function will not resume the wait if interrupted.
    234  *
    235  * @returns iprt status code.
    236  * @param   hConvVar            The condition variable to wait on.
     228RTDECL(int)  RTCondVarCritSectWait(RTCONDVAR hCondVar, PRTCRITSECT pCritSect, RTMSINTERVAL cMillies);
     229
     230/**
     231 * Wait for the condition variable to be signaled, return on interruption.
     232 *
     233 * This function will not resume the wait if interrupted.
     234 *
     235 * @returns iprt status code.
     236 * @param   hCondVar            The condition variable to wait on.
    237237 * @param   pCritSect           The critical section to leave during the wait
    238238 *                              and which will be re-enter before returning.
    … …  
    240240 *                              RT_INDEFINITE_WAIT to wait forever.
    241241 */
    242 RTDECL(int)  RTConvVarCritSectWaitNoResume(RTCONDVAR hCondVar, PRTCRITSECT pCritSect, RTMSINTERVAL cMillies);
     242RTDECL(int)  RTCondVarCritSectWaitNoResume(RTCONDVAR hCondVar, PRTCRITSECT pCritSect, RTMSINTERVAL cMillies);
    243243
    244244/**
    … …  
    246246 *
    247247 * This is only used for validating usage and deadlock detection.  When used
    248  * after calls to RTConvVarAddSignaller, the specified thread will be the only
     248 * after calls to RTCondVarAddSignaller, the specified thread will be the only
    249249 * signalling thread.
    250250 *
    251  * @param   hConvVar            The condition variable.
     251 * @param   hCondVar            The condition variable.
    252252 * @param   hThread             The thread that will signal it.  Pass
    253253 *                              NIL_RTTHREAD to indicate that there is no
    254254 *                              special signalling thread.
    255255 */
    256 RTDECL(void) RTConvVarSetSignaller(RTCONDVAR hCondVar, RTTHREAD hThread);
     256RTDECL(void) RTCondVarSetSignaller(RTCONDVAR hCondVar, RTTHREAD hThread);
    257257
    258258/**
    … …  
    261261 * First call RTCondVarSetSignaller then add further threads with this.
    262262 *
    263  * @param   hConvVar            The condition variable.
     263 * @param   hCondVar            The condition variable.
    264264 * @param   hThread             The thread that will signal it. NIL_RTTHREAD is
    265265 *                              not accepted.
    266266 */
    267 RTDECL(void) RTConvVarAddSignaller(RTCONDVAR hCondVar, RTTHREAD hThread);
     267RTDECL(void) RTCondVarAddSignaller(RTCONDVAR hCondVar, RTTHREAD hThread);
    268268
    269269/**
    … …  
    272272 * Reverts work done by RTCondVarAddSignaller and RTCondVarSetSignaller.
    273273 *
    274  * @param   hConvVar            The condition variable.
     274 * @param   hCondVar            The condition variable.
    275275 * @param   hThread             A previously added thread.
    276276 */
    277 RTDECL(void) RTConvVarRemoveSignaller(RTCONDVAR hCondVar, RTTHREAD hThread);
     277RTDECL(void) RTCondVarRemoveSignaller(RTCONDVAR hCondVar, RTTHREAD hThread);
    278278
    279279/** @} */

  • trunk/include/iprt/coredumper.h

    r56291 r57926  
    7373 * @param   pszOutputDir        The directory to store the cores in.  If NULL
    7474 *                              the current directory will be used.
    75  * @param   pszBaseName         Base file name, no directory.  If NULL the
    76  *                              dumper will generate an appropriate name.
    7775 * @param   fFlags              Setup flags, 0 in NOT a valid flag, it must be
    7876 *                              one or more of RTCOREDUMPER_FLAGS_*.

  • trunk/include/iprt/critsect.h

    r57004 r57926  
    175175 * @param   pCritSect       The critical section.
    176176 * @param   uId             Where we're entering the section.
    177  * @param   pszFile         The source position - file.
    178  * @param   iLine           The source position - line.
    179  * @param   pszFunction     The source position - function.
     177 * @param   SRC_POS         The source position where call is being made from.
     178 *                          Use RT_SRC_POS when possible.  Optional.
    180179 */
    181180RTDECL(int) RTCritSectEnterDebug(PRTCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    205204 * @param   pCritSect       The critical section.
    206205 * @param   uId             Where we're entering the section.
    207  * @param   pszFile         The source position - file.
    208  * @param   iLine           The source position - line.
    209  * @param   pszFunction     The source position - function.
     206 * @param   SRC_POS         The source position where call is being made from.
     207 *                          Use RT_SRC_POS when possible.  Optional.
    210208 */
    211209RTDECL(int) RTCritSectTryEnterDebug(PRTCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    244242 * @param   papCritSects    Array of critical section pointers.
    245243 * @param   uId             Where we're entering the section.
    246  * @param   pszFile         The source position - file.
    247  * @param   iLine           The source position - line.
    248  * @param   pszFunction     The source position - function.
     244 * @param   SRC_POS         The source position where call is being made from.
     245 *                          Use RT_SRC_POS when possible.  Optional.
    249246 *
    250247 * @remark  See RTCritSectEnterMultiple().
    … …  
    525522 * @param   pThis           Pointer to the read/write critical section.
    526523 * @param   uId             Where we're entering the section.
    527  * @param   pszFile         The source position - file.
    528  * @param   iLine           The source position - line.
    529  * @param   pszFunction     The source position - function.
     524 * @param   SRC_POS         The source position where call is being made from.
     525 *                          Use RT_SRC_POS when possible.  Optional.
    530526 */
    531527RTDECL(int) RTCritSectRwEnterSharedDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    557553 * @param   pThis           Pointer to the read/write critical section.
    558554 * @param   uId             Where we're entering the section.
    559  * @param   pszFile         The source position - file.
    560  * @param   iLine           The source position - line.
    561  * @param   pszFunction     The source position - function.
     555 * @param   SRC_POS         The source position where call is being made from.
     556 *                          Use RT_SRC_POS when possible.  Optional.
    562557 */
    563558RTDECL(int) RTCritSectRwTryEnterSharedDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    594589 * @param   pThis           Pointer to the read/write critical section.
    595590 * @param   uId             Where we're entering the section.
    596  * @param   pszFile         The source position - file.
    597  * @param   iLine           The source position - line.
    598  * @param   pszFunction     The source position - function.
     591 * @param   SRC_POS         The source position where call is being made from.
     592 *                          Use RT_SRC_POS when possible.  Optional.
    599593 */
    600594RTDECL(int) RTCritSectRwEnterExclDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    626620 * @param   pThis           Pointer to the read/write critical section.
    627621 * @param   uId             Where we're entering the section.
    628  * @param   pszFile         The source position - file.
    629  * @param   iLine           The source position - line.
    630  * @param   pszFunction     The source position - function.
     622 * @param   SRC_POS         The source position where call is being made from.
     623 *                          Use RT_SRC_POS when possible.  Optional.
    631624 */
    632625RTDECL(int) RTCritSectRwTryEnterExclDebug(PRTCRITSECTRW pThis, RTHCUINTPTR uId, RT_SRC_POS_DECL);

  • trunk/include/iprt/file.h

    r57613 r57926  
    781781 * Opens a new file with a unique name in the temp directory.
    782782 *
    783  * @returns iprt status code.
    784  * @param   pszTemplate     The file name template on input. The actual file
    785  *                          name on success. Empty string on failure.
    786  * @param   fMode           The mode to create the file with.  Use 0600 unless
    787  *                          you have reason not to.
     783 * Unlike the other temp file creation APIs, this does not allow you any control
     784 * over the name.  Nor do you have to figure out where the temporary directory
     785 * is.
     786 *
     787 * @returns iprt status code.
     788 * @param   phFile          Where to return the handle to the file.
     789 * @param   pszFilename     Where to return the name (+path) of the file .
     790 * @param   cbFilename      The size of the buffer @a pszFilename points to.
     791 * @param   fOpen           The RTFILE_O_XXX flags to open the file with.
    788792 *
    789793 * @remarks If actual control over the filename or location is required, we'll
    790794 *          create an extended edition of this API.
    791795 */
    792 RTDECL(int) RTFileOpenTemp(PRTFILE pFile, char *pszFilename, size_t cbFilename, uint64_t fOpen);
     796RTDECL(int) RTFileOpenTemp(PRTFILE phFile, char *pszFilename, size_t cbFilename, uint64_t fOpen);
    793797
    794798
    … …  
    10051009 * @returns iprt status code.
    10061010 * @param   File        Handle to the file.
    1007  * @param   iRequest    IOCTL request to carry out.
     1011 * @param   ulRequest   IOCTL request to carry out.
    10081012 * @param   pvData      IOCTL data.
    10091013 * @param   cbData      Size of the IOCTL data.

  • trunk/include/iprt/getopt.h

    r56291 r57926  
    416416 * @param   papszArgv       Argument vector.  NULL is fine.
    417417 */
    418 RTDECL(void) RTGetOptArgvFree(char **paArgv);
     418RTDECL(void) RTGetOptArgvFree(char **papszArgv);
    419419
    420420/**
    … …  
    430430 * @param   ppszCmdLine     Where to return the command line string.  This must
    431431 *                          be freed by calling RTStrFree.
    432  * @param   papszArgs       The argument vector to convert.
     432 * @param   papszArgv       The argument vector to convert.
    433433 * @param   fFlags          A combination of the RTGETOPTARGV_CNV_XXX flags.
    434434 */

  • trunk/include/iprt/http.h

    r57613 r57926  
    164164 *
    165165 * @param   hHttp           The HTTP client instance.
    166  * @param   pszProxy        URL of the proxy.
     166 * @param   pszProxyUrl     URL of the proxy server.
    167167 * @param   uPort           port number of the proxy, use 0 for not specifying a port.
    168168 * @param   pszProxyUser    Username, pass NULL for no authentication.
    169169 * @param   pszProxyPwd     Password, pass NULL for no authentication.
     170 *
     171 * @todo    This API does not allow specifying the type of proxy server... We're
     172 *          currently assuming it's a HTTP proxy.
    170173 */
    171174RTR3DECL(int) RTHttpSetProxy(RTHTTP hHttp, const char *pszProxyUrl, uint32_t uPort,

  • trunk/include/iprt/initterm.h

    r56291 r57926  
    7777 * @param   fFlags          Flags, see RTR3INIT_XXX.
    7878 */
    79 RTR3DECL(int) RTR3InitExe(int cArgs, char ***papszArgs, uint32_t fFlags);
     79RTR3DECL(int) RTR3InitExe(int cArgs, char ***ppapszArgs, uint32_t fFlags);
    8080
    8181/**
    … …  
    101101 *                          out ourselves.
    102102 */
    103 RTR3DECL(int) RTR3InitEx(uint32_t iVersion, uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath);
     103RTR3DECL(int) RTR3InitEx(uint32_t iVersion, uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath);
    104104
    105105/**

  • trunk/include/iprt/isofs.h

    r56291 r57926  
    194194 * Retrieves the offset + length (both in bytes) of a given file
    195195 * stored in the ISO.
     196 *
    196197 * @note    According to the standard, a file cannot be larger than 2^32-1 bytes.
    197198 *          Therefore using size_t / uint32_t is not a problem.
    … …  
    200201 * @param   pFile       Pointer to open ISO file returned by RTIsoFsOpen().
    201202 * @param   pszPath     Path of file within the ISO to retrieve information for.
    202  * @param   pcbOffset   Pointer to store the file's absolute offset within the ISO.
     203 * @param   poffInIso   Wheter to store the file's absolute offset within the
     204 *                      ISO.
    203205 * @param   pcbLength   Pointer to store the file's size.
    204206 */
    205 RTR3DECL(int) RTIsoFsGetFileInfo(PRTISOFSFILE pFile, const char *pszPath,
    206                                  uint32_t *pcbOffset, size_t *pcbLength);
     207RTR3DECL(int) RTIsoFsGetFileInfo(PRTISOFSFILE pFile, const char *pszPath, uint32_t *poffInIso, size_t *pcbLength);
    207208
    208209/**
    … …  
    211212 * @return  IPRT status code.
    212213 * @param   pFile       Pointer to open ISO file returned by RTIsoFsOpen().
    213  * @param   pszPath     Path of file within the ISO to extract.
    214  * @param   pszDest     Where to store the extracted file.
    215  */
    216 RTR3DECL(int) RTIsoFsExtractFile(PRTISOFSFILE pFile, const char *pszSource,
    217                                  const char *pszDest);
     214 * @param   pszSrcPath  Path of file within the ISO to extract.
     215 * @param   pszDstPath  Where to store the extracted file.
     216 */
     217RTR3DECL(int) RTIsoFsExtractFile(PRTISOFSFILE pFile, const char *pszSrcPath, const char *pszDstPath);
     218
    218219#endif /* IN_RING3 */
    219220

  • trunk/include/iprt/ldr.h

    r56309 r57926  
    690690    /** Watcom debug info. */
    691691    RTLDRDBGINFOTYPE_WATCOM,
    692     /** IBM High Level Language debug info.. */
     692    /** IBM High Level Language debug info. */
    693693    RTLDRDBGINFOTYPE_HLL,
    694694    /** The end of the valid debug info values (exclusive). */
    … …  
    931931 *
    932932 * @param   hLdrMod         The module handle.
     933 * @param   Rva             The segment index.
     934 * @param   offSeg          The segment offset.
     935 * @param   pRva            Where to return the RVA.
     936 */
     937RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva);
     938
     939/**
     940 * Converts a segment:offset into an image relative virtual address (RVA).
     941 *
     942 * @returns IPRT status code.
     943 *
     944 * @param   hLdrMod         The module handle.
    933945 * @param   Rva             The link address to convert.
    934946 * @param   piSeg           Where to return the segment index.
    935947 * @param   poffSeg         Where to return the segment offset.
    936  */
    937 RTDECL(int) RTLdrSegOffsetToRva(RTLDRMOD hLdrMod, uint32_t iSeg, RTLDRADDR offSeg, PRTLDRADDR pRva);
    938 
    939 /**
    940  * Converts a segment:offset into an image relative virtual address (RVA).
    941  *
    942  * @returns IPRT status code.
    943  *
    944  * @param   hLdrMod         The module handle.
    945  * @param   iSeg            The segment index.
    946  * @param   offSeg          The segment offset.
    947  * @param   pRva            Where to return the RVA.
    948948 */
    949949RTDECL(int) RTLdrRvaToSegOffset(RTLDRMOD hLdrMod, RTLDRADDR Rva, uint32_t *piSeg, PRTLDRADDR poffSeg);
    … …  
    10361036 *
    10371037 * @param   hLdrMod         The module handle.
    1038  * @param   enmLdrProp      The property to query.
     1038 * @param   enmProp         The property to query.
    10391039 * @param   pvBuf           Pointer to the input / output buffer.  In most cases
    10401040 *                          it's only used for returning data.
    … …  
    10591059 *
    10601060 * @param   hLdrMod         The module handle.
    1061  * @param   enmLdrProp      The property to query.
     1061 * @param   enmProp         The property to query.
    10621062 * @param   pvBits          Optional pointer to bits returned by
    10631063 *                          RTLdrGetBits().  This can be utilized by some module

  • trunk/include/iprt/list-off32.h

    r55487 r57926  
    233233 *
    234234 * @param   pList               The list.
    235  * @param   pNodeStruct         The node structure to check.  Typically
     235 * @param   pNode               The node structure to check.  Typically
    236236 *                              something obtained from RTListOff32NodeGetNext()
    237237 *                              or RTListOff32NodeGetPrev().  This is NOT a

  • trunk/include/iprt/list.h

    r56291 r57926  
    179179 *
    180180 * @param   pList               The list.
    181  * @param   pNodeStruct         The node structure to check.  Typically
     181 * @param   pNode               The node structure to check.  Typically
    182182 *                              something obtained from RTListNodeGetNext() or
    183183 *                              RTListNodeGetPrev().  This is NOT a PRTLISTNODE

  • trunk/include/iprt/lockvalidator.h

    r57004 r57926  
    694694 *                              pass NIL_RTTHREAD and we'll figure it out.
    695695 * @param   pSrcPos             The source position of the lock operation.
     696 * @param   cMillies            Intended sleep time in milliseconds.
    696697 */
    697698RTDECL(int)  RTLockValidatorRecSharedCheckOrder(PRTLOCKVALRECSHRD pRec, RTTHREAD hThreadSelf,
    … …  
    716717 * @param   pSrcPos             The source position of the lock operation.
    717718 * @param   fRecursiveOk        Whether it's ok to recurse.
     719 * @param   cMillies            Intended sleep time in milliseconds.
    718720 * @param   enmSleepState       The sleep state to enter on successful return.
    719721 * @param   fReallySleeping     Is it really going to sleep now or not.  Use
    … …  
    734736 * @param   pSrcPos             The source position of the lock operation.
    735737 * @param   fRecursiveOk        Whether it's ok to recurse.
     738 * @param   cMillies            Intended sleep time in milliseconds.
    736739 * @param   enmSleepState       The sleep state to enter on successful return.
    737740 * @param   fReallySleeping     Is it really going to sleep now or not.  Use
    … …  
    988991 *                              itself new locking order rules (true), or if the
    989992 *                              user will teach it all it needs to know (false).
    990  * @param   pszFile             The source position of the call, file.
    991  * @param   iLine               The source position of the call, line.
    992  * @param   pszFunction         The source position of the call, function.
     993 * @param   SRC_POS             The source position where call is being made from.
     994 *                              Use RT_SRC_POS when possible.  Optional.
    993995 * @param   pszNameFmt          Class name format string, optional (NULL).  Max
    994996 *                              length is 32 bytes.
    … …  
    10071009 *          first retainer.  NIL_RTLOCKVALCLASS if we run into trouble.
    10081010 *
    1009  * @param   pszFile             The source position of the call, file.
    1010  * @param   iLine               The source position of the call, line.
    1011  * @param   pszFunction         The source position of the call, function.
     1011 * @param   SRC_POS             The source position where call is being made from.
     1012 *                              Use RT_SRC_POS when possible.  Optional.
    10121013 * @param   pszNameFmt          Class name format string, optional (NULL).  Max
    10131014 *                              length is 32 bytes.
    … …  
    10291030 *
    10301031 * @returns Class handle (not retained!) or NIL_RTLOCKVALCLASS.
    1031  * @param   pszFile             The source file.
    1032  * @param   iLine               The line in that source file.
    1033  * @param   pszFunction         The function name.
     1032 * @param   SRC_POS             The source position where call is being made from.
     1033 *                              Use RT_SRC_POS when possible.  Optional.
    10341034 * @param   pszNameFmt          Class name format string, optional (NULL).  Max
    10351035 *                              length is 32 bytes.
    … …  
    10581058/**
    10591059 * Teaches the class @a hClass that locks in the class @a hPriorClass can be
    1060  * held when taking a lock of class @hClass
     1060 * held when taking a lock of class @a hClass
    10611061 *
    10621062 * @returns IPRT status.
    … …  
    10731073 * @returns IPRT status.
    10741074 * @param   hClass              Handle to the class to change.
    1075  * @param   fEnable             Enable it (true) or disable it (false).
     1075 * @param   fEnabled            Enable it (true) or disable it (false).
    10761076 */
    10771077RTDECL(int) RTLockValidatorClassEnforceStrictReleaseOrder(RTLOCKVALCLASS hClass, bool fEnabled);

  • trunk/include/iprt/log.h

    r57814 r57926  
    11041104 * @{ */
    11051105
    1106 /** @def LogWarning1
     1106/** @def Log1Warning
    11071107 * The same as Log(), but prepents a <tt>"WARNING! "</tt> string to the message.
    11081108 *
    … …  
    11151115#endif
    11161116
    1117 /** @def LogWarningFunc
     1117/** @def Log1WarningFunc
    11181118 * The same as LogWarning(), but prepents the log message with the function name.
    11191119 *
    … …  
    11281128#endif
    11291129
    1130 /** @def LogWarningThisFunc
     1130/** @def Log1WarningThisFunc
    11311131 * The same as LogWarningFunc() but for class functions (methods): the resulting
    11321132 * log line is additionally prepended with a hex value of |this| pointer.

  • trunk/include/iprt/manifest.h

    r56291 r57926  
    114114 */
    115115RTDECL(int) RTManifestEqualsEx(RTMANIFEST hManifest1, RTMANIFEST hManifest2, const char * const *papszIgnoreEntries,
    116                                const char * const *papszIgnoreAttr, uint32_t fFlags, char *pszError, size_t cbError);
     116                               const char * const *papszIgnoreAttrs, uint32_t fFlags, char *pszError, size_t cbError);
    117117
    118118/** @defgroup RTMANIFEST_EQUALS_XXX     RTManifestEqualsEx flags
    … …  
    164164
    165165/**
    166  * Query a manifest entry attribute.
     166 * Query a manifest attribute.
    167167 *
    168168 * @returns IPRT status code.
    169169 * @retval  VERR_BUFFER_OVERFLOW if the value buffer is too small. The @a
    170170 *          pszValue buffer will not be modified.
     171 * @retval  VERR_MANIFEST_ATTR_NOT_FOUND
     172 * @retval  VERR_MANIFEST_ATTR_TYPE_NOT_FOUND
     173 * @retval  VERR_MANIFEST_ATTR_TYPE_MISMATCH
     174 *
     175 * @param   hManifest           The manifest handle.
     176 * @param   pszAttr             The attribute name.  If NULL, it will be
     177 *                              selected by @a fType alone.
     178 * @param   fType               The attribute types the entry should match. Pass
     179 *                              Pass RTMANIFEST_ATTR_ANY match any.  If more
     180 *                              than one is given, the first matching one is
     181 *                              returned.
     182 * @param   pszValue            Where to return value.
     183 * @param   cbValue             The size of the buffer @a pszValue points to.
     184 * @param   pfType              Where to return the attribute type value.
     185 */
     186RTDECL(int) RTManifestQueryAttr(RTMANIFEST hManifest, const char *pszAttr, uint32_t fType,
     187                                char *pszValue, size_t cbValue, uint32_t *pfType);
     188
     189/**
     190 * Sets an attribute of a manifest entry.
     191 *
     192 * @returns IPRT status code.
     193 * @param   hManifest           The manifest handle.
     194 * @param   pszEntry            The entry name.  This will automatically be
     195 *                              added if there was no previous call to
     196 *                              RTManifestEntryAdd for this name.  See
     197 *                              RTManifestEntryAdd for the entry name rules.
     198 * @param   pszAttr             The attribute name.  If this already exists,
     199 *                              its value will be replaced.
     200 * @param   pszValue            The value string.
     201 * @param   fType               The attribute type, pass
     202 *                              RTMANIFEST_ATTR_UNKNOWN if not known.
     203 */
     204RTDECL(int) RTManifestEntrySetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr,
     205                                   const char *pszValue, uint32_t fType);
     206
     207/**
     208 * Unsets (removes) an attribute of a manifest entry if they both exist.
     209 *
     210 * @returns IPRT status code.
     211 * @retval  VWRN_NOT_FOUND if not found.
     212 *
     213 * @param   hManifest           The manifest handle.
     214 * @param   pszEntry            The entry name.
     215 * @param   pszAttr             The attribute name.
     216 */
     217RTDECL(int) RTManifestEntryUnsetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr);
     218
     219/**
     220 * Query a manifest entry attribute.
     221 *
     222 * @returns IPRT status code.
     223 * @retval  VERR_BUFFER_OVERFLOW if the value buffer is too small. The @a
     224 *          pszValue buffer will not be modified.
     225 * @retval  VERR_NOT_FOUND if the entry was not found.
    171226 * @retval  VERR_MANIFEST_ATTR_NOT_FOUND
    172227 * @retval  VERR_MANIFEST_ATTR_TYPE_NOT_FOUND
    … …  
    185240 * @param   pfType              Where to return the attribute type value.
    186241 */
    187 RTDECL(int) RTManifestQueryAttr(RTMANIFEST hManifest, const char *pszAttr, uint32_t fType,
    188                                 char *pszValue, size_t cbValue, uint32_t *pfType);
    189 
    190 /**
    191  * Sets an attribute of a manifest entry.
    192  *
    193  * @returns IPRT status code.
    194  * @param   hManifest           The manifest handle.
    195  * @param   pszEntry            The entry name.  This will automatically be
    196  *                              added if there was no previous call to
    197  *                              RTManifestEntryAdd for this name.  See
    198  *                              RTManifestEntryAdd for the entry name rules.
    199  * @param   pszAttr             The attribute name.  If this already exists,
    200  *                              its value will be replaced.
    201  * @param   pszValue            The value string.
    202  * @param   fType               The attribute type, pass
    203  *                              RTMANIFEST_ATTR_UNKNOWN if not known.
    204  */
    205 RTDECL(int) RTManifestEntrySetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr,
    206                                    const char *pszValue, uint32_t fType);
    207 
    208 /**
    209  * Unsets (removes) an attribute of a manifest entry if they both exist.
    210  *
    211  * @returns IPRT status code.
    212  * @retval  VWRN_NOT_FOUND if not found.
    213  *
    214  * @param   hManifest           The manifest handle.
    215  * @param   pszEntry            The entry name.
    216  * @param   pszAttr             The attribute name.
    217  */
    218 RTDECL(int) RTManifestEntryUnsetAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr);
    219 
    220 /**
    221  * Query a manifest entry attribute.
    222  *
    223  * @returns IPRT status code.
    224  * @retval  VERR_BUFFER_OVERFLOW if the value buffer is too small. The @a
    225  *          pszValue buffer will not be modified.
    226  * @retval  VERR_NOT_FOUND if the entry was not found.
    227  * @retval  VERR_MANIFEST_ATTR_NOT_FOUND
    228  * @retval  VERR_MANIFEST_ATTR_TYPE_NOT_FOUND
    229  * @retval  VERR_MANIFEST_ATTR_TYPE_MISMATCH
    230  *
    231  * @param   hManifest           The manifest handle.
    232  * @param   pszEntry            The entry name.
    233  * @param   pszAttr             The attribute name.  If NULL, it will be
    234  *                              selected by @a fType alone.
    235  * @param   fType               The attribute types the entry should match. Pass
    236  *                              Pass RTMANIFEST_ATTR_ANY match any.  If more
    237  *                              than one is given, the first matching one is
    238  *                              returned.
    239  * @param   pszValue            Where to return value.
    240  * @param   cbValue             The size of the buffer @a pszValue points to.
    241  * @param   pfType              Where to return the attribute type value.
    242  */
    243242RTDECL(int) RTManifestEntryQueryAttr(RTMANIFEST hManifest, const char *pszEntry, const char *pszAttr, uint32_t fType,
    244243                                     char *pszValue, size_t cbValue, uint32_t *pfType);
    … …  
    492491 * @param   cbSize               Size of the memory buffer.
    493492 * @param   paTests              Array of file names and digests.
    494  * @param   cTest                Number of entries in paTests.
     493 * @param   cTests               Number of entries in paTests.
    495494 * @param   piFailed             A index to paTests in the
    496495 *                               VERR_MANIFEST_DIGEST_MISMATCH error case

  • trunk/include/iprt/mem.h

    r57432 r57926  
    144144 * @returns NULL on failure, assertion raised in strict builds.
    145145 * @param   cb      Size in bytes of the memory block to allocated.
    146  * @param   pszTag  Allocation tag used for statistics and such.
    147146 */
    148147#define RTMemAlloc(cb)                  RTMemAllocTag((cb), RTMEM_TAG)
    … …  
    299298
    300299
    301 /** @def RTR0MemAllocEx and RTR0MemAllocExTag flags.
     300/** @name RTR0MemAllocEx and RTR0MemAllocExTag flags.
    302301 * @{ */
    303302/** The returned memory should be zeroed. */
    … …  
    369368 * @param   pv                  What to free, NULL is fine.
    370369 * @param   cb                  The amount of allocated memory.
    371  * @param   fFlags              The flags specified when allocating the memory.
    372  *                              Whether the exact flags are requires depends on
    373  *                              the implementation, but in general, ring-0
    374  *                              doesn't require anything while ring-3 requires
    375  *                              RTMEMALLOCEX_FLAGS_EXEC if used.
    376370 */
    377371RTDECL(void) RTMemFreeEx(void *pv, size_t cb) RT_NO_THROW_PROTO;
    … …  
    636630 * @param   cb      Size in bytes of the memory block to allocate.
    637631 * @param   pszTag  Allocation tag used for statistics and such.
     632 * @param   SRC_POS The source position where call is being made from.
     633 *                  Use RT_SRC_POS when possible.  Optional.
    638634 */
    639635RTDECL(void *)  RTMemEfTmpAlloc(size_t cb, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    646642 * @param   cb      Size in bytes of the memory block to allocate.
    647643 * @param   pszTag  Allocation tag used for statistics and such.
     644 * @param   SRC_POS The source position where call is being made from.  Use
     645 *                  RT_SRC_POS when possible.  Optional.
    648646 */
    649647RTDECL(void *)  RTMemEfTmpAllocZ(size_t cb, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    653651 *
    654652 * @param   pv      Pointer to memory block.
     653 * @param   SRC_POS The source position where call is being made from.  Use
     654 *                  RT_SRC_POS when possible.  Optional.
    655655 */
    656656RTDECL(void)    RTMemEfTmpFree(void *pv, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    663663 * @param   cb      Size in bytes of the memory block to allocate.
    664664 * @param   pszTag  Allocation tag used for statistics and such.
     665 * @param   SRC_POS The source position where call is being made from.  Use
     666 *                  RT_SRC_POS when possible.  Optional.
    665667 */
    666668RTDECL(void *)  RTMemEfAlloc(size_t cb, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    673675 * @param   cb      Size in bytes of the memory block to allocate.
    674676 * @param   pszTag  Allocation tag used for statistics and such.
     677 * @param   SRC_POS The source position where call is being made from.  Use
     678 *                  RT_SRC_POS when possible.  Optional.
    675679 */
    676680RTDECL(void *)  RTMemEfAllocZ(size_t cb, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    683687 * @param   cbUnaligned Size in bytes of the memory block to allocate.
    684688 * @param   pszTag  Allocation tag used for statistics and such.
     689 * @param   SRC_POS The source position where call is being made from.  Use
     690 *                  RT_SRC_POS when possible.  Optional.
    685691 */
    686692RTDECL(void *)  RTMemEfAllocVar(size_t cbUnaligned, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    693699 * @param   cbUnaligned Size in bytes of the memory block to allocate.
    694700 * @param   pszTag  Allocation tag used for statistics and such.
     701 * @param   SRC_POS The source position where call is being made from.  Use
     702 *                  RT_SRC_POS when possible.  Optional.
    695703 */
    696704RTDECL(void *)  RTMemEfAllocZVar(size_t cbUnaligned, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    704712 * @param   cbNew   The new block size (in bytes).
    705713 * @param   pszTag  Allocation tag used for statistics and such.
     714 * @param   SRC_POS The source position where call is being made from.  Use
     715 *                  RT_SRC_POS when possible.  Optional.
    706716 */
    707717RTDECL(void *)  RTMemEfRealloc(void *pvOld, size_t cbNew, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    722732 * @param   cb      The amount of memory to duplicate.
    723733 * @param   pszTag  Allocation tag used for statistics and such.
     734 * @param   SRC_POS The source position where call is being made from.  Use
     735 *                  RT_SRC_POS when possible.  Optional.
    724736 */
    725737RTDECL(void *) RTMemEfDup(const void *pvSrc, size_t cb, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    734746 * @param   cbExtra The amount of extra memory to allocate and zero.
    735747 * @param   pszTag  Allocation tag used for statistics and such.
     748 * @param   SRC_POS The source position where call is being made from.  Use
     749 *                  RT_SRC_POS when possible.  Optional.
    736750 */
    737751RTDECL(void *) RTMemEfDupEx(const void *pvSrc, size_t cbSrc, size_t cbExtra, const char *pszTag, RT_SRC_POS_DECL) RT_NO_THROW_PROTO;
    … …  
    920934/**
    921935 * Fenced drop-in replacement for RTMemDupExTag.
    922  * @copydoc RTMemDupExTag
     936 * @copydoc RTMemDupTag
    923937 */
    924938RTDECL(void *) RTMemEfDupNP(const void *pvSrc, size_t cb, const char *pszTag) RT_NO_THROW_PROTO;

  • trunk/include/iprt/memsafer.h

    r57432 r57926  
    163163 * @param   cbNew       The size of the new allocation.
    164164 * @param   ppvNew      Where to return the pointer to the new memory.
    165  * @param   a_fFlags    Flags for controlling the allocation, see
     165 * @param   fFlags      Flags for controlling the allocation, see
    166166 *                      RTMEMSAFER_F_XXX.  It is not permitted to drop saftely
    167167 *                      requirments after the initial allocation.

  • trunk/include/iprt/message.h

    r56919 r57926  
    8484 * @param   ...             Format arguments.
    8585 */
    86 RTDECL(RTEXITCODE) RTMsgErrorExit(RTEXITCODE enmExitcode, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3);
     86RTDECL(RTEXITCODE) RTMsgErrorExit(RTEXITCODE enmExitCode, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3);
    8787
    8888/**
    … …  
    106106 * @param   ...             Format arguments.
    107107 */
    108 RTDECL(int) RTMsgErrorRc(int rc, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3);
     108RTDECL(int) RTMsgErrorRc(int rcRet, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3);
    109109
    110110/**
    … …  
    117117 * @param   va              Format arguments.
    118118 */
    119 RTDECL(int) RTMsgErrorRcV(int rc, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(2, 0);
     119RTDECL(int) RTMsgErrorRcV(int rcRet, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(2, 0);
    120120
    121121/**

  • trunk/include/iprt/net.h

    r56291 r57926  
    4747 *          failure.
    4848 *
    49  * @param   pszValue        The value to convert.
    50  * @param   pAddr           Where to store the result.
     49 * @param   pszAddr         The address string to convert.
     50 * @param   pMacAddr        Where to store the result.
    5151 */
    5252RTDECL(int) RTNetStrToMacAddr(const char *pszAddr, PRTMAC pMacAddr);

  • trunk/include/iprt/path.h

    r57613 r57926  
    807807 *          RTPATHSPLIT::cchPath.
    808808 *
    809  * @param   pParsed             The parser output for @a pszSrcPath.
     809 * @param   pSplit              A split path (see RTPathSplit, RTPathSplitA).
    810810 * @param   fFlags              Combination of RTPATH_STR_F_STYLE_XXX.
    811811 *                              Most users will pass 0.

  • trunk/include/iprt/process.h

    r57916 r57926  
    160160 * @param   pszAsUser   User to run the process as.  Pass NULL to use the same
    161161 *                      user as the current process.
    162  *                      Windows: Use user@domain format to specify a domain.
     162 *                      Windows: Use user\@domain format to specify a domain.
    163163 * @param   pszPassword Password to use to authenticate @a pszAsUser.  Must be
    164164 *                      NULL wif pszAsUser is NULL.  Whether this is actually
    … …  
    341341 *          the process by returning from main().
    342342 *
    343  * @param   papszArgs       The argument vector of the calling process.
    344  * @param   pszDaemonized   The daemonized option.  This is appended to the end
    345  *                          of the parameter list of the daemonized process.
     343 * @param   papszArgs           The argument vector of the calling process.
     344 * @param   pszDaemonizedOpt    The daemonized option.  This is appended to the
     345 *                              end of the parameter list of the daemonized process.
    346346 */
    347347RTR3DECL(int)   RTProcDaemonize(const char * const *papszArgs, const char *pszDaemonizedOpt);

  • trunk/include/iprt/semaphore.h

    r57004 r57926  
    215215 * @param   uId                 Some kind of locking location ID.  Typically a
    216216 *                              return address up the stack.  Optional (0).
    217  * @param   pszFile             The file where the lock is being acquired from.
    218  *                              Optional.
    219  * @param   iLine               The line number in that file.  Optional (0).
    220  * @param   pszFunction         The function where the lock is being acquired
    221  *                              from.  Optional.
     217 * @param   SRC_POS             The source position where call is being made
     218 *                              from.  Use RT_SRC_POS when possible.  Optional.
    222219 */
    223220RTDECL(int)  RTSemEventWaitExDebug(RTSEMEVENT hEventSem, uint32_t fFlags, uint64_t uTimeout,
    … …  
    390387 * @param   uId                 Some kind of locking location ID.  Typically a
    391388 *                              return address up the stack.  Optional (0).
    392  * @param   pszFile             The file where the lock is being acquired from.
    393  *                              Optional.
    394  * @param   iLine               The line number in that file.  Optional (0).
    395  * @param   pszFunction         The function where the lock is being acquired
    396  *                              from.  Optional.
     389 * @param   SRC_POS             The source position where call is being made
     390 *                              from.  Use RT_SRC_POS when possible.  Optional.
    397391 */
    398392RTDECL(int)  RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
    … …  
    468462 *
    469463 * @returns iprt status code.
    470  * @param   phRWSem             Where to store the handle to the newly created
    471  *                              RW semaphore.
     464 * @param   phMutexSem          Where to store the handle to the newly created
     465 *                              mutex semaphore.
    472466 * @param   fFlags              Flags, any combination of the
    473467 *                              RTSEMMUTEX_FLAGS_XXX \#defines.
    … …  
    556550 * @param   uId                 Some kind of locking location ID.  Typically a
    557551 *                              return address up the stack.  Optional (0).
    558  * @param   pszFile             The file where the lock is being acquired from.
    559  *                              Optional.
    560  * @param   iLine               The line number in that file.  Optional (0).
    561  * @param   pszFunction         The function where the lock is being acquired
    562  *                              from.  Optional.
     552 * @param   SRC_POS             The source position where call is being made
     553 *                              from.  Use RT_SRC_POS when possible.  Optional.
    563554 */
    564555RTDECL(int)  RTSemMutexRequestDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    572563 * @param   uId                 Some kind of locking location ID.  Typically a
    573564 *                              return address up the stack.  Optional (0).
    574  * @param   pszFile             The file where the lock is being acquired from.
    575  *                              Optional.
    576  * @param   iLine               The line number in that file.  Optional (0).
    577  * @param   pszFunction         The function where the lock is being acquired
    578  *                              from.  Optional.
     565 * @param   SRC_POS             The source position where call is being made
     566 *                              from.  Use RT_SRC_POS when possible.  Optional.
    579567 */
    580568RTDECL(int)  RTSemMutexRequestNoResumeDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    608596 * @param   uId                 Some kind of locking location ID.  Typically a
    609597 *                              return address up the stack.  Optional (0).
    610  * @param   pszFile             The file where the lock is being acquired from.
    611  *                              Optional.
    612  * @param   iLine               The line number in that file.  Optional (0).
    613  * @param   pszFunction         The function where the lock is being acquired
    614  *                              from.  Optional.
     598 * @param   SRC_POS             The source position where call is being made
     599 *                              from.  Use RT_SRC_POS when possible.  Optional.
    615600 */
    616601RTDECL(int)  RTSemMutexRequestExDebug(RTSEMMUTEX hMutexSem, uint32_t fFlags, uint64_t uTimeout,
    … …  
    916901 * @param   uId                 Some kind of locking location ID.  Typically a
    917902 *                              return address up the stack.  Optional (0).
    918  * @param   pszFile             The file where the lock is being acquired from.
    919  *                              Optional.
    920  * @param   iLine               The line number in that file.  Optional (0).
    921  * @param   pszFunction         The function where the lock is being acquired
    922  *                              from.  Optional.
     903 * @param   SRC_POS             The source position where call is being made
     904 *                              from.  Use RT_SRC_POS when possible.  Optional.
    923905 */
    924906RTDECL(int)   RTSemRWRequestReadDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    936918 * @param   uId                 Some kind of locking location ID.  Typically a
    937919 *                              return address up the stack.  Optional (0).
    938  * @param   pszFile             The file where the lock is being acquired from.
    939  *                              Optional.
    940  * @param   iLine               The line number in that file.  Optional (0).
    941  * @param   pszFunction         The function where the lock is being acquired
    942  *                              from.  Optional.
     920 * @param   SRC_POS             The source position where call is being made
     921 *                              from.  Use RT_SRC_POS when possible.  Optional.
    943922 */
    944923RTDECL(int)   RTSemRWRequestReadNoResumeDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    979958 * @param   uId                 Some kind of locking location ID.  Typically a
    980959 *                              return address up the stack.  Optional (0).
    981  * @param   pszFile             The file where the lock is being acquired from.
    982  *                              Optional.
    983  * @param   iLine               The line number in that file.  Optional (0).
    984  * @param   pszFunction         The function where the lock is being acquired
    985  *                              from.  Optional.
     960 * @param   SRC_POS             The source position where call is being made
     961 *                              from.  Use RT_SRC_POS when possible.  Optional.
    986962 */
    987963RTDECL(int)   RTSemRWRequestReadExDebug(RTSEMRW hRWSem, uint32_t fFlags, uint64_t uTimeout,
    … …  
    10331009 * @param   uId                 Some kind of locking location ID.  Typically a
    10341010 *                              return address up the stack.  Optional (0).
    1035  * @param   pszFile             The file where the lock is being acquired from.
    1036  *                              Optional.
    1037  * @param   iLine               The line number in that file.  Optional (0).
    1038  * @param   pszFunction         The function where the lock is being acquired
    1039  *                              from.  Optional.
     1011 * @param   SRC_POS             The source position where call is being made
     1012 *                              from.  Use RT_SRC_POS when possible.  Optional.
    10401013 */
    10411014RTDECL(int)  RTSemRWRequestWriteDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    10491022 * @param   uId                 Some kind of locking location ID.  Typically a
    10501023 *                              return address up the stack.  Optional (0).
    1051  * @param   pszFile             The file where the lock is being acquired from.
    1052  *                              Optional.
    1053  * @param   iLine               The line number in that file.  Optional (0).
    1054  * @param   pszFunction         The function where the lock is being acquired
    1055  *                              from.  Optional.
     1024 * @param   SRC_POS             The source position where call is being made
     1025 *                              from.  Use RT_SRC_POS when possible.  Optional.
    10561026 */
    10571027RTDECL(int)  RTSemRWRequestWriteNoResumeDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL);
    … …  
    10881058 * @param   uId                 Some kind of locking location ID.  Typically a
    10891059 *                              return address up the stack.  Optional (0).
    1090  * @param   pszFile             The file where the lock is being acquired from.
    1091  *                              Optional.
    1092  * @param   iLine               The line number in that file.  Optional (0).
    1093  * @param   pszFunction         The function where the lock is being acquired
    1094  *                              from.  Optional.
     1060 * @param   SRC_POS             The source position where call is being made
     1061 *                              from.  Use RT_SRC_POS when possible.  Optional.
    10951062 */
    10961063RTDECL(int)  RTSemRWRequestWriteExDebug(RTSEMRW hRWSem, uint32_t fFlags, uint64_t uTimeout,

  • trunk/include/iprt/sha.h

    r57572 r57926  
    6363 * @param   pvBuf       Pointer to the data.
    6464 * @param   cbBuf       The amount of data (in bytes).
    65  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    66  *                      the caller's buffer.)
    67  */
    68 RTDECL(void) RTSha1(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA1_HASH_SIZE]);
     65 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     66 *                      the caller's buffer.)
     67 */
     68RTDECL(void) RTSha1(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA1_HASH_SIZE]);
    6969
    7070/**
    … …  
    7777 *                      caller's buffer.)
    7878 */
    79 RTDECL(bool) RTSha1Check(const void *pvBuf, size_t cbBuf, uint8_t const pabDigest[RTSHA1_HASH_SIZE]);
     79RTDECL(bool) RTSha1Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA1_HASH_SIZE]);
    8080
    8181/**
    … …  
    9999 *
    100100 * @param   pCtx        Pointer to the SHA-1 context.
    101  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    102  *                      the caller's buffer.)
    103  */
    104 RTDECL(void) RTSha1Final(PRTSHA1CONTEXT pCtx, uint8_t pabDigest[RTSHA1_HASH_SIZE]);
     101 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     102 *                      the caller's buffer.)
     103 */
     104RTDECL(void) RTSha1Final(PRTSHA1CONTEXT pCtx, uint8_t pabHash[RTSHA1_HASH_SIZE]);
    105105
    106106/**
    … …  
    109109 * @returns IPRT status code.
    110110 *
    111  * @param   pabDigest   The binary digest returned by RTSha1Final or RTSha1.
     111 * @param   pabHash     The binary digest returned by RTSha1Final or RTSha1.
    112112 * @param   pszDigest   Where to return the stringified digest.
    113113 * @param   cchDigest   The size of the output buffer. Should be at least
    114114 *                      RTSHA1_DIGEST_LEN + 1 bytes.
    115115 */
    116 RTDECL(int) RTSha1ToString(uint8_t const pabDigest[RTSHA1_HASH_SIZE], char *pszDigest, size_t cchDigest);
     116RTDECL(int) RTSha1ToString(uint8_t const pabHash[RTSHA1_HASH_SIZE], char *pszDigest, size_t cchDigest);
    117117
    118118/**
    … …  
    123123 * @param   pszDigest   The stringified digest. Leading and trailing spaces are
    124124 *                      ignored.
    125  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    126  *                      the caller's buffer.)
    127  */
    128 RTDECL(int) RTSha1FromString(char const *pszDigest, uint8_t pabDigest[RTSHA1_HASH_SIZE]);
     125 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     126 *                      the caller's buffer.)
     127 */
     128RTDECL(int) RTSha1FromString(char const *pszDigest, uint8_t pabHash[RTSHA1_HASH_SIZE]);
    129129
    130130/**
    … …  
    182182 * @param   pvBuf       Pointer to the data.
    183183 * @param   cbBuf       The amount of data (in bytes).
    184  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    185  *                      the caller's buffer.)
    186  */
    187 RTDECL(void) RTSha256(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA256_HASH_SIZE]);
     184 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     185 *                      the caller's buffer.)
     186 */
     187RTDECL(void) RTSha256(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA256_HASH_SIZE]);
    188188
    189189/**
    … …  
    196196 *                      caller's buffer.)
    197197 */
    198 RTDECL(bool) RTSha256Check(const void *pvBuf, size_t cbBuf, uint8_t const pabDigest[RTSHA256_HASH_SIZE]);
     198RTDECL(bool) RTSha256Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA256_HASH_SIZE]);
    199199
    200200/**
    … …  
    218218 *
    219219 * @param   pCtx        Pointer to the SHA-256 context.
    220  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    221  *                      the caller's buffer.)
    222  */
    223 RTDECL(void) RTSha256Final(PRTSHA256CONTEXT pCtx, uint8_t pabDigest[RTSHA256_HASH_SIZE]);
     220 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     221 *                      the caller's buffer.)
     222 */
     223RTDECL(void) RTSha256Final(PRTSHA256CONTEXT pCtx, uint8_t pabHash[RTSHA256_HASH_SIZE]);
    224224
    225225/**
    … …  
    228228 * @returns IPRT status code.
    229229 *
    230  * @param   pabDigest   The binary digest returned by RTSha256Final or RTSha256.
     230 * @param   pabHash     The binary digest returned by RTSha256Final or RTSha256.
    231231 * @param   pszDigest   Where to return the stringified digest.
    232232 * @param   cchDigest   The size of the output buffer. Should be at least
    233233 *                      RTSHA256_DIGEST_LEN + 1 bytes.
    234234 */
    235 RTDECL(int) RTSha256ToString(uint8_t const pabDigest[RTSHA256_HASH_SIZE], char *pszDigest, size_t cchDigest);
     235RTDECL(int) RTSha256ToString(uint8_t const pabHash[RTSHA256_HASH_SIZE], char *pszDigest, size_t cchDigest);
    236236
    237237/**
    … …  
    242242 * @param   pszDigest   The stringified digest. Leading and trailing spaces are
    243243 *                      ignored.
    244  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    245  *                      the caller's buffer.)
    246  */
    247 RTDECL(int) RTSha256FromString(char const *pszDigest, uint8_t pabDigest[RTSHA256_HASH_SIZE]);
     244 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     245 *                      the caller's buffer.)
     246 */
     247RTDECL(int) RTSha256FromString(char const *pszDigest, uint8_t pabHash[RTSHA256_HASH_SIZE]);
    248248
    249249/**
    … …  
    291291 * @param   pvBuf       Pointer to the data.
    292292 * @param   cbBuf       The amount of data (in bytes).
    293  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    294  *                      the caller's buffer.)
    295  */
    296 RTDECL(void) RTSha224(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA224_HASH_SIZE]);
     293 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     294 *                      the caller's buffer.)
     295 */
     296RTDECL(void) RTSha224(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA224_HASH_SIZE]);
    297297
    298298/**
    … …  
    305305 *                      caller's buffer.)
    306306 */
    307 RTDECL(bool) RTSha224Check(const void *pvBuf, size_t cbBuf, uint8_t const pabDigest[RTSHA224_HASH_SIZE]);
     307RTDECL(bool) RTSha224Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA224_HASH_SIZE]);
    308308
    309309/**
    … …  
    327327 *
    328328 * @param   pCtx        Pointer to the SHA-224 context.
    329  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    330  *                      the caller's buffer.)
    331  */
    332 RTDECL(void) RTSha224Final(PRTSHA224CONTEXT pCtx, uint8_t pabDigest[RTSHA224_HASH_SIZE]);
     329 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     330 *                      the caller's buffer.)
     331 */
     332RTDECL(void) RTSha224Final(PRTSHA224CONTEXT pCtx, uint8_t pabHash[RTSHA224_HASH_SIZE]);
    333333
    334334/**
    … …  
    337337 * @returns IPRT status code.
    338338 *
    339  * @param   pabDigest   The binary digest returned by RTSha224Final or RTSha224.
     339 * @param   pabHash     The binary digest returned by RTSha224Final or RTSha224.
    340340 * @param   pszDigest   Where to return the stringified digest.
    341341 * @param   cchDigest   The size of the output buffer. Should be at least
    342342 *                      RTSHA224_DIGEST_LEN + 1 bytes.
    343343 */
    344 RTDECL(int) RTSha224ToString(uint8_t const pabDigest[RTSHA224_HASH_SIZE], char *pszDigest, size_t cchDigest);
     344RTDECL(int) RTSha224ToString(uint8_t const pabHash[RTSHA224_HASH_SIZE], char *pszDigest, size_t cchDigest);
    345345
    346346/**
    … …  
    351351 * @param   pszDigest   The stringified digest. Leading and trailing spaces are
    352352 *                      ignored.
    353  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    354  *                      the caller's buffer.)
    355  */
    356 RTDECL(int) RTSha224FromString(char const *pszDigest, uint8_t pabDigest[RTSHA224_HASH_SIZE]);
     353 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     354 *                      the caller's buffer.)
     355 */
     356RTDECL(int) RTSha224FromString(char const *pszDigest, uint8_t pabHash[RTSHA224_HASH_SIZE]);
    357357
    358358/**
    … …  
    410410 * @param   pvBuf       Pointer to the data.
    411411 * @param   cbBuf       The amount of data (in bytes).
    412  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    413  *                      the caller's buffer.)
    414  */
    415 RTDECL(void) RTSha512(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RTSHA512_HASH_SIZE]);
     412 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     413 *                      the caller's buffer.)
     414 */
     415RTDECL(void) RTSha512(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RTSHA512_HASH_SIZE]);
    416416
    417417/**
    … …  
    424424 *                      caller's buffer.)
    425425 */
    426 RTDECL(bool) RTSha512Check(const void *pvBuf, size_t cbBuf, uint8_t const pabDigest[RTSHA512_HASH_SIZE]);
     426RTDECL(bool) RTSha512Check(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RTSHA512_HASH_SIZE]);
    427427
    428428/**
    … …  
    446446 *
    447447 * @param   pCtx        Pointer to the SHA-512 context.
    448  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    449  *                      the caller's buffer.)
    450  */
    451 RTDECL(void) RTSha512Final(PRTSHA512CONTEXT pCtx, uint8_t pabDigest[RTSHA512_HASH_SIZE]);
     448 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     449 *                      the caller's buffer.)
     450 */
     451RTDECL(void) RTSha512Final(PRTSHA512CONTEXT pCtx, uint8_t pabHash[RTSHA512_HASH_SIZE]);
    452452
    453453/**
    … …  
    456456 * @returns IPRT status code.
    457457 *
    458  * @param   pabDigest   The binary digest returned by RTSha512Final or RTSha512.
     458 * @param   pabHash     The binary digest returned by RTSha512Final or RTSha512.
    459459 * @param   pszDigest   Where to return the stringified digest.
    460460 * @param   cchDigest   The size of the output buffer. Should be at least
    461461 *                      RTSHA512_DIGEST_LEN + 1 bytes.
    462462 */
    463 RTDECL(int) RTSha512ToString(uint8_t const pabDigest[RTSHA512_HASH_SIZE], char *pszDigest, size_t cchDigest);
     463RTDECL(int) RTSha512ToString(uint8_t const pabHash[RTSHA512_HASH_SIZE], char *pszDigest, size_t cchDigest);
    464464
    465465/**
    … …  
    470470 * @param   pszDigest   The stringified digest. Leading and trailing spaces are
    471471 *                      ignored.
    472  * @param   pabDigest   Where to store the hash. (What is passed is a pointer to
    473  *                      the caller's buffer.)
    474  */
    475 RTDECL(int) RTSha512FromString(char const *pszDigest, uint8_t pabDigest[RTSHA512_HASH_SIZE]);
     472 * @param   pabHash     Where to store the hash. (What is passed is a pointer to
     473 *                      the caller's buffer.)
     474 */
     475RTDECL(int) RTSha512FromString(char const *pszDigest, uint8_t pabHash[RTSHA512_HASH_SIZE]);
    476476
    477477
    … …  
    481481    typedef RTSHA512CONTEXT RT_CONCAT3(RTSHA,a_UName,CONTEXT); \
    482482    typedef RTSHA512CONTEXT *RT_CONCAT3(PRTSHA,a_UName,CONTEXT); \
    483     RTDECL(void) RT_CONCAT(RTSha,a_Name)(const void *pvBuf, size_t cbBuf, uint8_t pabDigest[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
    484     RTDECL(bool) RT_CONCAT3(RTSha,a_Name,Check)(const void *pvBuf, size_t cbBuf, uint8_t const pabDigest[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
     483    RTDECL(void) RT_CONCAT(RTSha,a_Name)(const void *pvBuf, size_t cbBuf, uint8_t pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
     484    RTDECL(bool) RT_CONCAT3(RTSha,a_Name,Check)(const void *pvBuf, size_t cbBuf, uint8_t const pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
    485485    RTDECL(void) RT_CONCAT3(RTSha,a_Name,Init)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx); \
    486486    RTDECL(void) RT_CONCAT3(RTSha,a_Name,Update)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx, const void *pvBuf, size_t cbBuf); \
    487     RTDECL(void) RT_CONCAT3(RTSha,a_Name,Final)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx, uint8_t pabDigest[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
    488     RTDECL(int)  RT_CONCAT3(RTSha,a_Name,ToString)(uint8_t const pabDigest[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)], char *pszDigest, size_t cchDigest); \
    489     RTDECL(int)  RT_CONCAT3(RTSha,a_Name,FromString)(char const *pszDigest, uint8_t pabDigest[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)])
     487    RTDECL(void) RT_CONCAT3(RTSha,a_Name,Final)(RT_CONCAT3(PRTSHA,a_UName,CONTEXT) pCtx, uint8_t pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)]); \
     488    RTDECL(int)  RT_CONCAT3(RTSha,a_Name,ToString)(uint8_t const pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)], char *pszDigest, size_t cchDigest); \
     489    RTDECL(int)  RT_CONCAT3(RTSha,a_Name,FromString)(char const *pszDigest, uint8_t pabHash[RT_CONCAT3(RTSHA,a_UName,_HASH_SIZE)])
    490490
    491491

  • trunk/include/iprt/socket.h

    r53615 r57926  
    228228 *
    229229 * @returns iprt status code.
    230  * @param   Sock        Socket descriptor.
    231  * @param   fEvents     Event mask to wait for.
    232  * @param   pfEvents    Where to store the event mask on return.
    233  * @param   cMillies    Number of milliseconds to wait for the socket.
    234  *                      Use RT_INDEFINITE_WAIT to wait for ever.
    235  */
    236 RTR3DECL(int)  RTSocketSelectOneEx(RTSOCKET Sock, uint32_t fEvents, uint32_t *pfEvents,
    237                                    RTMSINTERVAL cMillies);
     230 * @param   hSocket         The Socket handle.
     231 * @param   fEvents         Event mask to wait for.
     232 * @param   pfEvents        Where to store the event mask on return.
     233 * @param   cMillies        Number of milliseconds to wait for the socket.  Use
     234 *                          RT_INDEFINITE_WAIT to wait for ever.
     235 */
     236RTR3DECL(int)  RTSocketSelectOneEx(RTSOCKET hSocket, uint32_t fEvents, uint32_t *pfEvents, RTMSINTERVAL cMillies);
    238237
    239238/**
    … …  
    241240 *
    242241 * @returns IPRT status code.
    243  * @param   hSocket             The socket handle.
    244  * @param   fRead               Whether to shutdown our read direction.
    245  * @param   fWrite              Whether to shutdown our write direction.
     242 * @param   hSocket         The socket handle.
     243 * @param   fRead           Whether to shutdown our read direction.
     244 * @param   fWrite          Whether to shutdown our write direction.
    246245 */
    247246RTDECL(int) RTSocketShutdown(RTSOCKET hSocket, bool fRead, bool fWrite);
    … …  
    251250 *
    252251 * @returns IPRT status code.
    253  * @param   Sock            Socket descriptor.
     252 * @param   hSocket         The Socket handle.
    254253 * @param   pAddr           Where to store the local address on success.
    255254 */
    … …  
    260259 *
    261260 * @returns IPRT status code.
    262  * @param   Sock            Socket descriptor.
     261 * @param   hSocket         The Socket handle.
    263262 * @param   pAddr           Where to store the peer address on success.
    264263 */
    … …  
    349348 * @returns iprt status code.
    350349 *
    351  * @param   Sock        Socket descriptor.
     350 * @param   hSocket     The Socket handle.
    352351 * @param   pSgBuf      Scatter/gather buffer to write data to socket.
    353352 * @param   pcbWritten  Number of bytes written.
    354353 */
    355 RTR3DECL(int)  RTSocketSgWriteNB(RTSOCKET Sock, PCRTSGBUF pSgBuf, size_t *pcbWritten);
     354RTR3DECL(int)  RTSocketSgWriteNB(RTSOCKET hSocket, PCRTSGBUF pSgBuf, size_t *pcbWritten);
    356355
    357356

  • trunk/include/iprt/string.h

    r57722 r57926  
    183183 * this as pointer to a volatile but read-only string.
    184184 */
    185 #ifndef RTSTR_TAG
     185#if !defined(RTSTR_TAG) || defined(DOXYGEN_RUNNING)
    186186# define RTSTR_TAG      (__FILE__)
    187187#endif
    … …  
    729729 *          may be partially processed.
    730730 * @param   psz            The string to sanitise.
    731  * @param   puszValidSets  A zero-terminated array of pairs of Unicode points.
     731 * @param   puszValidSet   A zero-terminated array of pairs of Unicode points.
    732732 *                         Each pair is the start and end point of a range,
    733733 *                         and the union of these ranges forms the white list.
    … …  
    929929 *                      This is undefined on failure.
    930930 */
    931 RTDECL(int) RTStrCalcLatin1LenEx(const char *psz, size_t cch, size_t *pcwc);
     931RTDECL(int) RTStrCalcLatin1LenEx(const char *psz, size_t cch, size_t *pcch);
    932932
    933933/**
    … …  
    14601460 * @param   psz         Pointer to the current code point.
    14611461 */
    1462 DECLINLINE(char *) RTLatin1PrevCp(const char *psz)
     1462DECLINLINE(char *) RTLatin1PrevCp(const char *pszStart const char *psz)
    14631463{
    1464     psz--;
    1465     return (char *)psz;
     1464    if ((uintptr_t)psz > (uintptr_t)pszStart)
     1465    {
     1466        psz--;
     1467        return (char *)psz;
     1468    }
     1469    return (char *)pszStart;
    14661470}
    14671471
    … …  
    34803484 *          terminated.
    34813485 *
    3482  * @param   pszDst              The destination buffer.
     3486 * @param   pwszDst             The destination buffer.
    34833487 * @param   cwcDst              The size of the destination buffer in RTUTF16s.
    34843488 * @param   pwszSrc             The source string.  NULL is not OK.
    … …  
    34943498 *          terminated.
    34953499 *
    3496  * @param   pszDst              The destination buffer.
     3500 * @param   pwszDst             The destination buffer.
    34973501 * @param   cwcDst              The size of the destination buffer in RTUTF16s.
    34983502 * @param   pszSrc              The source string, pure ASCII.  NULL is not OK.
    34993503 */
    3500 RTDECL(int) RTUtf16CatAscii(PRTUTF16 pwszDst, size_t cwcDst, const char *pwszSrc);
     3504RTDECL(int) RTUtf16CatAscii(PRTUTF16 pwszDst, size_t cwcDst, const char *pszSrc);
    35013505
    35023506/**
    … …  
    36503654 *          may be partially processed.
    36513655 * @param   pwsz           The string to sanitise.
    3652  * @param   puszValidSets  A zero-terminated array of pairs of Unicode points.
     3656 * @param   puszValidSet   A zero-terminated array of pairs of Unicode points.
    36533657 *                         Each pair is the start and end point of a range,
    36543658 *                         and the union of these ranges forms the white list.

  • trunk/src/VBox/Runtime/Doxyfile

    r36507 r57926  
    205205\
    206206Implements the callback \link \1 \1 "
     207
     208# bugref - xTracker bug reference, takes one to four bug numbers.
     209ALIASES               += bugref{1}="https://xtracker.innotek.de/index.php?bug=\1"
     210ALIASES               += bugref{2}="https://xtracker.innotek.de/index.php?bug=\1, \
     211https://xtracker.innotek.de/index.php?bug=\2"
     212ALIASES               += bugref{3}="https://xtracker.innotek.de/index.php?bug=\1, \
     213https://xtracker.innotek.de/index.php?bug=\2, \
     214https://xtracker.innotek.de/index.php?bug=\3"
     215ALIASES               += bugref{4}="https://xtracker.innotek.de/index.php?bug=\1, \
     216https://xtracker.innotek.de/index.php?bug=\2, \
     217https://xtracker.innotek.de/index.php?bug=\3, \
     218https://xtracker.innotek.de/index.php?bug=\4"
     219
     220# ticketref - Track ticket reference, takes one to four ticket numbers.
     221ALIASES               += ticketref{1}="http://www.virtualbox.org/ticket/\1"
     222ALIASES               += ticketref{2}="http://www.virtualbox.org/ticket/\1, \
     223http://www.virtualbox.org/ticket/\2"
     224ALIASES               += ticketref{3}="http://www.virtualbox.org/ticket/\1, \
     225http://www.virtualbox.org/ticket/\2, \
     226http://www.virtualbox.org/ticket/\3"
     227ALIASES               += ticketref{4}="http://www.virtualbox.org/ticket/\1, \
     228http://www.virtualbox.org/ticket/\2, \
     229http://www.virtualbox.org/ticket/\3, \
     230http://www.virtualbox.org/ticket/\4"
     231
    207232
    208233# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
    … …  
    11941219    "DECLINLINE(type)=inline type" \
    11951220    DECL_FORCE_INLINE(type)=DECLINLINE(type) \
     1221    DECL_NO_INLINE(type)=type \
    11961222    \
    11971223    AssertCompile(expr) \
    … …  
    12031229    AssertCompile2MemberOffsets(a,b,c) \
    12041230    \
     1231    RT_SRC_POS=1 \
     1232    RT_SRC_POS_ARGS=SRC_POS \
     1233    "RT_SRC_POS_DECL=int SRC_POS" \
     1234    \
     1235    RT_IPRT_FORMAT_ATTR(a,b)= \
     1236    RT_IPRT_FORMAT_ATTR_MAYBE_NULL(a,b)= \
     1237    RT_NO_THROW_PROTO=
    12051238
    12061239# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
    … …  
    12451278    CTXMID \
    12461279    OTHERCTXMID \
    1247     \
    1248     RT_SRC_POS \
    1249     RT_SRC_POS_ARGS \
    1250     RT_SRC_POS_DECL
    12511280
    12521281

  • trunk/src/VBox/Runtime/common/asn1/asn1-basics.cpp

    r57358 r57926  
    334334 */
    335335
    336 RTDECL(void) RTAsn1VtDelete(PRTASN1CORE pAsn1Core)
    337 {
    338     if (pAsn1Core)
    339     {
    340         PCRTASN1COREVTABLE pOps = pAsn1Core->pOps;
     336RTDECL(void) RTAsn1VtDelete(PRTASN1CORE pThisCore)
     337{
     338    if (pThisCore)
     339    {
     340        PCRTASN1COREVTABLE pOps = pThisCore->pOps;
    341341        if (pOps)
    342             pOps->pfnDtor(pAsn1Core);
     342            pOps->pfnDtor(pThisCore);
    343343    }
    344344}
    … …  
    355355
    356356
    357 static DECLCALLBACK(int) rtAsn1VtDeepEnumDepthFirst(PRTASN1CORE pAsn1Core, const char *pszName, uint32_t uDepth, void *pvUser)
    358 {
    359     AssertReturn(pAsn1Core, VINF_SUCCESS);
    360 
    361     if (pAsn1Core->pOps && pAsn1Core->pOps->pfnEnum)
    362     {
    363         int rc = pAsn1Core->pOps->pfnEnum(pAsn1Core, rtAsn1VtDeepEnumDepthFirst, uDepth, pvUser);
     357static DECLCALLBACK(int) rtAsn1VtDeepEnumDepthFirst(PRTASN1CORE pThisCore, const char *pszName, uint32_t uDepth, void *pvUser)
     358{
     359    AssertReturn(pThisCore, VINF_SUCCESS);
     360
     361    if (pThisCore->pOps && pThisCore->pOps->pfnEnum)
     362    {
     363        int rc = pThisCore->pOps->pfnEnum(pThisCore, rtAsn1VtDeepEnumDepthFirst, uDepth, pvUser);
    364364        if (rc != VINF_SUCCESS)
    365365            return rc;
    … …  
    367367
    368368    RTASN1DEEPENUMCTX *pCtx = (RTASN1DEEPENUMCTX *)pvUser;
    369     return pCtx->pfnCallback(pAsn1Core, pszName, uDepth, pCtx->pvUser);
    370 }
    371 
    372 
    373 static DECLCALLBACK(int) rtAsn1VtDeepEnumDepthLast(PRTASN1CORE pAsn1Core, const char *pszName, uint32_t uDepth, void *pvUser)
    374 {
    375     AssertReturn(pAsn1Core, VINF_SUCCESS);
     369    return pCtx->pfnCallback(pThisCore, pszName, uDepth, pCtx->pvUser);
     370}
     371
     372
     373static DECLCALLBACK(int) rtAsn1VtDeepEnumDepthLast(PRTASN1CORE pThisCore, const char *pszName, uint32_t uDepth, void *pvUser)
     374{
     375    AssertReturn(pThisCore, VINF_SUCCESS);
    376376
    377377    RTASN1DEEPENUMCTX *pCtx = (RTASN1DEEPENUMCTX *)pvUser;
    378     int rc = pCtx->pfnCallback(pAsn1Core, pszName, uDepth, pCtx->pvUser);
     378    int rc = pCtx->pfnCallback(pThisCore, pszName, uDepth, pCtx->pvUser);
    379379    if (rc == VINF_SUCCESS)
    380380    {
    381         if (pAsn1Core->pOps && pAsn1Core->pOps->pfnEnum)
    382             rc = pAsn1Core->pOps->pfnEnum(pAsn1Core, rtAsn1VtDeepEnumDepthFirst, uDepth, pvUser);
     381        if (pThisCore->pOps && pThisCore->pOps->pfnEnum)
     382            rc = pThisCore->pOps->pfnEnum(pThisCore, rtAsn1VtDeepEnumDepthFirst, uDepth, pvUser);
    383383    }
    384384    return rc;

  • trunk/src/VBox/Runtime/common/checksum/manifest2.cpp

    r57358 r57926  
    135135    const char * const *papszIgnoreEntries;
    136136    /** Name of attributes to ignore. */
    137     const char * const *papszIgnoreAttr;
     137    const char * const *papszIgnoreAttrs;
    138138    /** Flags governing the comparision. */
    139139    uint32_t            fFlags;
    … …  
    350350     * Ignore this entry?
    351351     */
    352     char const * const *ppsz = pEquals->papszIgnoreAttr;
     352    char const * const *ppsz = pEquals->papszIgnoreAttrs;
    353353    if (ppsz)
    354354    {
    … …  
    425425     * Ignore this entry?
    426426     */
    427     char const * const *ppsz = pEquals->papszIgnoreAttr;
     427    char const * const *ppsz = pEquals->papszIgnoreAttrs;
    428428    if (ppsz)
    429429    {
    … …  
    571571
    572572RTDECL(int) RTManifestEqualsEx(RTMANIFEST hManifest1, RTMANIFEST hManifest2, const char * const *papszIgnoreEntries,
    573                                const char * const *papszIgnoreAttr, uint32_t fFlags, char *pszError, size_t cbError)
     573                               const char * const *papszIgnoreAttrs, uint32_t fFlags, char *pszError, size_t cbError)
    574574{
    575575    /*
    … …  
    614614    Equals.fFlags               = fFlags;
    615615    Equals.papszIgnoreEntries   = papszIgnoreEntries;
    616     Equals.papszIgnoreAttr      = papszIgnoreAttr;
     616    Equals.papszIgnoreAttrs     = papszIgnoreAttrs;
    617617    Equals.pszError             = pszError;
    618618    Equals.cbError              = cbError;

  • trunk/src/VBox/Runtime/common/err/RTErrConvertFromErrno.cpp

    r57358 r57926  
    120120#endif
    121121#ifdef ENFILE
    122         case ENFILE:            return VERR_TOO_MANY_OPEN_FILES; /**@Todo fix duplicate error */
     122        case ENFILE:            return VERR_TOO_MANY_OPEN_FILES; /** @todo fix duplicate error */
    123123#endif
    124124#ifdef EMFILE

  • trunk/src/VBox/Runtime/common/err/errmsg.cpp

    r57358 r57926  
    4646static const RTSTATUSMSG  g_aStatusMsgs[] =
    4747{
    48 #ifndef IPRT_NO_ERROR_DATA
     48#if !defined(IPRT_NO_ERROR_DATA) && !defined(DOXYGEN_RUNNING)
    4949# include "errmsgdata.h"
    5050#else

  • trunk/src/VBox/Runtime/common/err/errmsgxpcom.cpp

    r57358 r57926  
    107107    MY_ERR("NS_SUCCESS_FILE_DIRECTORY_EMPTY",       "NS_SUCCESS_FILE_DIRECTORY_EMPTY",              UINT32_C(0x00520001)),
    108108
    109 #if defined(VBOX) && !defined(IN_GUEST)
     109#if defined(VBOX) && !defined(IN_GUEST) && !defined(DOXYGEN_RUNNING)
    110110# include "errmsgvboxcomdata.h"
    111111#endif

  • trunk/src/VBox/Runtime/r0drv/solaris/semeventwait-r0drv-solaris.h

    r56290 r57926  
    101101 * @param   fFlags              The wait flags.
    102102 * @param   uTimeout            The timeout.
    103  * @param   pWaitQueue          The wait queue head.
    104103 */
    105104DECLINLINE(int) rtR0SemSolWaitInit(PRTR0SEMSOLWAIT pWait, uint32_t fFlags, uint64_t uTimeout)

  • trunk/src/VBox/Runtime/r3/init.cpp

    r57358 r57926  
    369369 * rtR3Init worker.
    370370 */
    371 static int rtR3InitBody(uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath)
     371static int rtR3InitBody(uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath)
    372372{
    373373    /*
    … …  
    448448    AssertLogRelMsgRCReturn(rc, ("Failed to get executable directory path, rc=%Rrc!\n", rc), rc);
    449449
    450     rc = rtR3InitArgv(fFlags, cArgs, papszArgs);
     450    rc = rtR3InitArgv(fFlags, cArgs, ppapszArgs);
    451451    AssertLogRelMsgRCReturn(rc, ("Failed to convert the arguments, rc=%Rrc!\n", rc), rc);
    452452
    … …  
    550550 *                          out ourselves.
    551551 */
    552 static int rtR3Init(uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath)
     552static int rtR3Init(uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath)
    553553{
    554554    /* no entry log flow, because prefixes and thread may freak out. */
    … …  
    590590            rc = rtR3InitProgramPath(pszProgramPath);
    591591        if (RT_SUCCESS(rc))
    592             rc = rtR3InitArgv(fFlags, cArgs, papszArgs);
     592            rc = rtR3InitArgv(fFlags, cArgs, ppapszArgs);
    593593        return rc;
    594594    }
    … …  
    598598     * Do the initialization.
    599599     */
    600     int rc = rtR3InitBody(fFlags, cArgs, papszArgs, pszProgramPath);
     600    int rc = rtR3InitBody(fFlags, cArgs, ppapszArgs, pszProgramPath);
    601601    if (RT_FAILURE(rc))
    602602    {
    … …  
    614614
    615615
    616 RTR3DECL(int) RTR3InitExe(int cArgs, char ***papszArgs, uint32_t fFlags)
     616RTR3DECL(int) RTR3InitExe(int cArgs, char ***ppapszArgs, uint32_t fFlags)
    617617{
    618618    Assert(!(fFlags & RTR3INIT_FLAGS_DLL));
    619     return rtR3Init(fFlags, cArgs, papszArgs, NULL);
     619    return rtR3Init(fFlags, cArgs, ppapszArgs, NULL);
    620620}
    621621
    … …  
    635635
    636636
    637 RTR3DECL(int) RTR3InitEx(uint32_t iVersion, uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath)
     637RTR3DECL(int) RTR3InitEx(uint32_t iVersion, uint32_t fFlags, int cArgs, char ***ppapszArgs, const char *pszProgramPath)
    638638{
    639639    AssertReturn(iVersion == RTR3INIT_VER_CUR, VERR_NOT_SUPPORTED);
    640     return rtR3Init(fFlags, cArgs, papszArgs, pszProgramPath);
     640    return rtR3Init(fFlags, cArgs, ppapszArgs, pszProgramPath);
    641641}
    642642

  • trunk/src/VBox/Runtime/r3/isofs.cpp

    r57358 r57926  
    525525
    526526
    527 RTR3DECL(int) RTIsoFsGetFileInfo(PRTISOFSFILE pFile, const char *pszPath,
    528                                  uint32_t *pcbOffset, size_t *pcbLength)
     527RTR3DECL(int) RTIsoFsGetFileInfo(PRTISOFSFILE pFile, const char *pszPath, uint32_t *poffInIso, size_t *pcbLength)
    529528{
    530529    AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
    531530    AssertPtrReturn(pszPath, VERR_INVALID_PARAMETER);
    532     AssertPtrReturn(pcbOffset, VERR_INVALID_PARAMETER);
     531    AssertPtrReturn(poffInIso, VERR_INVALID_PARAMETER);
    533532
    534533    PRTISOFSDIRRECORD pDirRecord;
    … …  
    545544        if (RT_SUCCESS(rc))
    546545        {
    547             *pcbOffset = pFileRecord->extent_location * RTISOFS_SECTOR_SIZE;
     546            *poffInIso = pFileRecord->extent_location * RTISOFS_SECTOR_SIZE;
    548547            *pcbLength = pFileRecord->extent_data_length;
    549548            rtIsoFsFreeDirectoryRecord(pFileRecord);
    … …  
    555554
    556555
    557 RTR3DECL(int) RTIsoFsExtractFile(PRTISOFSFILE pFile, const char *pszSource,
    558                                  const char *pszDest)
    559 {
    560     AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
    561     AssertPtrReturn(pszSource, VERR_INVALID_PARAMETER);
    562     AssertPtrReturn(pszDest, VERR_INVALID_PARAMETER);
     556RTR3DECL(int) RTIsoFsExtractFile(PRTISOFSFILE pFile, const char *pszSrcPath, const char *pszDstPath)
     557{
     558    AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
     559    AssertPtrReturn(pszSrcPath, VERR_INVALID_PARAMETER);
     560    AssertPtrReturn(pszDstPath, VERR_INVALID_PARAMETER);
    563561
    564562    uint32_t cbOffset;
    565563    size_t cbLength;
    566     int rc = RTIsoFsGetFileInfo(pFile, pszSource, &cbOffset, &cbLength);
     564    int rc = RTIsoFsGetFileInfo(pFile, pszSrcPath, &cbOffset, &cbLength);
    567565    if (RT_SUCCESS(rc))
    568566    {
    … …  
    571569        {
    572570            RTFILE fileDest;
    573             rc = RTFileOpen(&fileDest, pszDest, RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE);
     571            rc = RTFileOpen(&fileDest, pszDstPath, RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE);
    574572            if (RT_SUCCESS(rc))
    575573            {

  • trunk/src/VBox/Runtime/r3/nt/internal-r3-nt.h

    r56290 r57926  
    4949 * @returns @c true if equal, @c false if not.
    5050 * @param   pwsz1               The first string.
    51  * @param   cb1                 The length of the first string, in bytes.
     51 * @param   cch1                The length of the first string, in bytes.
    5252 * @param   psz2                The second string.
    5353 * @param   cch2                The length of the second string.

  • trunk/src/VBox/Runtime/win/errmsgwin.cpp

    r57358 r57926  
    4545static const RTWINERRMSG  g_aStatusMsgs[] =
    4646{
    47 #ifndef IPRT_NO_ERROR_DATA
     47#if !defined(IPRT_NO_ERROR_DATA) && !defined(DOXYGEN_RUNNING)
    4848# include "errmsgcomdata.h"
    4949# if defined(VBOX) && !defined(IN_GUEST)
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette