VirtualBox

儲存庫 vbox 的更動 90803


忽略:
時間撮記:
2021-8-23 下午07:08:38 (4 年 以前)
作者:
vboxsync
svn:sync-xref-src-repo-rev:
146438
訊息:

Runtime: More VALID_PTR -> RT_VALID_PTR/AssertPtr.

位置:
trunk/src/VBox/Runtime
檔案:
修改 26 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/VBox/Runtime/common/dbg/dbgas.cpp

    r82968 r90803  
    332332        PRTDBGASMOD pMod = pDbgAs->papModules[i];
    333333        AssertPtr(pMod);
    334         if (VALID_PTR(pMod))
     334        if (RT_VALID_PTR(pMod))
    335335        {
    336336            Assert(pMod->iOrdinal == i);

  • trunk/src/VBox/Runtime/common/fuzz/fuzz.cpp

    r85121 r90803  
    21372137        rc = pMutator->pfnPrep(pThis, offStart, pMutationParent, &pMutation);
    21382138        if (   RT_SUCCESS(rc)
    2139             && VALID_PTR(pMutation))
     2139            && RT_VALID_PTR(pMutation))
    21402140        {
    21412141            pMutation->pMutator = pMutator;

  • trunk/src/VBox/Runtime/common/ldr/ldrEx.cpp

    r90789 r90803  
    394394     */
    395395    AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
    396     AssertMsgReturn(!pvBits || VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
     396    AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER);
    397397    AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
    398398    PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;
    … …  
    418418     */
    419419    AssertMsgReturn(rtldrIsValid(hLdrMod), ("hLdrMod=%p\n", hLdrMod), VERR_INVALID_HANDLE);
    420     AssertMsgReturn(!pvBits || RT_VALID_PTR(pvBits), ("pvBits=%p\n", pvBits), VERR_INVALID_PARAMETER);
     420    AssertPtrNullReturn(pvBits, VERR_INVALID_POINTER);
    421421    AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
    422422    PRTLDRMODINTERNAL pMod = (PRTLDRMODINTERNAL)hLdrMod;

  • trunk/src/VBox/Runtime/common/log/log.cpp

    r90693 r90803  
    799799     */
    800800    if (   (cGroups && !papszGroups)
    801         || !VALID_PTR(ppLogger) )
     801        || !RT_VALID_PTR(ppLogger) )
    802802    {
    803803        AssertMsgFailed(("Invalid parameters!\n"));
    … …  
    997997
    998998                    /* Use the callback to generate some initial log contents. */
    999                     Assert(VALID_PTR(pLogger->pInt->pfnPhase) || pLogger->pInt->pfnPhase == NULL);
     999                    Assert(RT_VALID_PTR(pLogger->pInt->pfnPhase) || pLogger->pInt->pfnPhase == NULL);
    10001000                    if (pLogger->pInt->pfnPhase)
    10011001                        pLogger->pInt->pfnPhase(pLogger, RTLOGPHASE_BEGIN, rtlogPhaseMsgNormal);

  • trunk/src/VBox/Runtime/common/log/tracelogwriter.cpp

    r86387 r90803  
    899899
    900900    if (   RT_SUCCESS(rc)
    901         && VALID_PTR(pEvtDescInt))
     901        && RT_VALID_PTR(pEvtDescInt))
    902902    {
    903903        TRACELOGEVT Evt;
    … …  
    933933
    934934    if (   RT_SUCCESS(rc)
    935         && VALID_PTR(pEvtDescInt))
     935        && RT_VALID_PTR(pEvtDescInt))
    936936    {
    937937        TRACELOGEVT Evt;

  • trunk/src/VBox/Runtime/common/misc/assert.cpp

    r82968 r90803  
    224224                "Expression: %s\n"
    225225                "Location  : %s(%d) %s\n",
    226                 VALID_PTR(pszExpr) ? pszExpr : "<none>",
    227                 VALID_PTR(pszFile) ? pszFile : "<none>",
     226                RT_VALID_PTR(pszExpr) ? pszExpr : "<none>",
     227                RT_VALID_PTR(pszFile) ? pszFile : "<none>",
    228228                uLine,
    229                 VALID_PTR(pszFunction) ? pszFunction : "");
     229                RT_VALID_PTR(pszFunction) ? pszFunction : "");
    230230# ifdef IPRT_WITH_ASSERT_STACK
    231231        fprintf(stderr, "Stack     :\n%s\n", szStack);

  • trunk/src/VBox/Runtime/common/misc/lockvalidator.cpp

    r87151 r90803  
    386386    if (!pThread)
    387387        return "<NIL>";
    388     if (!VALID_PTR(pThread))
     388    if (!RT_VALID_PTR(pThread))
    389389        return "<INVALID>";
    390390    if (pThread->u32Magic != RTTHREADINT_MAGIC)
    … …  
    450450
    451451    /* Validate the class pointer. */
    452     if (!VALID_PTR(pClass))
     452    if (!RT_VALID_PTR(pClass))
    453453    {
    454454        RTAssertMsg2AddWeak("%sbad class=%p sub-class=%s\n", pszPrefix, pClass, pszSubClass);
    … …  
    538538    if (!pClass)
    539539        return "<nil-class>";
    540     if (!VALID_PTR(pClass))
     540    if (!RT_VALID_PTR(pClass))
    541541        return "<bad-class-ptr>";
    542542    if (pClass->u32Magic != RTLOCKVALCLASS_MAGIC)
    … …  
    612612        {
    613613            PRTLOCKVALRECSHRD pShared = pRec->ShrdOwner.pSharedRec;
    614             if (    VALID_PTR(pShared)
     614            if (    RT_VALID_PTR(pShared)
    615615                &&  pShared->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC)
    616616#ifdef RTLOCKVAL_WITH_VERBOSE_DUMPS
    … …  
    660660# define FIX_REC(r)     (r)
    661661#endif
    662     if (    VALID_PTR(pRec)
     662    if (    RT_VALID_PTR(pRec)
    663663        &&  !ASMAtomicUoReadBool(&g_fLockValidatorQuiet))
    664664    {
    … …  
    683683                PRTLOCKVALRECUNION  pRealRec = pRec->Nest.pRec;
    684684                uint32_t            u32Magic;
    685                 if (   VALID_PTR(pRealRec)
     685                if (   RT_VALID_PTR(pRealRec)
    686686                    && (   (u32Magic = pRealRec->Core.u32Magic) == RTLOCKVALRECEXCL_MAGIC
    687687                        || u32Magic == RTLOCKVALRECSHRD_MAGIC
    … …  
    720720                                            PRTLOCKVALRECUNION pHighightRec)
    721721{
    722     if (    VALID_PTR(pThread)
     722    if (    RT_VALID_PTR(pThread)
    723723        &&  !ASMAtomicUoReadBool(&g_fLockValidatorQuiet)
    724724        &&  pThread->u32Magic == RTTHREADINT_MAGIC
    … …  
    731731                                pThread, pThread->szName, cEntries, cEntries == 1 ? "y" : "ies");
    732732            PRTLOCKVALRECUNION pCur = rtLockValidatorReadRecUnionPtr(&pThread->LockValidator.pStackTop);
    733             for (uint32_t i = 0; VALID_PTR(pCur); i++)
     733            for (uint32_t i = 0; RT_VALID_PTR(pCur); i++)
    734734            {
    735735                char szPrefix[80];
    … …  
    771771        RTAssertMsg1Weak("RTLockValidator", pSrcPos ? pSrcPos->uLine : 0, pSrcPos ? pSrcPos->pszFile : NULL, pSrcPos ? pSrcPos->pszFunction : NULL);
    772772        if (pSrcPos && pSrcPos->uId)
    773             RTAssertMsg2Weak("%s  [uId=%p  thrd=%s]\n", pszWhat, pSrcPos->uId, VALID_PTR(pThreadSelf) ? pThreadSelf->szName : "<NIL>");
     773            RTAssertMsg2Weak("%s  [uId=%p  thrd=%s]\n", pszWhat, pSrcPos->uId, RT_VALID_PTR(pThreadSelf) ? pThreadSelf->szName : "<NIL>");
    774774        else
    775             RTAssertMsg2Weak("%s  [thrd=%s]\n", pszWhat, VALID_PTR(pThreadSelf) ? pThreadSelf->szName : "<NIL>");
     775            RTAssertMsg2Weak("%s  [thrd=%s]\n", pszWhat, RT_VALID_PTR(pThreadSelf) ? pThreadSelf->szName : "<NIL>");
    776776        rtLockValComplainAboutLock("Lock: ", pRec, "\n");
    777777        if (fDumpStack)
    … …  
    15911591        case RTLOCKVALRECNEST_MAGIC:
    15921592            pRec = rtLockValidatorReadRecUnionPtr(&pRec->Nest.pRec);
    1593             if (VALID_PTR(pRec))
     1593            if (RT_VALID_PTR(pRec))
    15941594            {
    15951595                switch (pRec->Core.u32Magic)
    … …  
    16331633        {
    16341634            PRTLOCKVALRECSHRD pSharedRec = pRec->ShrdOwner.pSharedRec;
    1635             if (RT_LIKELY(   VALID_PTR(pSharedRec)
     1635            if (RT_LIKELY(   RT_VALID_PTR(pSharedRec)
    16361636                          && pSharedRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC))
    16371637                return pSharedRec->hClass;
    … …  
    16421642        {
    16431643            PRTLOCKVALRECUNION pRealRec = pRec->Nest.pRec;
    1644             if (VALID_PTR(pRealRec))
     1644            if (RT_VALID_PTR(pRealRec))
    16451645            {
    16461646                switch (pRealRec->Core.u32Magic)
    … …  
    16521652                    {
    16531653                        PRTLOCKVALRECSHRD pSharedRec = pRealRec->ShrdOwner.pSharedRec;
    1654                         if (RT_LIKELY(   VALID_PTR(pSharedRec)
     1654                        if (RT_LIKELY(   RT_VALID_PTR(pSharedRec)
    16551655                                      && pSharedRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC))
    16561656                            return pSharedRec->hClass;
    … …  
    17021702
    17031703            PRTLOCKVALRECSHRD pSharedRec = pRec->ShrdOwner.pSharedRec;
    1704             if (RT_LIKELY(   VALID_PTR(pSharedRec)
     1704            if (RT_LIKELY(   RT_VALID_PTR(pSharedRec)
    17051705                          && pSharedRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC))
    17061706            {
    … …  
    17171717
    17181718            PRTLOCKVALRECUNION pRealRec = pRec->Nest.pRec;
    1719             if (VALID_PTR(pRealRec))
     1719            if (RT_VALID_PTR(pRealRec))
    17201720            {
    17211721                switch (pRealRec->Core.u32Magic)
    … …  
    17281728                    {
    17291729                        PRTLOCKVALRECSHRD pSharedRec = pRealRec->ShrdOwner.pSharedRec;
    1730                         if (RT_LIKELY(   VALID_PTR(pSharedRec)
     1730                        if (RT_LIKELY(   RT_VALID_PTR(pSharedRec)
    17311731                                      && pSharedRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC))
    17321732                        {
    … …  
    17741774        {
    17751775            PRTLOCKVALRECSHRD pSharedRec = pRec->ShrdOwner.pSharedRec;
    1776             if (RT_LIKELY(   VALID_PTR(pSharedRec)
     1776            if (RT_LIKELY(   RT_VALID_PTR(pSharedRec)
    17771777                          && pSharedRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC))
    17781778                return pSharedRec->uSubClass;
    … …  
    17831783        {
    17841784            PRTLOCKVALRECUNION pRealRec = pRec->Nest.pRec;
    1785             if (VALID_PTR(pRealRec))
     1785            if (RT_VALID_PTR(pRealRec))
    17861786            {
    17871787                switch (pRealRec->Core.u32Magic)
    … …  
    17931793                    {
    17941794                        PRTLOCKVALRECSHRD pSharedRec = pRealRec->ShrdOwner.pSharedRec;
    1795                         if (RT_LIKELY(   VALID_PTR(pSharedRec)
     1795                        if (RT_LIKELY(   RT_VALID_PTR(pSharedRec)
    17961796                                      && pSharedRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC))
    17971797                            return pSharedRec->uSubClass;
    … …  
    18261826    uint32_t            cEntries = 0;
    18271827    PRTLOCKVALRECUNION  pCur = rtLockValidatorReadRecUnionPtr(&pThread->LockValidator.pStackTop);
    1828     while (VALID_PTR(pCur))
     1828    while (RT_VALID_PTR(pCur))
    18291829    {
    18301830        switch (pCur->Core.u32Magic)
    … …  
    28702870            if (pStack->a[i].pRec->Core.u32Magic == RTLOCKVALRECSHRD_MAGIC)
    28712871                pShrdOwner = (PRTLOCKVALRECUNION)pStack->a[i].pRec->Shared.papOwners[pStack->a[i].iEntry];
    2872             if (VALID_PTR(pShrdOwner) && pShrdOwner->Core.u32Magic == RTLOCKVALRECSHRDOWN_MAGIC)
     2872            if (RT_VALID_PTR(pShrdOwner) && pShrdOwner->Core.u32Magic == RTLOCKVALRECSHRDOWN_MAGIC)
    28732873            {
    28742874                rtLockValComplainAboutLock(szPrefix, pShrdOwner, "\n");
    … …  
    43334333        {
    43344334            PRTLOCKVALRECUNION pCur = rtLockValidatorReadRecUnionPtr(&pThread->LockValidator.pStackTop);
    4335             while (VALID_PTR(pCur) && !fRet)
     4335            while (RT_VALID_PTR(pCur) && !fRet)
    43364336            {
    43374337                switch (pCur->Core.u32Magic)
    … …  
    43424342                        break;
    43434343                    case RTLOCKVALRECSHRDOWN_MAGIC:
    4344                         fRet = VALID_PTR(pCur->ShrdOwner.pSharedRec)
     4344                        fRet = RT_VALID_PTR(pCur->ShrdOwner.pSharedRec)
    43454345                            && pCur->ShrdOwner.pSharedRec->hClass == hClass;
    43464346                        pCur = rtLockValidatorReadRecUnionPtr(&pCur->ShrdOwner.pDown);
    … …  
    43534353                                break;
    43544354                            case RTLOCKVALRECSHRDOWN_MAGIC:
    4355                                 fRet = VALID_PTR(pCur->ShrdOwner.pSharedRec)
     4355                                fRet = RT_VALID_PTR(pCur->ShrdOwner.pSharedRec)
    43564356                                    && pCur->Nest.pRec->ShrdOwner.pSharedRec->hClass == hClass;
    43574357                                break;
    … …  
    43864386        {
    43874387            PRTLOCKVALRECUNION pCur = rtLockValidatorReadRecUnionPtr(&pThread->LockValidator.pStackTop);
    4388             while (VALID_PTR(pCur) && !fRet)
     4388            while (RT_VALID_PTR(pCur) && !fRet)
    43894389            {
    43904390                switch (pCur->Core.u32Magic)
    … …  
    43964396                        break;
    43974397                    case RTLOCKVALRECSHRDOWN_MAGIC:
    4398                         fRet = VALID_PTR(pCur->ShrdOwner.pSharedRec)
     4398                        fRet = RT_VALID_PTR(pCur->ShrdOwner.pSharedRec)
    43994399                            && pCur->ShrdOwner.pSharedRec->hClass == hClass
    44004400                            && pCur->ShrdOwner.pSharedRec->uSubClass == uSubClass;
    … …  
    44094409                                break;
    44104410                            case RTLOCKVALRECSHRDOWN_MAGIC:
    4411                                 fRet = VALID_PTR(pCur->ShrdOwner.pSharedRec)
     4411                                fRet = RT_VALID_PTR(pCur->ShrdOwner.pSharedRec)
    44124412                                    && pCur->Nest.pRec->ShrdOwner.pSharedRec->hClass == hClass
    44134413                                    && pCur->Nest.pRec->ShrdOwner.pSharedRec->uSubClass == uSubClass;

  • trunk/src/VBox/Runtime/common/misc/sg.cpp

    r89264 r90803  
    8484{
    8585    AssertPtr(pSgBuf);
    86     Assert(   (cSegs > 0 && VALID_PTR(paSegs))
     86    Assert(   (cSegs > 0 && RT_VALID_PTR(paSegs))
    8787           || (!cSegs && !paSegs));
    8888    Assert(cSegs < (~(unsigned)0 >> 1));

  • trunk/src/VBox/Runtime/common/misc/thread.cpp

    r90396 r90803  
    304304    RTTHREAD Thread;
    305305
    306     AssertReturn(!(fFlags & RTTHREADFLAGS_WAITABLE), VERR_INVALID_PARAMETER);
    307     AssertReturn(!pszName || VALID_PTR(pszName), VERR_INVALID_POINTER);
    308     AssertReturn(!pThread || VALID_PTR(pThread), VERR_INVALID_POINTER);
     306    AssertReturn(!(fFlags & RTTHREADFLAGS_WAITABLE), VERR_INVALID_FLAGS);
     307    AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
     308    AssertPtrNullReturn(pThread, VERR_INVALID_POINTER);
    309309
    310310    rc = VINF_SUCCESS;
    … …  
    552552DECLHIDDEN(PRTTHREADINT) rtThreadGet(RTTHREAD Thread)
    553553{
    554     if (    Thread != NIL_RTTHREAD
    555         &&  VALID_PTR(Thread))
     554    if (   Thread != NIL_RTTHREAD
     555        && RT_VALID_PTR(Thread))
    556556    {
    557557        PRTTHREADINT pThread = (PRTTHREADINT)Thread;

  • trunk/src/VBox/Runtime/common/time/time.cpp

    r82968 r90803  
    295295    int             iMonth;
    296296
    297     AssertMsg(VALID_PTR(pTime), ("%p\n", pTime));
    298     AssertMsg(VALID_PTR(pTimeSpec), ("%p\n", pTime));
     297    AssertPtr(pTime);
     298    AssertPtr(pTimeSpec);
    299299
    300300    /*
    … …  
    414414     * Validate input.
    415415     */
    416     AssertReturn(VALID_PTR(pTimeSpec), NULL);
    417     AssertReturn(VALID_PTR(pTime), NULL);
     416    AssertPtrReturn(pTimeSpec, NULL);
     417    AssertPtrReturn(pTime, NULL);
    418418    AssertReturn(pTime->u32Nanosecond < 1000000000, NULL);
    419419    AssertReturn(pTime->u8Second < 60, NULL);
    … …  
    696696     * Validate that we've got the minimum of stuff handy.
    697697     */
    698     AssertReturn(VALID_PTR(pTime), NULL);
     698    AssertPtrReturn(pTime, NULL);
    699699    AssertMsgReturn(!(pTime->fFlags & ~RTTIME_FLAGS_MASK), ("%#x\n", pTime->fFlags), NULL);
    700700    AssertMsgReturn((pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) != RTTIME_FLAGS_TYPE_LOCAL, ("Use RTTimeLocalNormalize!\n"), NULL);
    … …  
    736736     * Validate that we've got the minimum of stuff handy.
    737737     */
    738     AssertReturn(VALID_PTR(pTime), NULL);
     738    AssertPtrReturn(pTime, NULL);
    739739    AssertMsgReturn(!(pTime->fFlags & ~RTTIME_FLAGS_MASK), ("%#x\n", pTime->fFlags), NULL);
    740740    AssertMsgReturn((pTime->fFlags & RTTIME_FLAGS_TYPE_MASK) != RTTIME_FLAGS_TYPE_UTC, ("Use RTTimeNormalize!\n"), NULL);
    … …  
    15541554     * Validate that we've got the minimum of stuff handy.
    15551555     */
    1556     AssertReturn(VALID_PTR(pTime), NULL);
     1556    AssertPtrReturn(pTime, NULL);
    15571557    AssertMsgReturn(!(pTime->fFlags & ~RTTIME_FLAGS_MASK), ("%#x\n", pTime->fFlags), NULL);
    15581558

  • trunk/src/VBox/Runtime/generic/timer-generic.cpp

    r82968 r90803  
    143143DECLINLINE(bool) rtTimerIsValid(PRTTIMER pTimer)
    144144{
    145     AssertReturn(VALID_PTR(pTimer), false);
     145    AssertPtrReturn(pTimer, false);
    146146    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, false);
    147147    AssertReturn(!pTimer->fDestroyed, false);

  • trunk/src/VBox/Runtime/include/internal/fileaio.h

    r82968 r90803  
    5858/** Return true if the specified request is not valid, false otherwise. */
    5959#define RTFILEAIOREQ_IS_NOT_VALID(pReq) \
    60     (RT_UNLIKELY(!VALID_PTR(pReq) || (pReq->u32Magic != RTFILEAIOREQ_MAGIC)))
     60    (RT_UNLIKELY(!RT_VALID_PTR(pReq) || (pReq->u32Magic != RTFILEAIOREQ_MAGIC)))
    6161
    6262/** Validates a context handle and returns VERR_INVALID_HANDLE if not valid. */

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

    r87581 r90803  
    256256    AssertPtrReturn(pszFile2, VERR_INVALID_POINTER);
    257257    AssertReturn(*pszFile2, VERR_INVALID_PARAMETER);
    258     AssertMsgReturn(!pfnProgress || VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
     258    AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
    259259    AssertMsgReturn(!(fFlags & ~RTFILECOMP_FLAGS_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
    260260
    … …  
    302302    AssertReturn(RTFileIsValid(hFile1), VERR_INVALID_HANDLE);
    303303    AssertReturn(RTFileIsValid(hFile1), VERR_INVALID_HANDLE);
    304     AssertMsgReturn(!pfnProgress || VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
     304    AssertPtrNullReturn(pfnProgress, VERR_INVALID_POINTER);
    305305    AssertMsgReturn(!(fFlags & ~RTFILECOMP_FLAGS_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
    306306

  • trunk/src/VBox/Runtime/r3/freebsd/fileaio-freebsd.cpp

    r82968 r90803  
    272272         * completion port.
    273273         */
    274         AssertMsg(VALID_PTR(pReqInt->pCtxInt),
     274        AssertMsg(RT_VALID_PTR(pReqInt->pCtxInt),
    275275                  ("Invalid state. Request was canceled but wasn't submitted\n"));
    276276

  • trunk/src/VBox/Runtime/r3/os2/serialport-os2.cpp

    r82968 r90803  
    271271{
    272272    AssertPtrReturn(phSerialPort, VERR_INVALID_POINTER);
    273     AssertReturn(VALID_PTR(pszPortAddress) && *pszPortAddress != '\0', VERR_INVALID_PARAMETER);
     273    AssertPtrReturn(pszPortAddress, VERR_INVALID_POINTER);
     274    AssertReturn(*pszPortAddress != '\0', VERR_INVALID_PARAMETER);
    274275    AssertReturn(!(fFlags & ~RTSERIALPORT_OPEN_F_VALID_MASK), VERR_INVALID_PARAMETER);
    275276    AssertReturn((fFlags & RTSERIALPORT_OPEN_F_READ) || (fFlags & RTSERIALPORT_OPEN_F_WRITE),

  • trunk/src/VBox/Runtime/r3/posix/RTFileSetAllocationSize-posix.cpp

    r82968 r90803  
    5959    int rc = VINF_SUCCESS;
    6060    PFNPOSIXFALLOCATE pfnPosixFAllocate = (PFNPOSIXFALLOCATE)(uintptr_t)dlsym(RTLD_DEFAULT, "posix_fallocate");
    61     if (VALID_PTR(pfnPosixFAllocate))
     61    if (RT_VALID_PTR(pfnPosixFAllocate))
    6262    {
    6363        int rcPosix = pfnPosixFAllocate(RTFileToNative(hFile), 0, cbSize);

  • trunk/src/VBox/Runtime/r3/posix/fileaio-posix.cpp

    r82968 r90803  
    485485         * Notify the waiting thread that the request was canceled.
    486486         */
    487         AssertMsg(VALID_PTR(pCtxInt),
    488                   ("Invalid state. Request was canceled but wasn't submitted\n"));
     487        AssertMsg(RT_VALID_PTR(pCtxInt), ("Invalid state. Request was canceled but wasn't submitted\n"));
    489488
    490489        Assert(!pCtxInt->pReqToCancel);

  • trunk/src/VBox/Runtime/r3/posix/serialport-posix.cpp

    r87873 r90803  
    698698{
    699699    AssertPtrReturn(phSerialPort, VERR_INVALID_POINTER);
    700     AssertReturn(VALID_PTR(pszPortAddress) && *pszPortAddress != '\0', VERR_INVALID_PARAMETER);
     700    AssertPtrReturn(pszPortAddress, VERR_INVALID_POINTER);
     701    AssertReturn(*pszPortAddress != '\0', VERR_INVALID_PARAMETER);
    701702    AssertReturn(!(fFlags & ~RTSERIALPORT_OPEN_F_VALID_MASK), VERR_INVALID_PARAMETER);
    702703    AssertReturn((fFlags & RTSERIALPORT_OPEN_F_READ) || (fFlags & RTSERIALPORT_OPEN_F_WRITE),

  • trunk/src/VBox/Runtime/r3/posix/timer-posix.cpp

    r89679 r90803  
    379379                PRTTIMER pTimer = (PRTTIMER)SigInfo.si_value.sival_ptr;
    380380                AssertPtr(pTimer);
    381                 if (RT_UNLIKELY(    !VALID_PTR(pTimer)
     381                if (RT_UNLIKELY(    !RT_VALID_PTR(pTimer)
    382382                                ||  ASMAtomicUoReadU8(&pTimer->fSuspended)
    383383                                ||  ASMAtomicUoReadU8(&pTimer->fDestroyed)

  • trunk/src/VBox/Runtime/testcase/tstRTGetOpt.cpp

    r82968 r90803  
    7373        CHECK2(rcGetOpt == (chRet), ("got %d, expected %d\n", rcGetOpt, (chRet))); \
    7474        CHECK2(GetState.iNext == (iInc) + iPrev, ("iNext=%d expected %d\n", GetState.iNext, (iInc) + iPrev)); \
    75         CHECK2(VALID_PTR(Val.psz) && !strcmp(Val.psz, (str)), ("got %s, expected %s\n", Val.psz, (str))); \
     75        CHECK2(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, (str)), ("got %s, expected %s\n", Val.psz, (str))); \
    7676        GetState.iNext = (iInc) + iPrev; \
    7777    } while (0)
    … …  
    207207
    208208    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 2);
    209     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string1"));
    210     CHECK(GetState.uIndex == UINT32_MAX);
    211     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    212     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string2"));
    213     CHECK(GetState.uIndex == UINT32_MAX);
    214     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    215     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string3"));
    216     CHECK(GetState.uIndex == UINT32_MAX);
    217     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    218     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string4"));
    219     CHECK(GetState.uIndex == UINT32_MAX);
    220     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    221     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
    222     CHECK(GetState.uIndex == UINT32_MAX);
    223     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    224     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
     209    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string1"));
     210    CHECK(GetState.uIndex == UINT32_MAX);
     211    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     212    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string2"));
     213    CHECK(GetState.uIndex == UINT32_MAX);
     214    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     215    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string3"));
     216    CHECK(GetState.uIndex == UINT32_MAX);
     217    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     218    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string4"));
     219    CHECK(GetState.uIndex == UINT32_MAX);
     220    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     221    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
     222    CHECK(GetState.uIndex == UINT32_MAX);
     223    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     224    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
    225225    CHECK(GetState.uIndex == UINT32_MAX);
    226226    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 2);
    227     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string5"));
    228     CHECK(GetState.uIndex == UINT32_MAX);
    229     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    230     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string6"));
    231     CHECK(GetState.uIndex == UINT32_MAX);
    232     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    233     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string7"));
    234     CHECK(GetState.uIndex == UINT32_MAX);
    235     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    236     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
    237     CHECK(GetState.uIndex == UINT32_MAX);
    238     CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
    239     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
     227    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string5"));
     228    CHECK(GetState.uIndex == UINT32_MAX);
     229    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     230    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string6"));
     231    CHECK(GetState.uIndex == UINT32_MAX);
     232    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     233    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string7"));
     234    CHECK(GetState.uIndex == UINT32_MAX);
     235    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     236    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
     237    CHECK(GetState.uIndex == UINT32_MAX);
     238    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
     239    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
    240240    CHECK(GetState.uIndex == UINT32_MAX);
    241241
    … …  
    270270    CHECK_pDef(s_aOpts2, 5);
    271271    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 386, 2);
    272     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "myvm"));
     272    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "myvm"));
    273273
    274274    /* no-dash options */
    … …  
    276276    CHECK_pDef(s_aOpts2, 7);
    277277    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 388, 2);
    278     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string9"));
     278    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string9"));
    279279
    280280    /* non-option, option, non-option  */
    … …  
    319319    RTTestSub(hTest, "RTGetOpt - Option w/ Index");
    320320    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 2);
    321     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string10"));
     321    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string10"));
    322322    CHECK(GetState.uIndex == 786);
    323323
    324324    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
    325     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string11"));
     325    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string11"));
    326326    CHECK(GetState.uIndex == 786);
    327327
    328328    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
    329     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string12"));
     329    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string12"));
    330330    CHECK(GetState.uIndex == 786);
    331331
    332332    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 2);
    333     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string13"));
     333    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string13"));
    334334    CHECK(GetState.uIndex == 687);
    335335
    336336    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
    337     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string14"));
     337    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string14"));
    338338    CHECK(GetState.uIndex == 687);
    339339
    340340    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
    341     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string15"));
     341    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "string15"));
    342342    CHECK(GetState.uIndex == 687);
    343343
    344344    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
    345     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
     345    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
    346346    CHECK(GetState.uIndex == 688);
    347347
    348348    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
    349     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
     349    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
    350350    CHECK(GetState.uIndex == 689);
    351351
    … …  
    372372    RTTestSub(hTest, "RTGetOptFetchValue");
    373373    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 405, 2);
    374     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "firstvalue"));
     374    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "firstvalue"));
    375375    CHECK(GetState.uIndex == UINT32_MAX);
    376376    CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1);
    377     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "secondvalue"));
     377    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "secondvalue"));
    378378    CHECK(GetState.uIndex == UINT32_MAX);
    379379
    380380    CHECK_GETOPT(RTGetOpt(&GetState, &Val), 405, 1);
    381     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "firstvalue"));
     381    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "firstvalue"));
    382382    CHECK(GetState.uIndex == UINT32_MAX);
    383383    CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1);
    384     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "secondvalue"));
     384    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "secondvalue"));
    385385    CHECK(GetState.uIndex == UINT32_MAX);
    386386
    … …  
    406406    CHECK(GetState.uIndex == UINT32_MAX);
    407407    CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1);
    408     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "thirdvalue"));
     408    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "thirdvalue"));
    409409    CHECK(GetState.uIndex == UINT32_MAX);
    410410
    … …  
    416416    CHECK(!Val.f);
    417417    CHECK_GETOPT(RTGetOpt(&GetState, &Val), VERR_GETOPT_UNKNOWN_OPTION, 2);
    418     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "invalid"));
     418    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "invalid"));
    419419
    420420    /* bool on/off with indexed argument */
    … …  
    426426    CHECK(GetState.uIndex == 7);
    427427    CHECK_GETOPT(RTGetOpt(&GetState, &Val), VERR_GETOPT_UNKNOWN_OPTION, 2);
    428     CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "invalid"));
     428    CHECK(RT_VALID_PTR(Val.psz) && !strcmp(Val.psz, "invalid"));
    429429
    430430    /* standard options. */

  • trunk/src/VBox/Runtime/testcase/tstRTR0Common.h

    r82968 r90803  
    5656    do \
    5757    { \
    58         if (!VALID_PTR(pReqHdr)) \
     58        if (!RT_VALID_PTR(pReqHdr)) \
    5959            return VERR_INVALID_PARAMETER; \
    6060        \

  • trunk/src/VBox/Runtime/testcase/tstRTR0DbgKrnlInfo.cpp

    r82968 r90803  
    5555    if (u64Arg)
    5656        return VERR_INVALID_PARAMETER;
    57     if (!VALID_PTR(pReqHdr))
     57    if (!RT_VALID_PTR(pReqHdr))
    5858        return VERR_INVALID_PARAMETER;
    5959    char   *pszErr = (char *)(pReqHdr + 1);

  • trunk/src/VBox/Runtime/testcase/tstRTR0MemUserKernel.cpp

    r82968 r90803  
    5252{
    5353    NOREF(pSession);
    54     if (!VALID_PTR(pReqHdr))
     54    if (!RT_VALID_PTR(pReqHdr))
    5555        return VERR_INVALID_PARAMETER;
    5656    char   *pszErr = (char *)(pReqHdr + 1);

  • trunk/src/VBox/Runtime/testcase/tstRTR0SemMutex.cpp

    r82968 r90803  
    5959{
    6060    NOREF(pSession);
    61     if (!VALID_PTR(pReqHdr))
     61    if (!RT_VALID_PTR(pReqHdr))
    6262        return VERR_INVALID_PARAMETER;
    6363    char   *pszErr = (char *)(pReqHdr + 1);

  • trunk/src/VBox/Runtime/testcase/tstRTR0ThreadPreemption.cpp

    r82968 r90803  
    168168    if (u64Arg)
    169169        return VERR_INVALID_PARAMETER;
    170     if (!VALID_PTR(pReqHdr))
     170    if (!RT_VALID_PTR(pReqHdr))
    171171        return VERR_INVALID_PARAMETER;
    172172    char   *pszErr = (char *)(pReqHdr + 1);

  • trunk/src/VBox/Runtime/testcase/tstRTSort.cpp

    r86382 r90803  
    5454    uint32_t const *pu32Element1 = (uint32_t const *)pvElement1;
    5555    uint32_t const *pu32Element2 = (uint32_t const *)pvElement2;
    56     RTTESTI_CHECK(VALID_PTR(pData) && pData->cElements <= RT_ELEMENTS(pData->aValues));
     56    RTTESTI_CHECK(RT_VALID_PTR(pData) && pData->cElements <= RT_ELEMENTS(pData->aValues));
    5757    RTTESTI_CHECK((uintptr_t)(pu32Element1 - &pData->aValues[0]) < pData->cElements);
    5858    RTTESTI_CHECK((uintptr_t)(pu32Element2 - &pData->aValues[0]) < pData->cElements);
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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