Router/alList.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2003 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21
  22
  23
  24 #include "alList.h"
  25 #include <windows.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29
  30 //****************************************************************************
  31 //****************************************************************************
  32 //
  33 // Defines
  34 //
  35 //****************************************************************************
  36 //****************************************************************************
  37
  38 //
  39 // Some occasionally useful debugging stuff.
  40 //
  41 #if(DBG)
  42     #ifndef ASSERT
  43     static ALint alListDebugAssertsEnabled = 1;
  44     #define ASSERT(exp)                                                     \
  45         {                                                                   \
  46             if(!(exp) && alListDebugAssertsEnabled)                         \
  47             {                                                               \
  48                 char tempStr[256];                                          \
  49                 OutputDebugString("\n");                                    \
  50                 sprintf(tempStr, "Assert failed in file %s, line %d!\n",    \
  51                         __FILE__, __LINE__);                                \
  52                 OutputDebugString(tempStr);                                 \
  53                 OutputDebugString("\n");                                    \
  54                 if(alListDebugAssertsEnabled)                               \
  55                 {                                                           \
  56                     DebugBreak();                                           \
  57                 }                                                           \
  58             }                                                               \
  59         }
  60
  61     #endif
  62 #else
  63     #ifndef ASSERT
  64     #define ASSERT(exp)
  65     #endif
  66 #endif
  67
  68
  69
  70 //****************************************************************************
  71 //****************************************************************************
  72 //
  73 // List Functions
  74 //
  75 //****************************************************************************
  76 //****************************************************************************
  77
  78 //*****************************************************************************
  79 // alListAddEntry
  80 //*****************************************************************************
  81 // Adds an entry to the tail of the list.  Each entry must be unique.
  82 //
  83 ALvoid alListAddEntry
  84 (
  85     IN  ALlist* pList,
  86     IN  ALlistEntry* pEntry
  87 )
  88 {
  89 #if(DBG)
  90     ALlistEntry* pCurrent = 0;
  91 #endif
  92
  93     ASSERT(pList);
  94     ASSERT(pEntry);
  95     ASSERT(pList->Locked);
  96     ASSERT(!pEntry->Next);
  97     ASSERT(!pEntry->Previous);
  98
  99     //
 100     // Verify the entry doesn't already exist.
 101     //
 102 #if(DBG)
 103     pCurrent = pList->Head;
 104     while(pCurrent)
 105     {
 106         if(pCurrent == pEntry)
 107         {
 108             break;
 109         }
 110
 111         pCurrent = pCurrent->Next;
 112     }
 113
 114     if(pCurrent)
 115     {
 116         // Duplicate entries are not supported.
 117         ASSERT(0);
 118         return;
 119     }
 120 #endif
 121
 122
 123     //
 124     // Add the item to the tail of the list.
 125     //
 126     if(pList->Tail)
 127     {
 128         pList->Tail->Next = pEntry;
 129     }
 130
 131     pEntry->Previous = pList->Tail;
 132     pList->Tail = pEntry;
 133
 134     //
 135     // Check if this is the first entry.
 136     //
 137     if(!pList->Head)
 138     {
 139         pList->Head = pEntry;
 140         pList->Current = pEntry;
 141     }
 142
 143     pList->NumberOfEntries++;
 144 }
 145
 146
 147 //*****************************************************************************
 148 // alListAddEntryToHead
 149 //*****************************************************************************
 150 // Adds an entry to the head of the list.  Each entry must be unique.
 151 //
 152 ALvoid alListAddEntryToHead
 153 (
 154     IN  ALlist* pList,
 155     IN  ALlistEntry* pEntry
 156 )
 157 {
 158 #if(DBG)
 159     ALlistEntry* pCurrent = 0;
 160 #endif
 161     ASSERT(pList);
 162     ASSERT(pEntry);
 163     ASSERT(pList->Locked);
 164     ASSERT(!pEntry->Next);
 165     ASSERT(!pEntry->Previous);
 166
 167     //
 168     // Verify the entry doesn't already exist.
 169     //
 170 #if(DBG)
 171     pCurrent = pList->Head;
 172     while(pCurrent)
 173     {
 174         if(pCurrent == pEntry)
 175         {
 176             break;
 177         }
 178
 179         pCurrent = pCurrent->Next;
 180     }
 181
 182     if(pCurrent)
 183     {
 184         // Duplicate entries are not supported.
 185         ASSERT(0);
 186         return;
 187     }
 188 #endif
 189
 190
 191     //
 192     // Add the item to the head of the list.
 193     //
 194     if(pList->Head)
 195     {
 196         pList->Head->Previous = pEntry;
 197     }
 198
 199     pEntry->Next = pList->Head;
 200     pList->Head = pEntry;
 201
 202     //
 203     // Check if this is the first entry.
 204     //
 205     if(!pList->Tail)
 206     {
 207         pList->Tail = pEntry;
 208         pList->Current = pEntry;
 209     }
 210
 211     pList->NumberOfEntries++;
 212 }
 213
 214
 215 //*****************************************************************************
 216 // alListAcquireLock
 217 //*****************************************************************************
 218 // This is called to aquire the list lock for operations that span multiple
 219 // list calls like iterating over the list.
 220 //
 221 ALvoid alListAcquireLock
 222 (
 223     IN  ALlist* pList
 224 )
 225 {
 226     ASSERT(pList);
 227
 228     EnterCriticalSection(&pList->Lock);
 229 #if(DBG)
 230     pList->Locked++;
 231 #endif
 232
 233     //
 234     // Check that only one person has the lock.
 235     //
 236     ASSERT(pList->Locked == 1);
 237 }
 238
 239
 240 //*****************************************************************************
 241 // alListCreate
 242 //*****************************************************************************
 243 // Creates and initializes a list.
 244 //
 245 ALboolean alListCreate
 246 (
 247     OUT ALlist** ppList
 248 )
 249 {
 250     ALlist* pList = 0;
 251
 252     ASSERT(ppList);
 253
 254     //
 255     // Allocate and initialize the list context.
 256     //
 257     *ppList = 0;
 258     pList = (ALlist*)malloc(sizeof(ALlist));
 259     if(!pList)
 260     {
 261         // Failed to allocate the list!
 262         ASSERT(0);
 263         return FALSE;
 264     }
 265
 266     memset(pList, 0, sizeof(ALlist));
 267     InitializeCriticalSection(&pList->Lock);
 268     pList->NumberOfEntries = 0;
 269     *ppList = pList;
 270     return TRUE;
 271 }
 272
 273
 274 //*****************************************************************************
 275 // alListFree
 276 //*****************************************************************************
 277 // Destroys the list.
 278 //
 279 ALvoid alListFree
 280 (
 281     IN  ALlist* pList
 282 )
 283 {
 284     ASSERT(pList);
 285     ASSERT(!pList->Head);
 286
 287     //
 288     // Free the resources allocated during the creation.
 289     //
 290     if(pList)
 291     {
 292         DeleteCriticalSection(&pList->Lock);
 293         free(pList);
 294     }
 295
 296     return;
 297 }
 298
 299
 300 //*****************************************************************************
 301 // alListGetData
 302 //*****************************************************************************
 303 // Returns the data from the list entry.
 304 //
 305 ALvoid* alListGetData
 306 (
 307     IN  ALlistEntry* pEntry
 308 )
 309 {
 310     ASSERT(pEntry);
 311
 312     return pEntry->Data;
 313 }
 314
 315
 316 //*****************************************************************************
 317 // alListGetEntryAt
 318 //*****************************************************************************
 319 // Returns the entry in the list at the specified index of the list.
 320 //
 321 ALlistEntry* alListGetEntryAt
 322 (
 323     IN  ALlist* pList,
 324     IN  ALint Index
 325 )
 326 {
 327     ALlistEntry* pEntry = 0;
 328     ALint i;
 329
 330     ASSERT(pList);
 331     ASSERT(pList->Locked);
 332     ASSERT(Index < pList->NumberOfEntries);
 333
 334     pEntry = pList->Head;
 335     for(i = 0; i < Index && pEntry; i++)
 336     {
 337         pEntry = pEntry->Next;
 338     }
 339
 340     return pEntry;
 341 }
 342
 343
 344 //*****************************************************************************
 345 // alListGetEntryCount
 346 //*****************************************************************************
 347 // Returns the number of items stored in the list.
 348 //
 349 ALint alListGetEntryCount
 350 (
 351     IN  ALlist* pList
 352 )
 353 {
 354     ASSERT(pList->Locked);
 355     return pList->NumberOfEntries;
 356 }
 357
 358
 359 //*****************************************************************************
 360 // alListGetHead
 361 //*****************************************************************************
 362 // Returns the first entry in the list.
 363 //
 364 ALlistEntry* alListGetHead
 365 (
 366     IN  ALlist* pList
 367 )
 368 {
 369     ASSERT(pList);
 370     ASSERT(pList->Locked);
 371
 372     return pList->Head;
 373 }
 374
 375
 376 //*****************************************************************************
 377 // alListGetNext
 378 //*****************************************************************************
 379 // Returns the entry after to the entry pointed to by the iterator.  If
 380 // the iterator is at the last entry (or has finished iterating over the
 381 // list), the returned entry will be 0.
 382 //
 383 ALlistEntry* alListGetNext
 384 (
 385     IN  ALlist* pList
 386 )
 387 {
 388     ASSERT(pList);
 389     ASSERT(pList->Locked);
 390
 391     if(!pList->Current)
 392     {
 393         return 0;
 394     }
 395
 396     return pList->Current->Next;
 397 }
 398
 399
 400 //*****************************************************************************
 401 // alListGetPrevious
 402 //*****************************************************************************
 403 // Returns the entry previous to the entry pointed to by the iterator.  If
 404 // the iterator is at the first entry, the returned entry will be 0.
 405 //
 406 ALlistEntry* alListGetPrevious
 407 (
 408     IN  ALlist* pList
 409 )
 410 {
 411     ASSERT(pList);
 412     ASSERT(pList->Locked);
 413
 414     if(!pList->Current)
 415     {
 416         return 0;
 417     }
 418
 419     return pList->Current->Previous;
 420 }
 421
 422
 423 //*****************************************************************************
 424 // alListGetTail
 425 //*****************************************************************************
 426 // Returns the last entry in the list.
 427 //
 428 ALlistEntry* alListGetTail
 429 (
 430     IN  ALlist* pList
 431 )
 432 {
 433     ASSERT(pList);
 434     ASSERT(pList->Locked);
 435
 436     return pList->Tail;
 437 }
 438
 439
 440 //*****************************************************************************
 441 // alListInitializeEntry
 442 //*****************************************************************************
 443 // Initializes a preallocated list entry.
 444 //
 445 ALvoid alListInitializeEntry
 446 (
 447     ALlistEntry* pEntry,
 448     ALvoid* pData
 449 )
 450 {
 451     ASSERT(pEntry);
 452
 453     pEntry->Data = pData;
 454     pEntry->Next = 0;
 455     pEntry->Previous = 0;
 456 }
 457
 458
 459 //*****************************************************************************
 460 // alListIsEmpty
 461 //*****************************************************************************
 462 // Returns the TRUE if the list is empty.
 463 //
 464 ALboolean alListIsEmpty
 465 (
 466     IN  ALlist* pList
 467 )
 468 {
 469     ASSERT(pList);
 470     ASSERT(pList->Locked);
 471
 472     return (pList->Head == 0);
 473 }
 474
 475
 476 //*****************************************************************************
 477 // alListIteratorGet
 478 //*****************************************************************************
 479 // Returns the entry pointed to by the iterator.
 480 //
 481 ALlistEntry* alListIteratorGet
 482 (
 483     IN  ALlist* pList
 484 )
 485 {
 486     ASSERT(pList);
 487     ASSERT(pList->Locked);
 488
 489     return pList->Current;
 490 }
 491
 492
 493 //*****************************************************************************
 494 // alListIteratorFindData
 495 //*****************************************************************************
 496 // Searches the list for the matching item and return the pointer to the
 497 // entry.  If the match is not found, the return will be 0.
 498 //
 499 ALlistEntry* alListIteratorFindData
 500 (
 501     IN  ALlist* pList,
 502     IN  ALvoid* pData
 503 )
 504 {
 505     ALlistEntry* pCurrent = 0;
 506
 507     ASSERT(pList);
 508     ASSERT(pList->Locked);
 509
 510     //
 511     // Find the item.
 512     //
 513     pCurrent = pList->Head;
 514     while(pCurrent)
 515     {
 516         if(pCurrent->Data == pData)
 517         {
 518             break;
 519         }
 520
 521         pCurrent = pCurrent->Next;
 522     }
 523
 524     pList->Current = pCurrent;
 525     return pCurrent;
 526 }
 527
 528
 529 //*****************************************************************************
 530 // alListIteratorNext
 531 //*****************************************************************************
 532 // This is called to advance the list iterator to the next entry in the list
 533 // and return that entry.
 534 //
 535 ALlistEntry* alListIteratorNext
 536 (
 537     IN  ALlist* pList
 538 )
 539 {
 540     ASSERT(pList);
 541     ASSERT(pList->Locked);
 542
 543     if(!pList->Current)
 544     {
 545         return 0;
 546     }
 547
 548     pList->Current = pList->Current->Next;
 549     return pList->Current;
 550 }
 551
 552
 553 //*****************************************************************************
 554 // alListIteratorPrevious
 555 //*****************************************************************************
 556 // This is called to advance the list iterator to the previous entry in the
 557 // list and return that entry.
 558 //
 559 ALlistEntry* alListIteratorPrevious
 560 (
 561     IN  ALlist* pList
 562 )
 563 {
 564     ASSERT(pList);
 565     ASSERT(pList->Locked);
 566
 567     if(!pList->Current)
 568     {
 569         return 0;
 570     }
 571
 572     pList->Current = pList->Current->Previous;
 573     return pList->Current;
 574 }
 575
 576
 577 //*****************************************************************************
 578 // alListIteratorRemove
 579 //*****************************************************************************
 580 // Removes the current item from the list and returns it.  The iterator will
 581 // equal the next item in the list.
 582 //
 583 ALlistEntry* alListIteratorRemove
 584 (
 585     IN  ALlist* pList
 586 )
 587 {
 588     ALlistEntry* pEntry = 0;
 589
 590     ASSERT(pList);
 591     ASSERT(pList->Locked);
 592
 593     //
 594     // Make sure we aren't at the end of the list.
 595     //
 596     if(!pList->Current)
 597     {
 598         return 0;
 599     }
 600
 601     //
 602     // Remove the item from the list.
 603     //
 604     pEntry = pList->Current;
 605
 606     //
 607     // Fix up the next item in the list.
 608     //
 609     if(pEntry->Next)
 610     {
 611         pEntry->Next->Previous = pEntry->Previous;
 612     }
 613
 614     //
 615     // Fix up the previous item in the list.
 616     //
 617     if(pEntry->Previous)
 618     {
 619         pEntry->Previous->Next = pEntry->Next;
 620     }
 621
 622     //
 623     // Fix up the current pointer.
 624     //
 625     pList->Current = pEntry->Next;
 626
 627     //
 628     // Check the head pointer.
 629     //
 630     if(pList->Head == pEntry)
 631     {
 632         pList->Head = pEntry->Next;
 633     }
 634
 635     //
 636     // Check the tail pointer.
 637     //
 638     if(pList->Tail == pEntry)
 639     {
 640         pList->Tail = pEntry->Previous;
 641     }
 642
 643     //
 644     // Set the entry pointers.
 645     //
 646     pEntry->Next = 0;
 647     pEntry->Previous = 0;
 648     pList->NumberOfEntries--;
 649     ASSERT(0 <= pList->NumberOfEntries);
 650     return pEntry;
 651 }
 652
 653
 654 //*****************************************************************************
 655 // alListIteratorReset
 656 //*****************************************************************************
 657 // Returns the list iterator to the head of the list.
 658 //
 659 ALlistEntry* alListIteratorReset
 660 (
 661     IN  ALlist* pList
 662 )
 663 {
 664     ASSERT(pList);
 665     ASSERT(pList->Locked);
 666
 667     pList->Current = pList->Head;
 668     return pList->Current;
 669 }
 670
 671
 672 //*****************************************************************************
 673 // alListIteratorSet
 674 //*****************************************************************************
 675 // Sets the current entry pointer to the entry passed in.  If the entry is not
 676 // found, the current entry will be 0.
 677 //
 678 ALlistEntry* alListIteratorSet
 679 (
 680     IN  ALlist* pList,
 681     IN  ALlistEntry* pEntry
 682 )
 683 {
 684     ALlistEntry* pCurrent = 0;
 685
 686     ASSERT(pList);
 687     ASSERT(pList->Locked);
 688
 689     pCurrent = pList->Head;
 690     while(pCurrent)
 691     {
 692         if(pCurrent == pEntry)
 693         {
 694             break;
 695         }
 696
 697         pCurrent = pCurrent->Next;
 698     }
 699
 700     pList->Current = pCurrent;
 701     return pList->Current;
 702 }
 703
 704
 705 //*****************************************************************************
 706 // alListMatchEntry
 707 //*****************************************************************************
 708 // Matches the entry to an item in the list and returns the data in that
 709 // entry.  If the match is not found, the return will be 0.
 710 //
 711 ALvoid* alListMatchEntry
 712 (
 713     IN  ALlist* pList,
 714     IN  ALlistEntry* pEntry
 715 )
 716 {
 717     ALlistEntry* pCurrent = 0;
 718
 719     ASSERT(pList);
 720     ASSERT(pList->Locked);
 721
 722     //
 723     // Find the item.
 724     //
 725     pCurrent = pList->Head;
 726     while(pCurrent)
 727     {
 728         if(pCurrent == pEntry)
 729         {
 730             break;
 731         }
 732
 733         pCurrent = pCurrent->Next;
 734     }
 735
 736     if(!pCurrent)
 737     {
 738         return 0;
 739     }
 740
 741     return pCurrent->Data;
 742 }
 743
 744
 745 //*****************************************************************************
 746 // alListMatchData
 747 //*****************************************************************************
 748 // Searches the list for the first matching item and returns the pointer to
 749 // the entry.  If the match is not found, the return will be 0.
 750 //
 751 ALlistEntry* alListMatchData
 752 (
 753     IN  ALlist* pList,
 754     IN  ALvoid* pData
 755 )
 756 {
 757     ALlistEntry* pCurrent = 0;
 758
 759     ASSERT(pList);
 760     ASSERT(pList->Locked);
 761
 762     //
 763     // Find the item.
 764     //
 765     pCurrent = pList->Head;
 766     while(pCurrent)
 767     {
 768         if(pCurrent->Data == pData)
 769         {
 770             break;
 771         }
 772
 773         pCurrent = pCurrent->Next;
 774     }
 775
 776     return pCurrent;
 777 }
 778
 779
 780 //*****************************************************************************
 781 // alListReleaseLock
 782 //*****************************************************************************
 783 // This is called to release the list lock.
 784 //
 785 ALvoid alListReleaseLock
 786 (
 787     IN  ALlist* pList
 788 )
 789 {
 790     ASSERT(pList);
 791     ASSERT(pList->Locked);
 792
 793 #if(DBG)
 794     pList->Locked--;
 795     ASSERT(pList->Locked == 0);
 796 #endif
 797
 798     LeaveCriticalSection(&pList->Lock);
 799 }
 800
 801
 802 //*****************************************************************************
 803 // alListRemoveEntry
 804 //*****************************************************************************
 805 // Removes the item from the list and returns the data from the item.  If
 806 // this is the current item, the current item will equal the next item in the
 807 // list.
 808 //
 809 ALvoid* alListRemoveEntry
 810 (
 811     IN  ALlist* pList,
 812     IN  ALlistEntry* pEntry
 813 )
 814 {
 815     ALlistEntry* pCurrent = 0;
 816
 817     ASSERT(pList);
 818     ASSERT(pList->Locked);
 819     ASSERT(pEntry);
 820
 821     //
 822     // Release the item from the list.
 823     //
 824     pCurrent = pList->Head;
 825     while(pCurrent)
 826     {
 827         if(pCurrent == pEntry)
 828         {
 829             break;
 830         }
 831
 832         pCurrent = pCurrent->Next;
 833     }
 834
 835     if(!pCurrent)
 836     {
 837         return 0;
 838     }
 839
 840     //
 841     // Fix up the next item in the list.
 842     //
 843     if(pEntry->Next)
 844     {
 845         pEntry->Next->Previous = pEntry->Previous;
 846     }
 847
 848     //
 849     // Fix up the previous item in the list.
 850     //
 851     if(pEntry->Previous)
 852     {
 853         pEntry->Previous->Next = pEntry->Next;
 854     }
 855
 856     //
 857     // Fix up the current pointer.
 858     //
 859     if(pCurrent == pList->Current)
 860     {
 861         pList->Current = pEntry->Next;
 862     }
 863
 864     //
 865     // Check the head pointer.
 866     //
 867     if(pList->Head == pEntry)
 868     {
 869         pList->Head = pEntry->Next;
 870     }
 871
 872     //
 873     // Check the tail pointer.
 874     //
 875     if(pList->Tail == pEntry)
 876     {
 877         pList->Tail = pEntry->Previous;
 878     }
 879
 880     //
 881     // Set the entry pointers.
 882     //
 883     pEntry->Next = 0;
 884     pEntry->Previous = 0;
 885     pList->NumberOfEntries--;
 886     ASSERT(0 <= pList->NumberOfEntries);
 887     return pEntry->Data;
 888 }
 889
 890
 891 //*****************************************************************************
 892 // alListRemoveHead
 893 //*****************************************************************************
 894 // Removes the list entry at the head of the list.  If this is the current
 895 // item, the current item will equal the next item in the list.
 896 //
 897 ALlistEntry* alListRemoveHead
 898 (
 899     IN  ALlist* pList
 900 )
 901 {
 902     ALlistEntry* pCurrent = 0;
 903
 904     ASSERT(pList);
 905     ASSERT(pList->Locked);
 906
 907     //
 908     // Release the item from the list.
 909     //
 910     pCurrent = pList->Head;
 911     if(!pCurrent)
 912     {
 913         return 0;
 914     }
 915
 916     //
 917     // Fix up the next item in the list.
 918     //
 919     if(pCurrent->Next)
 920     {
 921         pCurrent->Next->Previous = 0;
 922     }
 923
 924     //
 925     // Fix up the previous item in the list.
 926     //
 927     ASSERT(!pCurrent->Previous)
 928
 929     //
 930     // Fix up the current pointer.
 931     //
 932     if(pCurrent == pList->Current)
 933     {
 934         pList->Current = pCurrent->Next;
 935     }
 936
 937     //
 938     // Check the head pointer.
 939     //
 940     pList->Head = pCurrent->Next;
 941
 942     //
 943     // Check the tail pointer.
 944     //
 945     if(pList->Tail == pCurrent)
 946     {
 947         pList->Tail = 0;
 948     }
 949
 950     //
 951     // Set the entry pointers.
 952     //
 953     pCurrent->Next = 0;
 954     pCurrent->Previous = 0;
 955     pList->NumberOfEntries--;
 956     ASSERT(0 <= pList->NumberOfEntries);
 957     return pCurrent;
 958 }
 959
 960
 961 //*****************************************************************************
 962 // alListRemoveTail
 963 //*****************************************************************************
 964 // Removes the list entry at the tail of the list.  If this is the current
 965 // item, the current item will be null.
 966 //
 967 ALlistEntry* alListRemoveTail
 968 (
 969     IN  ALlist* pList
 970 )
 971 {
 972     ALlistEntry* pCurrent = 0;
 973
 974     ASSERT(pList);
 975     ASSERT(pList->Locked);
 976
 977     //
 978     // Release the item from the list.
 979     //
 980     pCurrent = pList->Tail;
 981     if(!pCurrent)
 982     {
 983         return 0;
 984     }
 985
 986     //
 987     // Fix up the next item in the list.
 988     //
 989     ASSERT(!pCurrent->Next)
 990
 991     //
 992     // Fix up the previous item in the list.
 993     //
 994     if(pCurrent->Previous)
 995     {
 996         pCurrent->Previous->Next = 0;
 997     }
 998
 999     //
1000     // Fix up the current pointer.
1001     //
1002     if(pCurrent == pList->Current)
1003     {
1004         pList->Current = 0;
1005     }
1006
1007     //
1008     // Check the head pointer.
1009     //
1010     if(pList->Head == pCurrent)
1011     {
1012         pList->Head = 0;
1013     }
1014
1015     //
1016     // Check the tail pointer.
1017     //
1018     pList->Tail = pCurrent->Previous;
1019
1020     //
1021     // Set the entry pointers.
1022     //
1023     pCurrent->Next = 0;
1024     pCurrent->Previous = 0;
1025     pList->NumberOfEntries--;
1026     ASSERT(0 <= pList->NumberOfEntries);
1027     return pCurrent;
1028 }
1029