VirtualBox

Changeset 55487 in vbox


Ignore:
Timestamp:
Apr 28, 2015 3:39:07 PM (9 years ago)
Author:
vboxsync
Message:

iprt: Cloned iprt/list.h and morphed it into a 32-bit offset based affair suitable for cross context lists.

File:
1 copied

Legend:

Unmodified
Added
Removed

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

    r55474 r55487  
    11/** @file
    2  * IPRT - Generic Doubly Linked List.
     2 * IPRT - Generic Doubly Linked List, using 32-bit offset instead of pointers.
    33 */
    44
    55/*
    6  * Copyright (C) 2010-2011 Oracle Corporation
     6 * Copyright (C) 2010-2015 Oracle Corporation
    77 *
    88 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2424 */
    2525
    26 #ifndef ___iprt_list_h
    27 #define ___iprt_list_h
     26#ifndef ___iprt_list_off32_h
     27#define ___iprt_list_off32_h
    2828
    2929#include <iprt/types.h>
    3030
    31 /** @defgroup grp_rt_list    RTList - Generic Doubly Linked List
     31/* @defgroup grp_rt_list_off32 RTListOff32 - Generic Doubly Linked List based on 32-bit offset.
    3232 * @ingroup grp_rt
    3333 *
    34  * The list implementation is circular without any type wise distintion between
    35  * the list and its nodes.  This can be confusing since the list head usually
    36  * resides in a different structure than the nodes, so care must be taken when
    37  * walking the list.
     34 * This is the same as @link grp_rt_list, except that instead of pointers we
     35 * use 32-bit offsets.  The list implementation is circular, with a dummy node
     36 * as anchor.  Be careful with the dummy node when walking the list.
    3837 *
    3938 * @{
    … …  
    4544 * A list node of a doubly linked list.
    4645 */
    47 typedef struct RTLISTNODE
    48 {
    49     /** Pointer to the next list node. */
    50     struct RTLISTNODE *pNext;
    51     /** Pointer to the previous list node. */
    52     struct RTLISTNODE *pPrev;
    53 } RTLISTNODE;
     46typedef struct RTLISTOFF32NODE
     47{
     48    /** Offset to the next list node, relative to this structure. */
     49    int32_t offNext;
     50    /** Offset to the previous list node, relative to this structure. */
     51    int32_t offPrev;
     52} RTLISTOFF32NODE;
    5453/** Pointer to a list node. */
    55 typedef RTLISTNODE *PRTLISTNODE;
     54typedef RTLISTOFF32NODE *PRTLISTOFF32NODE;
    5655/** Pointer to a const list node. */
    57 typedef RTLISTNODE const *PCRTLISTNODE;
     56typedef RTLISTOFF32NODE const *PCRTLISTOFF32NODE;
    5857/** Pointer to a list node pointer. */
    59 typedef PRTLISTNODE *PPRTLISTNODE;
     58typedef PRTLISTOFF32NODE *PPRTLISTOFF32NODE;
    6059
    6160/** The anchor (head/tail) of a doubly linked list.
    6261 *
    63  * @remarks Please use this instead of RTLISTNODE to indicate a list
     62 * @remarks Please always use this instead of RTLISTOFF32NODE to indicate a list
    6463 *          head/tail.  It makes the code so much easier to read.  Also,
    65  *          always mention the actual list node type(s) in the comment.  */
    66 typedef RTLISTNODE RTLISTANCHOR;
     64 *          always mention the actual list node type(s) in the comment.
     65 * @remarks Must be allocated in a similar manner as the nodes, so as to
     66 *          keep it within a 32-bit distance from them.
     67 */
     68typedef RTLISTOFF32NODE RTLISTOFF32ANCHOR;
    6769/** Pointer to a doubly linked list anchor. */
    68 typedef RTLISTANCHOR *PRTLISTANCHOR;
     70typedef RTLISTOFF32ANCHOR *PRTLISTOFF32ANCHOR;
    6971/** Pointer to a const doubly linked list anchor. */
    70 typedef RTLISTANCHOR const *PCRTLISTANCHOR;
     72typedef RTLISTOFF32ANCHOR const *PCRTLISTOFF32ANCHOR;
    7173
    7274
    … …  
    7678 * @param   pList               Pointer to an unitialised list.
    7779 */
    78 DECLINLINE(void) RTListInit(PRTLISTNODE pList)
    79 {
    80     pList->pNext = pList;
    81     pList->pPrev = pList;
    82 }
     80DECLINLINE(void) RTListOff32Init(PRTLISTOFF32NODE pList)
     81{
     82    pList->offNext = 0;
     83    pList->offPrev = 0;
     84}
     85
     86/**
     87 * Internal macro for converting an offset to a pointer.
     88 * @returns PRTLISTOFF32NODE
     89 * @param   a_pNode             The node the offset is relative to.
     90 * @param   a_off               The offset.
     91 */
     92#define RTLISTOFF32_TO_PTR(a_pNode, a_off)          ((PRTLISTOFF32NODE)((intptr_t)(a_pNode) + (a_off)))
     93
     94/**
     95 * Internal macro for getting the pointer to the next node.
     96 * @returns PRTLISTOFF32NODE
     97 * @param   a_pNode             The node the offset is relative to.
     98 */
     99#define RTLISTOFF32_NEXT_PTR(a_pNode)               RTLISTOFF32_TO_PTR(a_pNode, (a_pNode)->offNext)
     100
     101/**
     102 * Internal macro for getting the pointer to the previous node.
     103 * @returns PRTLISTOFF32NODE
     104 * @param   a_pNode             The node the offset is relative to.
     105 */
     106#define RTLISTOFF32_PREV_PTR(a_pNode)               RTLISTOFF32_TO_PTR(a_pNode, (a_pNode)->offPrev)
     107
     108/**
     109 * Internal macro for converting an a pointer to an offset.
     110 * @returns offset
     111 * @param   a_pNode             The node the offset is relative to.
     112 * @param   a_pOtherNode        The pointer to convert.
     113 */
     114#define RTLISTOFF32_TO_OFF(a_pNode, a_pOtherNode)   ((int32_t)((intptr_t)(a_pOtherNode) - (intptr_t)(a_pNode)))
     115
     116/**
     117 * Internal macro for getting the pointer to the next node.
     118 * @returns PRTLISTOFF32NODE
     119 * @param   a_pNode             The node which offNext member should be set.
     120 * @param   a_pNewNext          Pointer to the new next node.
     121 */
     122#define RTLISTOFF32_SET_NEXT_PTR(a_pNode, a_pNewNext) \
     123    do { (a_pNode)->offNext = RTLISTOFF32_TO_OFF(a_pNode, a_pNewNext); } while (0)
     124
     125/**
     126 * Internal macro for getting the pointer to the previous node.
     127 * @returns PRTLISTOFF32NODE
     128 * @param   a_pNode             The node which offPrev member should be set.
     129 * @param   a_pNewPrev          Pointer to the new previous node.
     130 */
     131#define RTLISTOFF32_SET_PREV_PTR(a_pNode, a_pNewPrev) \
     132    do { (a_pNode)->offPrev = RTLISTOFF32_TO_OFF(a_pNode, a_pNewPrev); } while (0)
     133
     134
    83135
    84136/**
    … …  
    88140 * @param   pNode               The node to append.
    89141 */
    90 DECLINLINE(void) RTListAppend(PRTLISTNODE pList, PRTLISTNODE pNode)
    91 {
    92     pList->pPrev->pNext = pNode;
    93     pNode->pPrev        = pList->pPrev;
    94     pNode->pNext        = pList;
    95     pList->pPrev        = pNode;
     142DECLINLINE(void) RTListOff32Append(PRTLISTOFF32NODE pList, PRTLISTOFF32NODE pNode)
     143{
     144    PRTLISTOFF32NODE pLast = RTLISTOFF32_PREV_PTR(pList);
     145    RTLISTOFF32_SET_NEXT_PTR(pLast, pNode);
     146    RTLISTOFF32_SET_PREV_PTR(pNode, pLast);
     147    RTLISTOFF32_SET_NEXT_PTR(pNode, pList);
     148    RTLISTOFF32_SET_PREV_PTR(pList, pNode);
    96149}
    97150
    … …  
    102155 * @param   pNode               The node to prepend.
    103156 */
    104 DECLINLINE(void) RTListPrepend(PRTLISTNODE pList, PRTLISTNODE pNode)
    105 {
    106     pList->pNext->pPrev = pNode;
    107     pNode->pNext        = pList->pNext;
    108     pNode->pPrev        = pList;
    109     pList->pNext        = pNode;
     157DECLINLINE(void) RTListOff32Prepend(PRTLISTOFF32NODE pList, PRTLISTOFF32NODE pNode)
     158{
     159    PRTLISTOFF32NODE pFirst = RTLISTOFF32_NEXT_PTR(pList);
     160    RTLISTOFF32_SET_PREV_PTR(pFirst, pNode);
     161    RTLISTOFF32_SET_NEXT_PTR(pNode, pFirst);
     162    RTLISTOFF32_SET_PREV_PTR(pNode, pList);
     163    RTLISTOFF32_SET_NEXT_PTR(pList, pNode);
    110164}
    111165
    … …  
    116170 * @param   pNewNode            The node to insert.
    117171 */
    118 DECLINLINE(void) RTListNodeInsertAfter(PRTLISTNODE pCurNode, PRTLISTNODE pNewNode)
    119 {
    120     RTListPrepend(pCurNode, pNewNode);
     172DECLINLINE(void) RTListOff32NodeInsertAfter(PRTLISTOFF32NODE pCurNode, PRTLISTOFF32NODE pNewNode)
     173{
     174    RTListOff32Prepend(pCurNode, pNewNode);
    121175}
    122176
    … …  
    127181 * @param   pNewNode            The node to insert.
    128182 */
    129 DECLINLINE(void) RTListNodeInsertBefore(PRTLISTNODE pCurNode, PRTLISTNODE pNewNode)
    130 {
    131     RTListAppend(pCurNode, pNewNode);
     183DECLINLINE(void) RTListOff32NodeInsertBefore(PRTLISTOFF32NODE pCurNode, PRTLISTOFF32NODE pNewNode)
     184{
     185    RTListOff32Append(pCurNode, pNewNode);
    132186}
    133187
    … …  
    137191 * @param   pNode               The node to remove.
    138192 */
    139 DECLINLINE(void) RTListNodeRemove(PRTLISTNODE pNode)
    140 {
    141     PRTLISTNODE pPrev = pNode->pPrev;
    142     PRTLISTNODE pNext = pNode->pNext;
    143 
    144     pPrev->pNext = pNext;
    145     pNext->pPrev = pPrev;
     193DECLINLINE(void) RTListOff32NodeRemove(PRTLISTOFF32NODE pNode)
     194{
     195    PRTLISTOFF32NODE pPrev = RTLISTOFF32_PREV_PTR(pNode);
     196    PRTLISTOFF32NODE pNext = RTLISTOFF32_NEXT_PTR(pNode);
     197
     198    RTLISTOFF32_SET_NEXT_PTR(pPrev, pNext);
     199    RTLISTOFF32_SET_PREV_PTR(pNext, pPrev);
    146200
    147201    /* poison */
    148     pNode->pNext = NULL;
    149     pNode->pPrev = NULL;
     202    pNode->offNext = INT32_MAX / 2;
     203    pNode->offPrev = INT32_MAX / 2;
    150204}
    151205
    … …  
    159213 * @param   pNode               The node to check.
    160214 */
    161 #define RTListNodeIsLast(pList, pNode)  ((pNode)->pNext == (pList))
     215#define RTListOff32NodeIsLast(pList, pNode)  (RTLISTOFF32_NEXT_PTR(pNode) == (pList))
    162216
    163217/**
    … …  
    170224 * @param   pNode               The node to check.
    171225 */
    172 #define RTListNodeIsFirst(pList, pNode) ((pNode)->pPrev == (pList))
     226#define RTListOff32NodeIsFirst(pList, pNode) (RTLISTOFF32_PREV_PTR(pNode) == (pList))
    173227
    174228/**
    … …  
    180234 * @param   pList               The list.
    181235 * @param   pNodeStruct         The node structure to check.  Typically
    182  *                              something obtained from RTListNodeGetNext() or
    183  *                              RTListNodeGetPrev().  This is NOT a PRTLISTNODE
    184  *                              but something that contains a RTLISTNODE member!
    185  * @param   Type                Structure the list node is a member of.
    186  * @param   Member              The list node member.
    187  */
    188 #define RTListNodeIsDummy(pList, pNode, Type, Member) \
     236 *                              something obtained from RTListOff32NodeGetNext()
     237 *                              or RTListOff32NodeGetPrev().  This is NOT a
     238 *                              PRTLISTOFF32NODE but something that contains a
     239 *                              RTLISTOFF32NODE member!
     240 * @param   Type                Structure the list node is a member of.
     241 * @param   Member              The list node member.
     242 */
     243#define RTListOff32NodeIsDummy(pList, pNode, Type, Member) \
    189244         ( (pNode) == RT_FROM_MEMBER((pList), Type, Member) )
    190 /** @copydoc RTListNodeIsDummy */
    191 #define RTListNodeIsDummyCpp(pList, pNode, Type, Member) \
     245/** @copydoc RTListOff32NodeIsDummy */
     246#define RTListOff32NodeIsDummyCpp(pList, pNode, Type, Member) \
    192247         ( (pNode) == RT_FROM_CPP_MEMBER((pList), Type, Member) )
    193248
    … …  
    200255 * @param   pList               The list to check.
    201256 */
    202 #define RTListIsEmpty(pList)            ((pList)->pPrev == (pList))
     257#define RTListOff32IsEmpty(pList)   ((pList)->offNext == 0)
    203258
    204259/**
    … …  
    211266 * @param   Member              The list node member.
    212267 */
    213 #define RTListNodeGetNext(pCurNode, Type, Member) \
    214     RT_FROM_MEMBER((pCurNode)->pNext, Type, Member)
    215 /** @copydoc RTListNodeGetNext */
    216 #define RTListNodeGetNextCpp(pCurNode, Type, Member) \
    217     RT_FROM_CPP_MEMBER((pCurNode)->pNext, Type, Member)
     268#define RTListOff32NodeGetNext(pCurNode, Type, Member) \
     269    RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(pCurNode), Type, Member)
     270/** @copydoc RTListOff32NodeGetNext */
     271#define RTListOff32NodeGetNextCpp(pCurNode, Type, Member) \
     272    RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(pCurNode), Type, Member)
    218273
    219274/**
    … …  
    226281 * @param   Member              The list node member.
    227282 */
    228 #define RTListNodeGetPrev(pCurNode, Type, Member) \
    229     RT_FROM_MEMBER((pCurNode)->pPrev, Type, Member)
    230 /** @copydoc RTListNodeGetPrev */
    231 #define RTListNodeGetPrevCpp(pCurNode, Type, Member) \
    232     RT_FROM_CPP_MEMBER((pCurNode)->pPrev, Type, Member)
     283#define RTListOff32NodeGetPrev(pCurNode, Type, Member) \
     284    RT_FROM_MEMBER(RTLISTOFF32_PREV_PTR(pCurNode), Type, Member)
     285/** @copydoc RTListOff32NodeGetPrev */
     286#define RTListOff32NodeGetPrevCpp(pCurNode, Type, Member) \
     287    RT_FROM_CPP_MEMBER(RTLISTOFF32_PREV_PTR(pCurNode), Type, Member)
    233288
    234289/**
    … …  
    242297 * @param   Member              The list node member.
    243298 */
    244 #define RTListGetFirst(pList, Type, Member) \
    245     (!RTListIsEmpty(pList) ? RTListNodeGetNext(pList, Type, Member) : NULL)
    246 /** @copydoc RTListGetFirst */
    247 #define RTListGetFirstCpp(pList, Type, Member) \
    248     (!RTListIsEmpty(pList) ? RTListNodeGetNextCpp(pList, Type, Member) : NULL)
     299#define RTListOff32GetFirst(pList, Type, Member) \
     300    ((pList)->offNext != 0 ? RTListOff32NodeGetNext(pList, Type, Member) : NULL)
     301/** @copydoc RTListOff32GetFirst */
     302#define RTListOff32GetFirstCpp(pList, Type, Member) \
     303    ((pList)->offNext != 0 ? RTListOff32NodeGetNextCpp(pList, Type, Member) : NULL)
    249304
    250305/**
    … …  
    258313 * @param   Member              The list node member.
    259314 */
    260 #define RTListGetLast(pList, Type, Member) \
    261     (!RTListIsEmpty(pList) ? RTListNodeGetPrev(pList, Type, Member) : NULL)
    262 /** @copydoc RTListGetLast */
    263 #define RTListGetLastCpp(pList, Type, Member) \
    264     (!RTListIsEmpty(pList) ? RTListNodeGetPrevCpp(pList, Type, Member) : NULL)
     315#define RTListOff32GetLast(pList, Type, Member) \
     316    ((pList)->offPrev != 0 ? RTListOff32NodeGetPrev(pList, Type, Member) : NULL)
     317/** @copydoc RTListOff32GetLast */
     318#define RTListOff32GetLastCpp(pList, Type, Member) \
     319    ((pList)->offPrev != 0 ? RTListOff32NodeGetPrevCpp(pList, Type, Member) : NULL)
    265320
    266321/**
    … …  
    274329 * @param   Member              The list node member.
    275330 */
    276 #define RTListGetNext(pList, pCurNode, Type, Member) \
    277     ( (pCurNode)->Member.pNext != (pList) ? RT_FROM_MEMBER((pCurNode)->Member.pNext, Type, Member) : NULL )
    278 /** @copydoc RTListGetNext */
    279 #define RTListGetNextCpp(pList, pCurNode, Type, Member) \
    280     ( (pCurNode)->Member.pNext != (pList) ? RT_FROM_CPP_MEMBER((pCurNode)->Member.pNext, Type, Member) : NULL )
     331#define RTListOff32GetNext(pList, pCurNode, Type, Member) \
     332    ( RTLISTOFF32_NEXT_PTR(&(pCurNode)->Member) != (pList) \
     333      ? RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pCurNode)->Member), Type, Member) : NULL )
     334/** @copydoc RTListOff32GetNext */
     335#define RTListOff32GetNextCpp(pList, pCurNode, Type, Member) \
     336    ( RTLISTOFF32_NEXT_PTR(&(pCurNode)->Member) != (pList) \
     337      ? RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(&(pCurNode)->Member), Type, Member) : NULL )
    281338
    282339/**
    … …  
    290347 * @param   Member              The list node member.
    291348 */
    292 #define RTListGetPrev(pList, pCurNode, Type, Member) \
    293     ( (pCurNode)->Member.pPrev != (pList) ? RT_FROM_MEMBER((pCurNode)->Member.pPrev, Type, Member) : NULL )
    294 /** @copydoc RTListGetPrev */
    295 #define RTListGetPrevCpp(pList, pCurNode, Type, Member) \
    296     ( (pCurNode)->Member.pPrev != (pList) ? RT_FROM_CPP_MEMBER((pCurNode)->Member.pPrev, Type, Member) : NULL )
     349#define RTListOff32GetPrev(pList, pCurNode, Type, Member) \
     350    ( RTLISTOFF32_PREV_PTR(&(pCurNode)->Member) != (pList) \
     351      ? RT_FROM_MEMBER(RTLISTOFF32_PREV_PTR(&(pCurNode)->Member), Type, Member) : NULL )
     352/** @copydoc RTListOff32GetPrev */
     353#define RTListOff32GetPrevCpp(pList, pCurNode, Type, Member) \
     354    ( RTLISTOFF32_PREV_PTR(&(pCurNode)->Member) != (pList) \
     355      ? RT_FROM_CPP_MEMBER(RTLISTOFF32_PREV_PTR(&(pCurNode)->Member), Type, Member) : NULL )
    297356
    298357/**
    … …  
    304363 * @param   Member              The list node member name.
    305364 */
    306 #define RTListForEach(pList, pIterator, Type, Member) \
    307     for (pIterator = RTListNodeGetNext(pList, Type, Member); \
    308          !RTListNodeIsDummy(pList, pIterator, Type, Member); \
    309          pIterator = RT_FROM_MEMBER((pIterator)->Member.pNext, Type, Member) )
    310 /** @copydoc RTListForEach */
    311 #define RTListForEachCpp(pList, pIterator, Type, Member) \
    312     for (pIterator = RTListNodeGetNextCpp(pList, Type, Member); \
    313          !RTListNodeIsDummyCpp(pList, pIterator, Type, Member); \
    314          pIterator = RT_FROM_CPP_MEMBER((pIterator)->Member.pNext, Type, Member) )
     365#define RTListOff32ForEach(pList, pIterator, Type, Member) \
     366    for (pIterator = RTListOff32NodeGetNext(pList, Type, Member); \
     367         !RTListOff32NodeIsDummy(pList, pIterator, Type, Member); \
     368         pIterator = RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
     369/** @copydoc RTListOff32ForEach */
     370#define RTListOff32ForEachCpp(pList, pIterator, Type, Member) \
     371    for (pIterator = RTListOff32NodeGetNextCpp(pList, Type, Member); \
     372         !RTListOff32NodeIsDummyCpp(pList, pIterator, Type, Member); \
     373         pIterator = RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
    315374
    316375
    … …  
    326385 * @param   Member              The list node member name.
    327386 */
    328 #define RTListForEachSafe(pList, pIterator, pIterNext, Type, Member) \
    329     for (pIterator = RTListNodeGetNext(pList, Type, Member), \
    330          pIterNext = RT_FROM_MEMBER((pIterator)->Member.pNext, Type, Member); \
    331          !RTListNodeIsDummy(pList, pIterator, Type, Member); \
     387#define RTListOff32ForEachSafe(pList, pIterator, pIterNext, Type, Member) \
     388    for (pIterator = RTListOff32NodeGetNext(pList, Type, Member), \
     389         pIterNext = RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member); \
     390         !RTListOff32NodeIsDummy(pList, pIterator, Type, Member); \
    332391         pIterator = pIterNext, \
    333          pIterNext = RT_FROM_MEMBER((pIterator)->Member.pNext, Type, Member) )
    334 /** @copydoc RTListForEachSafe */
    335 #define RTListForEachSafeCpp(pList, pIterator, pIterNext, Type, Member) \
    336     for (pIterator = RTListNodeGetNextCpp(pList, Type, Member), \
    337          pIterNext = RT_FROM_CPP_MEMBER((pIterator)->Member.pNext, Type, Member); \
    338          !RTListNodeIsDummyCpp(pList, pIterator, Type, Member); \
     392         pIterNext = RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
     393/** @copydoc RTListOff32ForEachSafe */
     394#define RTListOff32ForEachSafeCpp(pList, pIterator, pIterNext, Type, Member) \
     395    for (pIterator = RTListOff32NodeGetNextCpp(pList, Type, Member), \
     396         pIterNext = RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member); \
     397         !RTListOff32NodeIsDummyCpp(pList, pIterator, Type, Member); \
    339398         pIterator = pIterNext, \
    340          pIterNext = RT_FROM_CPP_MEMBER((pIterator)->Member.pNext, Type, Member) )
     399         pIterNext = RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
    341400
    342401
    … …  
    349408 * @param   Member              The list node member name.
    350409 */
    351 #define RTListForEachReverse(pList, pIterator, Type, Member) \
    352     for (pIterator = RTListNodeGetPrev(pList, Type, Member); \
    353          !RTListNodeIsDummy(pList, pIterator, Type, Member); \
    354          pIterator = RT_FROM_MEMBER((pIterator)->Member.pPrev, Type, Member) )
    355 /** @copydoc RTListForEachReverse */
    356 #define RTListForEachReverseCpp(pList, pIterator, Type, Member) \
    357     for (pIterator = RTListNodeGetPrevCpp(pList, Type, Member); \
    358          !RTListNodeIsDummyCpp(pList, pIterator, Type, Member); \
    359          pIterator = RT_FROM_CPP_MEMBER((pIterator)->Member.pPrev, Type, Member) )
     410#define RTListOff32ForEachReverse(pList, pIterator, Type, Member) \
     411    for (pIterator = RTListOff32NodeGetPrev(pList, Type, Member); \
     412         !RTListOff32NodeIsDummy(pList, pIterator, Type, Member); \
     413         pIterator = RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
     414/** @copydoc RTListOff32ForEachReverse */
     415#define RTListOff32ForEachReverseCpp(pList, pIterator, Type, Member) \
     416    for (pIterator = RTListOff32NodeGetPrevCpp(pList, Type, Member); \
     417         !RTListOff32NodeIsDummyCpp(pList, pIterator, Type, Member); \
     418         pIterator = RT_FROM_CPP_MEMBER(RTLISTOFF32_PREV_PTR(&(pIterator)->Member), Type, Member) )
    360419
    361420
    … …  
    370429 * @param   Member              The list node member name.
    371430 */
    372 #define RTListForEachReverseSafe(pList, pIterator, pIterPrev, Type, Member) \
    373     for (pIterator = RTListNodeGetPrev(pList, Type, Member), \
    374          pIterPrev = RT_FROM_MEMBER((pIterator)->Member.pPrev, Type, Member); \
    375          !RTListNodeIsDummy(pList, pIterator, Type, Member); \
     431#define RTListOff32ForEachReverseSafe(pList, pIterator, pIterPrev, Type, Member) \
     432    for (pIterator = RTListOff32NodeGetPrev(pList, Type, Member), \
     433         pIterPrev = RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member); \
     434         !RTListOff32NodeIsDummy(pList, pIterator, Type, Member); \
    376435         pIterator = pIterPrev, \
    377          pIterPrev = RT_FROM_MEMBER((pIterator)->Member.pPrev, Type, Member) )
    378 /** @copydoc RTListForEachReverseSafe */
    379 #define RTListForEachReverseSafeCpp(pList, pIterator, pIterPrev, Type, Member) \
    380     for (pIterator = RTListNodeGetPrevCpp(pList, Type, Member), \
    381          pIterPrev = RT_FROM_CPP_MEMBER((pIterator)->Member.pPrev, Type, Member); \
    382          !RTListNodeIsDummyCpp(pList, pIterator, Type, Member); \
     436         pIterPrev = RT_FROM_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
     437/** @copydoc RTListOff32ForEachReverseSafe */
     438#define RTListOff32ForEachReverseSafeCpp(pList, pIterator, pIterPrev, Type, Member) \
     439    for (pIterator = RTListOff32NodeGetPrevCpp(pList, Type, Member), \
     440         pIterPrev = RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member); \
     441         !RTListOff32NodeIsDummyCpp(pList, pIterator, Type, Member); \
    383442         pIterator = pIterPrev, \
    384          pIterPrev = RT_FROM_CPP_MEMBER((pIterator)->Member.pPrev, Type, Member) )
     443         pIterPrev = RT_FROM_CPP_MEMBER(RTLISTOFF32_NEXT_PTR(&(pIterator)->Member), Type, Member) )
    385444
    386445
    … …  
    391450 * @param   pListSrc            The list to move.
    392451 */
    393 DECLINLINE(void) RTListMove(PRTLISTNODE pListDst, PRTLISTNODE pListSrc)
    394 {
    395     if (!RTListIsEmpty(pListSrc))
     452DECLINLINE(void) RTListOff32Move(PRTLISTOFF32NODE pListDst, PRTLISTOFF32NODE pListSrc)
     453{
     454    if (!RTListOff32IsEmpty(pListSrc))
    396455    {
    397         pListDst->pNext = pListSrc->pNext;
    398         pListDst->pPrev = pListSrc->pPrev;
     456        PRTLISTOFF32NODE pFirst = RTLISTOFF32_NEXT_PTR(pListSrc);
     457        PRTLISTOFF32NODE pLast  = RTLISTOFF32_PREV_PTR(pListSrc);
     458
     459        RTLISTOFF32_SET_NEXT_PTR(pListDst, pFirst);
     460        RTLISTOFF32_SET_PREV_PTR(pListDst, pLast);
    399461
    400462        /* Adjust the first and last element links */
    401         pListDst->pNext->pPrev = pListDst;
    402         pListDst->pPrev->pNext = pListDst;
     463        RTLISTOFF32_SET_NEXT_PTR(pLast, pListDst);
     464        RTLISTOFF32_SET_PREV_PTR(pFirst, pListDst);
    403465
    404466        /* Finally remove the elements from the source list */
    405         RTListInit(pListSrc);
     467        RTListOff32Init(pListSrc);
    406468    }
    407469}
    … …  
    414476 * @param   pListSrc            The source list to concatenate.
    415477 */
    416 DECLINLINE(void) RTListConcatenate(PRTLISTANCHOR pListDst, PRTLISTANCHOR pListSrc)
    417 {
    418     if (!RTListIsEmpty(pListSrc))
     478DECLINLINE(void) RTListOff32Concatenate(PRTLISTOFF32ANCHOR pListDst, PRTLISTOFF32ANCHOR pListSrc)
     479{
     480    if (!RTListOff32IsEmpty(pListSrc))
    419481    {
    420         PRTLISTNODE pFirst = pListSrc->pNext;
    421         PRTLISTNODE pLast = pListSrc->pPrev;
    422 
    423         pListDst->pPrev->pNext = pFirst;
    424         pFirst->pPrev          = pListDst->pPrev;
    425         pLast->pNext           = pListDst;
    426         pListDst->pPrev        = pLast;
     482        PRTLISTOFF32NODE pFirstSrc = RTLISTOFF32_NEXT_PTR(pListSrc);
     483        PRTLISTOFF32NODE pLastSrc  = RTLISTOFF32_PREV_PTR(pListSrc);
     484        PRTLISTOFF32NODE pLastDst  = RTLISTOFF32_PREV_PTR(pListDst);
     485
     486        RTLISTOFF32_SET_NEXT_PTR(pLastDst, pFirstSrc);
     487        RTLISTOFF32_SET_PREV_PTR(pFirstSrc, pLastDst);
     488
     489        RTLISTOFF32_SET_NEXT_PTR(pLastSrc, pListDst);
     490        RTLISTOFF32_SET_PREV_PTR(pListDst, pLastSrc);
    427491
    428492        /* Finally remove the elements from the source list */
    429         RTListInit(pListSrc);
     493        RTListOff32Init(pListSrc);
    430494    }
    431495}
    … …  
    436500
    437501#endif
     502
Note: See TracChangeset for help on using the changeset viewer.

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