Double linked list structure

// Double linked list structure. Can be used as either a list head, or as link words.

// @struct USBH_DLIST |
//   The USBH_DLIST structure is the link element of the double linked list. It is used as either a list head, or as link entry.
// @field  struct tDLIST * | Flink |
//   Pointer to the successor (forward link).
// @field  struct tDLIST * | pPrev |
//   Pointer to the predecessor (backward link).
// @comm By means of such elements any structures may be handled as a double linked list. The USBH_DLIST structure is to be inserted
//   into the structure which is to be handled. A pointer to the original structure can be obtained by means of the macro <f STRUCT_BASE_POINTER>.
11 typedef struct USBH_DLIST USBH_DLIST;
12 struct USBH_DLIST {
13   USBH_DLIST * pNext;
14   USBH_DLIST * pPrev;
15 };

void         USBH_DLIST_Append     (USBH_DLIST * ListHead, USBH_DLIST * List);
void         USBH_DLIST_InsertTail (USBH_DLIST * ListHead, USBH_DLIST * Entry);
void         USBH_DLIST_InsertHead (USBH_DLIST * ListHead, USBH_DLIST * Entry);
void         USBH_DLIST_InsertEntry(USBH_DLIST * Entry,    USBH_DLIST * NewEntry);
void         USBH_DLIST_RemoveTail (USBH_DLIST * ListHead, USBH_DLIST ** Entry);
void         USBH_DLIST_RemoveHead (USBH_DLIST * ListHead, USBH_DLIST ** Entry);
void         USBH_DLIST_RemoveEntry(USBH_DLIST * Entry);
USBH_DLIST * USBH_DLIST_GetPrev    (USBH_DLIST * Entry);
USBH_DLIST * USBH_DLIST_GetNext    (USBH_DLIST * Entry);
int          USBH_DLIST_IsEmpty    (USBH_DLIST * ListHead);
void         USBH_DLIST_Init       (USBH_DLIST * ListHead);


/*********************************************************************
*
*       USBH_DLIST
*/
34 typedef struct USBH_DLIST_ITEM {
35   struct USBH_DLIST_ITEM * pNext;
36   struct USBH_DLIST_ITEM * pPrev;
37 } USBH_DLIST_ITEM;
38 
typedef struct {
  struct USBH_DLIST_ITEM * pFirst;
  int NumItems;
} USBH_DLIST_HEAD;

void USBH_DLIST_Remove(USBH_DLIST_HEAD * pHead, USBH_DLIST_ITEM * pItem);
void USBH_DLIST_Add   (USBH_DLIST_HEAD * pHead, USBH_DLIST_ITEM * pNew);

typedef struct USBH_DLIST USBH_DLIST;
struct USBH_DLIST
{
  USBH_DLIST * pNext;
  USBH_DLIST * pPrev;
};

// USBH_DLIST_Init
//     STR     R0, [R0,#4]
//     STR     R0, [R0]
//     BX      LR
void USBH_DLIST_Init(USBH_DLIST * ListHead)
{
  ListHead->pPrev = ListHead;
  ListHead->pNext = ListHead;
}

// USBH_DLIST_Append
//     LDR     R2, [R0,#4]
//     STR     R1, [R2]
//     LDR     R3, [R1,#4]
//     STR     R0, [R3]
//     LDR     R3, [R1,#4]
//     STR     R3, [R0,#4]
//     STR     R2, [R1,#4]
//     BX      LR

//  /---<<<<<<<<<<<<<<<<<<<<<<pNext---\         /---<<<<<<<<<<<<<<<<<<pNext---\
//  ListHead <----> 0 <----> 1 <----> N         List <----> 0 <----> 1 <----> N
//  pPrev >>>>>>>>>>>>>>>>>>>>>>>>>---/         pPrev >>>>>>>>>>>>>>>>>>>>>---/
//
//  /---<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<pNext---\
//  ListHead <----> 0 <----> 1 <----> N <---->  List <----> 0 <----> 1 <----> N
//  pPrev >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>---/
void USBH_DLIST_Append(USBH_DLIST * ListHead, USBH_DLIST * List)
{
  ListHead->pPrev->pNext = List;
  List->pPrev->pNext = ListHead;
  ListHead->pPrev = List->pPrev;
  List->pPrev = ListHead->pPrev;
}

// USBH_DLIST_IsEmpty
//     LDR     R1, [R0]
//     CMP     R1, R0
//     ITE EQ
//     MOVEQ   R0, #1
//     MOVNE   R0, #0
//     BX      LR
int USBH_DLIST_IsEmpty(USBH_DLIST * ListHead)
{
  return ListHead == ListHead->pNext;
}

// USBH_DLIST_GetNext          USBH_DLIST_GetPrev
//     LDR     R0, [R0]            LDR     R0, [R0,#4]
//     BX      LR                  BX      LR
USBH_DLIST * USBH_DLIST_GetNext(USBH_DLIST * Entry)
{
  return Entry->pNext;
}
USBH_DLIST * USBH_DLIST_GetPrev(USBH_DLIST * Entry)
{
  return Entry->pPrev;
}

//                             USBH_DLIST_RemoveHead     USBH_DLIST_RemoveTail
//                                LDR     R0, [R0]          LDR     R0, [R0,#4]
// USBH_DLIST_RemoveEntry         STR     R0, [R1]          STR     R0, [R1]
//
//    LDRD.W  R1, R2, [R0]        LDRD.W  R1, R2, [R0]      LDRD.W  R1, R2, [R0]
//    STR     R1, [R2]            STR     R1, [R2]          STR     R1, [R2]
//
//    LDRD.W  R1, R2, [R0]        LDRD.W  R1, R2, [R0]      LDRD.W  R1, R2, [R0]
//    STR     R2, [R1,#4]         STR     R2, [R1,#4]       STR     R2, [R1,#4]
//
//    STR     R0, [R0,#4]         STR     R0, [R0,#4]       STR     R0, [R0,#4]
//    STR     R0, [R0]            STR     R0, [R0]          STR     R0, [R0]
//    BX      LR                  BX      LR                BX      LR

// pPrev [ Entry ] pNext ---> pPrev pNext
void USBH_DLIST_RemoveEntry(USBH_DLIST * Entry)
{
  Entry->pPrev->pNext = Entry->pNext;
  Entry->pNext->pPrev = Entry->pPrev;
  //USBH_DLIST_Init( Entry );
  Entry->pPrev = Entry;
  Entry->pNext = Entry;
}


void USBH_DLIST_RemoveHead(USBH_DLIST * ListHead, USBH_DLIST ** Entry)
{
  (*Entry)->pNext = ListHead->pNext;
  USBH_DLIST_RemoveEntry( ListHead->pNext );
}


void USBH_DLIST_RemoveTail(USBH_DLIST * ListHead, USBH_DLIST ** Entry)
{
  (*Entry)->pNext = ListHead->pPrev;
  USBH_DLIST_RemoveEntry( ListHead->pPrev );
}

//                                                       USBH_DLIST_InsertTail
// USBH_DLIST_InsertEntry      USBH_DLIST_InsertHead         LDR     R0, [R0,#4]
//     LDR     R2, [R0]            LDR     R2, [R0]          LDR     R2, [R0]
//     STRD.W  R2, R0, [R1]        STRD.W  R2, R0, [R1]      STRD.W  R2, R0, [R1]
//     LDR     R2, [R0]            LDR     R2, [R0]          LDR     R2, [R0]
//     STR     R1, [R2,#4]         STR     R1, [R2,#4]       STR     R1, [R2,#4]
//     STR     R1, [R0]            STR     R1, [R0]          STR     R1, [R0]
//     BX      LR                  BX      LR                BX      LR

void USBH_DLIST_InsertEntry(USBH_DLIST * Entry, USBH_DLIST * NewEntry)
{
  NewEntry->pNext = Entry->pNext;
  NewEntry->pPrev = Entry;

  Entry->pNext->pPrev = NewEntry;
  Entry->pNext = NewEntry;
}

void USBH_DLIST_InsertHead(USBH_DLIST * ListHead, USBH_DLIST * Entry)
{
  USBH_DLIST_InsertEntry( ListHead, Entry );
}

void USBH_DLIST_InsertTail(USBH_DLIST * ListHead, USBH_DLIST * Entry)
{
  USBH_DLIST_InsertEntry( ListHead->pPrev, Entry );
}

// -------------------------------------------------------------------------------
 typedef struct USBH_DLIST_ITEM {
   struct USBH_DLIST_ITEM * pNext;
   struct USBH_DLIST_ITEM * pPrev;
 } USBH_DLIST_ITEM;

 typedef struct {
   struct USBH_DLIST_ITEM * pFirst;
   int NumItems;
 } USBH_DLIST_HEAD;


void USBH_DLIST_InitHead(USBH_DLIST_HEAD * pHead)
{
  pHead->pFirst = 0;
  pHead->NumItems = 0;
}

// USBH_DLIST_Add
//     MOVS    R2, #0
//     STR     R2, [R1,#4]   ; pNew->pPrev = 0;
//
//     LDR     R2, [R0]
//     STR     R2, [R1]      ; pNew->pNext = pHead->pFirst;
//
//     LDR     R2, [R0]
//     CMP     R2, #0
//     IT NE                 ; pHead->pFirst != 0
//     STRNE   R1, [R2,#4]   ; pHead->pFirst->pPrev = pNew;
//
//     STR     R1, [R0]      ; pHead->pFirst = pNew;
//     BX      LR
//
//  pFirst --> pNew
//  0 <------- pNew ----> 0
//
//  0 <------- pNew ----> pOld
//  pNew <---- pOld ----> 0
//
void USBH_DLIST_Add(USBH_DLIST_HEAD * pHead, USBH_DLIST_ITEM * pNew)
{
  pNew->pPrev = 0;
  pNew->pNext = 0;
  if (pHead->pFirst != 0)
  {
    pNew->pNext = pHead->pFirst;
    pHead->pFirst->pPrev = pNew;
  }
  pHead->pFirst = pNew;
  //pHead->NumItems++;
}

// USBH_DLIST_Remove
//     LDR     R3, [R0]
//     LDR     R2, [R1]
//
//     CMP     R3, R1
//     IT NE
//     LDRNE   R0, [R1,#4]
//     STR     R2, [R0]
//
//     LDR     R0, [R1]
//     CMP     R0, #0
//     ITT NE
//     LDRNE   R1, [R1,#4]
//     STRNE   R1, [R0,#4]
//
//     BX      LR

//
void USBH_DLIST_Remove(USBH_DLIST_HEAD * pHead, USBH_DLIST_ITEM * pItem)
{
  if (pHead->pFirst == pItem)
    pHead->pFirst->pNext = pItem->pNext;
  else
    pItem->pPrev->pNext = pItem->pNext;

  if (pItem->pNext != 0)
  {
    pHead->NumItems = (int)pItem->pPrev;
  }
}