Main Page | Alphabetical List | Compound List | File List | Compound Members | File Members

list.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"
#include "mempool.h"
#include "ram.h"
#include "crc32.h"

Go to the source code of this file.

Compounds

struct  Hash
struct  HashNode
struct  Link
struct  List
struct  RadixLink
struct  RadixList
struct  RadixLN

Defines

#define TIMER_P(x)
#define TIMER_Q(X)
#define Debug(func)
#define DebugAlert()
#define MemAlloc(size)   geRam_AllocateClear(size)
#define MemFree(mem)   geRam_Free(mem)
#define new(type)   MemAlloc(sizeof(type))
#define destroy(mem)   if ( mem ) MemFree(mem)
#define HASH_MOD   (1009)
#define HASH_SIZE   (HASH_MOD + 1)
#define HASH(Key)   ((( ((Key)>>15) ^ (Key) )%HASH_MOD)+1)

Functions

int LN_ListLen (LinkNode *pList)
LinkNode *LISTCALL LN_CutHead (LinkNode *pList)
LinkNode *LISTCALL LN_CutTail (LinkNode *pList)
void LISTCALL List_Destroy (List *pList)
List *LISTCALL List_Create (void)
List *LISTCALL List_AddTail (List *pList, void *Data)
List *LISTCALL List_AddHead (List *pList, void *Data)
void *LISTCALL List_CutHead (List *pList)
void *LISTCALL List_CutTail (List *pList)
void *LISTCALL List_PeekHead (List *pList)
void *LISTCALL List_PeekTail (List *pList)
void LISTCALL List_CutNode (List *pNode)
void LISTCALL List_DeleteNode (List *pNode)
void LISTCALL List_FreeNode (List *pNode)
void *LISTCALL List_NodeData (List *pNode)
List *LISTCALL List_Next (List *pNode)
List *LISTCALL List_Prev (List *pNode)
List * List_Find (List *pList, void *Data)
void LISTCALL Link_Destroy (Link *pLink)
Link *LISTCALL Link_Create (void)
void LISTCALL Link_Push (Link *pLink, void *Data)
void *LISTCALL Link_Pop (Link *pLink)
void *LISTCALL Link_Peek (Link *pLink)
void LISTCALL Stack_Destroy (Stack *pStack)
Stack *LISTCALL Stack_Create (void)
int LISTCALL Stack_Extend (Stack *pStack)
void LISTCALL Stack_Push_Func (Stack *pStack, void *Data)
void *LISTCALL Stack_Pop_Func (Stack *pStack)
RadixList * RadixList_Create (int RadixListMax)
void RadixList_Destroy (RadixList *pRadixList)
List * RadixList_Add (RadixList *pRadixList, void *Data, int Key)
void * RadixList_CutMax (RadixList *pRadixList, int *pKey)
void * RadixList_CutMin (RadixList *pRadixList, int *pKey)
void * RadixList_CutKey (RadixList *pRadixList, int Key)
RadixLN * RadixLN_Create (int RadixLNMax)
void RadixLN_Destroy (RadixLN *pRadixLN)
void RadixLN_AddHead (RadixLN *pRadixLN, LinkNode *LN, int Key)
void RadixLN_AddTail (RadixLN *pRadixLN, LinkNode *LN, int Key)
LinkNode * RadixLN_CutMax (RadixLN *pRadixLN, int *pKey)
LinkNode * RadixLN_CutMin (RadixLN *pRadixLN, int *pKey)
LinkNode * RadixLN_CutKey (RadixLN *pRadixLN, int Key)
LinkNode * RadixLN_PeekMax (RadixLN *pRadixLN, int *pKey)
LinkNode * RadixLN_PeekMin (RadixLN *pRadixLN, int *pKey)
RadixLink * RadixLink_Create (int RadixLinkMax)
void RadixLink_Grow (RadixLink *pRadixLink, int NewMax)
void RadixLink_Destroy (RadixLink *pRadixLink)
void RadixLink_Add (RadixLink *pRadixLink, void *Data, int Key)
void * RadixLink_CutMax (RadixLink *pRadixLink, int *pKey)
void * RadixLink_CutMin (RadixLink *pRadixLink, int *pKey)
void * RadixLink_CutKey (RadixLink *pRadixLink, int Key)
void List_TimerReport (void)
Hash * Hash_Create (void)
void Hash_Destroy (Hash *pHash)
HashNode *LISTCALL Hash_Add (Hash *pHash, uint32 Key, uint32 Data)
void LISTCALL Hash_DeleteNode (Hash *pHash, HashNode *pNode)
HashNode *LISTCALL Hash_Get (Hash *pHash, uint32 Key, uint32 *pData)
HashNode *LISTCALL Hash_WalkNext (Hash *pHash, HashNode *pNode)
uint32 LISTCALL Hash_NumMembers (Hash *pHash)
uint32 Hash_StringToKey (const char *String)
void HashNode_SetData (HashNode *pNode, uint32 Data)
void HashNode_GetData (HashNode *pNode, uint32 *pKey, uint32 *pData)
uint32 HashNode_Data (HashNode *pNode)
uint32 HashNode_Key (HashNode *pNode)
geBoolean List_Start (void)
geBoolean List_Stop (void)

Variables

MemPool * ListPool_g = NULL
MemPool * LinkPool_g = NULL
MemPool * HashNodePool_g = NULL
int UsageCount = 0

Define Documentation

#define Debug (  func   ) 
 

Definition at line 62 of file list.c.

 
#define DebugAlert (   ) 
 

Definition at line 63 of file list.c.

#define destroy (  mem   )     if ( mem ) MemFree(mem)
 

Definition at line 100 of file list.c.

#define HASH (  Key   )     ((( ((Key)>>15) ^ (Key) )%HASH_MOD)+1)
 

Definition at line 1060 of file list.c.

#define HASH_MOD   (1009)
 

Definition at line 1058 of file list.c.

#define HASH_SIZE   (HASH_MOD + 1)
 

Definition at line 1059 of file list.c.

#define MemAlloc (  size   )     geRam_AllocateClear(size)
 

Definition at line 66 of file list.c.

Referenced by RadixLink_Create(), RadixLink_Grow(), RadixList_Create(), RadixLN_Create(), Stack_Create(), and Stack_Extend().

#define MemFree (  mem   )     geRam_Free(mem)
 

Definition at line 67 of file list.c.

Referenced by RadixLink_Destroy(), RadixLink_Grow(), RadixList_Destroy(), RadixLN_Destroy(), and Stack_Extend().

#define new (  type   )     MemAlloc(sizeof(type))
 

Definition at line 98 of file list.c.

#define TIMER_P (  x   ) 
 

Definition at line 53 of file list.c.

Referenced by BlitData_DePalettize(), Fire_Animate(), FireAnimator_CreateFire(), geTClip_Triangle(), Particles_Animate(), Plasma_Animate(), RadixLN_Create(), RadixLN_CutMax(), RadixLN_CutMin(), RadixLN_PeekMax(), and RadixLN_PeekMin().

#define TIMER_Q (  X   ) 
 

Definition at line 54 of file list.c.

Referenced by BlitData_DePalettize(), Fire_Animate(), FireAnimator_CreateFire(), geTClip_Triangle(), Particles_Animate(), Plasma_Animate(), RadixLN_Create(), RadixLN_CutMax(), RadixLN_CutMin(), RadixLN_PeekMax(), and RadixLN_PeekMin().

Function Documentation

HashNode* LISTCALL Hash_Add (  Hash *  pHash,
uint32  Key,
uint32  Data
) 
 

Definition at line 1157 of file list.c.

References HashNode::Data, Debug, HashNode::Hash, HASH, Hash_NumMembers(), HASH_SIZE, HashNodePool_g, HashNode::Key, LISTCALL, LN_AddBefore, LN_Next, LN_Null, LN_Prev, MemPool_GetHunk(), Hash::NodeList, and uint32.

Referenced by BitmapList_Add(). 

01158 {
01159 uint32 H;
01160 HashNode *hn,**pTable,*Node,*Prev;
01161 Debug( int ListLen1; int ListLen2; int HashLen1; int HashLen2; int WalkLen)
01162 
01163         assert(pHash);
01164         assert( pHash->MySelf1 == pHash && pHash->MySelf2 == pHash );
01165 
01166         hn = MemPool_GetHunk(HashNodePool_g);
01167         assert(hn);
01168         Debug( LN_Null(hn) )
01169 
01170         hn->Key = Key;
01171         hn->Data = Data;
01172         hn->Hash = H = HASH(Key);
01173 
01174         pTable = &(pHash->HashTable[H]);
01175         Node = *pTable;
01176 
01177         assert( H > 0 );
01178         assert( pHash->NodeList->Hash == 0 );
01179         assert( ((HashNode *)LN_Prev(pHash->NodeList))->Hash == HASH_SIZE );
01180 
01181         Debug(HashLen1 = Hash_NumMembers(pHash))
01182         Debug(ListLen1 = Hash_ListLen(pHash,H))
01183 
01184         if ( ! Node )
01185         {
01186                 Prev = pHash->NodeList;
01187                 Node = LN_Next(Prev);
01188 
01189                 Debug(WalkLen = 0)
01190 
01191                 assert(Prev->Hash < H);
01192                 while( Node->Hash < H )
01193                 {
01194                         Prev = Node;
01195                         Node = LN_Next(Prev);
01196                 
01197                         assert(WalkLen < pHash->Members );
01198                         Debug( WalkLen ++)
01199                         
01200                         assert(Prev->Hash <= Node->Hash);
01201                         assert(Prev->Hash < HASH_SIZE );
01202                 }
01203 
01204                 assert(Prev->Hash < H);
01205                 assert(Node->Hash >= H);
01206         }
01207 
01208         LN_AddBefore(hn,Node);
01209         *pTable = hn;
01210 
01211         Debug(pHash->Members ++)
01212 
01213         Debug(ListLen2 = Hash_ListLen(pHash,H))
01214         assert( ListLen2 == (ListLen1 + 1) );
01215         Debug(HashLen2 = Hash_NumMembers(pHash))
01216         assert( HashLen2 == (HashLen1 + 1) );
01217 
01218 return hn;
01219 }

Hash* Hash_Create (  void   ) 
 

Definition at line 1082 of file list.c.

References HashNode::Data, Debug, HashNode::Hash, HASH_SIZE, HashNodePool_g, HashNode::Key, LN_AddBefore, LN_Null, MemPool_GetHunk(), Hash::NodeList, and NULL.

Referenced by BitmapList_Create(). 

01083 {
01084 Hash * pHash;
01085 HashNode *pHead,*pTail;
01086 
01087         pHash = new(Hash);
01088         if ( ! pHash ) 
01089                 return NULL;
01090         
01091         //memset(pHash,0,sizeof(Hash));
01092 
01093         Debug( pHash->MySelf1 = pHash )
01094         Debug( pHash->MySelf2 = pHash )
01095 
01096         pTail = MemPool_GetHunk(HashNodePool_g);
01097         assert(pTail);
01098         LN_Null(pTail);
01099         pTail->Key = pTail->Data = 0;
01100         pTail->Hash = HASH_SIZE;
01101 
01102         pHead = MemPool_GetHunk(HashNodePool_g);
01103         assert(pHead);
01104         LN_Null(pHead);
01105         pHead->Key = pHead->Data = 0;
01106         pHead->Hash = 0;
01107 
01108         LN_AddBefore(pHead,pTail);
01109 
01110         pHash->NodeList = pHead;
01111 
01112         Debug(pHash->Members = 0)
01113 
01114 return pHash;
01115 }

void LISTCALL Hash_DeleteNode (  Hash *  pHash,
HashNode *  pNode
) 
 

Definition at line 1221 of file list.c.

References Debug, HashNode::Hash, Hash_NumMembers(), HASH_SIZE, HashNodePool_g, LISTCALL, LN_Cut, LN_Next, LN_Prev, MemPool_FreeHunk(), NULL, and uint32.

Referenced by BitmapList_Remove(). 

01222 {
01223 HashNode ** pHead;
01224 uint32 H;
01225 Debug( int ListLen1; int ListLen2;int HashLen1; int HashLen2)
01226 
01227         assert(pNode );
01228         assert( pHash );
01229         assert( pHash->MySelf1 == pHash && pHash->MySelf2 == pHash );
01230 
01231         assert( pNode->Hash > 0 && pNode->Hash < HASH_SIZE );
01232 
01233         H = pNode->Hash;
01234         pHead = & ( pHash->HashTable[H] );
01235 
01236         Debug( HashLen1 = Hash_NumMembers(pHash) )
01237         Debug( ListLen1 = Hash_ListLen(pHash,H) )
01238         assert(pHash->Members > 0);
01239         Debug(pHash->Members --)
01240 
01241         if ( *pHead == pNode )
01242         {
01243                 *pHead = LN_Next(pNode);
01244                 if ( (*pHead)->Hash != H )
01245                 {
01246                         // pNode was the head of the list
01247                         assert( ((HashNode *)LN_Prev(pNode))->Hash < H );
01248                         *pHead = NULL;
01249                 }
01250         }
01251         assert( *pHead == NULL || (*pHead)->Hash == H );
01252 
01253         LN_Cut(pNode);
01254 
01255         MemPool_FreeHunk(HashNodePool_g,pNode);
01256         
01257         Debug( HashLen2 = Hash_NumMembers(pHash) )
01258         Debug( ListLen2 = Hash_ListLen(pHash,H) )
01259         assert( HashLen2 == (HashLen1 - 1) );
01260 
01261 }

void Hash_Destroy (  Hash *  pHash  ) 
 

Definition at line 1117 of file list.c.

References Debug, destroy, HashNodePool_g, LN_Walk_Editting, MemPool_FreeHunk(), and Hash::NodeList.

Referenced by BitmapList_Destroy(). 

01118 {
01119         if ( pHash )
01120         {
01121         HashNode *pList,*pNode,*pNext;
01122         
01123                 assert( pHash->MySelf1 == pHash && pHash->MySelf2 == pHash );
01124 
01125                 Debug(pHash->Members += 2) // count Head & Tail
01126 
01127                 pList = pHash->NodeList;
01128                 LN_Walk_Editting(pNode,pList,pNext) {
01129                         MemPool_FreeHunk(HashNodePool_g,pNode);
01130                         assert(pHash->Members > 1);
01131                         Debug(pHash->Members --)
01132                 }
01133                 assert(pHash->Members == 1);
01134                 MemPool_FreeHunk(HashNodePool_g,pList);
01135                 destroy(pHash);
01136         }
01137 }

HashNode* LISTCALL Hash_Get (  Hash *  pHash,
uint32  Key,
uint32 *  pData
) 
 

Definition at line 1263 of file list.c.

References HashNode::Data, HASH, HashNode::Hash, HASH_SIZE, HashNode::Key, LISTCALL, LN_Next, NULL, and uint32.

Referenced by BitmapList_Add(), BitmapList_Has(), and BitmapList_Remove(). 

01264 {
01265 uint32 H;
01266 HashNode *pNode;
01267 
01268         assert(pHash );
01269         assert( pHash->MySelf1 == pHash && pHash->MySelf2 == pHash );
01270 
01271         H = HASH(Key);
01272         assert( H > 0 && H < HASH_SIZE );
01273 
01274         pNode = pHash->HashTable[H];
01275         if ( ! pNode )
01276                 return NULL;
01277 
01278         assert( pNode->Hash == H );
01279 
01280         while( pNode->Hash == H )
01281         {
01282                 if ( pNode->Key == Key )
01283                 {
01284                         if ( pData )
01285                                 *pData = pNode->Data;
01286                         return pNode;
01287                 }
01288                 pNode = LN_Next(pNode);
01289         }
01290 
01291 return NULL;
01292 }

uint32 LISTCALL Hash_NumMembers (  Hash *  pHash  ) 
 

Definition at line 1325 of file list.c.

References HashNode::Hash, HASH_SIZE, LISTCALL, LN_Next, Hash::NodeList, and uint32.

Referenced by Hash_Add(), and Hash_DeleteNode(). 

01326 {
01327 uint32 N;
01328 HashNode *pNode;
01329 
01330         assert(pHash);
01331         assert( pHash->MySelf1 == pHash && pHash->MySelf2 == pHash );
01332 
01333         pNode = pHash->NodeList;
01334         assert( pNode->Hash == 0 );
01335         pNode = LN_Next(pNode);
01336         assert( pNode->Hash > 0 );
01337 
01338         N = 0;
01339         while( pNode->Hash < HASH_SIZE )
01340         {
01341                 assert( N < (uint32)pHash->Members );
01342                 pNode = LN_Next(pNode);
01343                 N ++;
01344         }
01345 
01346         assert( N == (uint32)pHash->Members );
01347 
01348 return N;
01349 }

uint32 Hash_StringToKey (  const char *  String  ) 
 

Definition at line 1353 of file list.c.

References CRC32_Array(), and uint32. 

01354 {
01355 return CRC32_Array(String,strlen(String));
01356 }

HashNode* LISTCALL Hash_WalkNext (  Hash *  pHash,
HashNode *  pNode
) 
 

Definition at line 1294 of file list.c.

References HashNode::Hash, HASH_SIZE, LISTCALL, LN_Next, LN_Prev, Hash::NodeList, and NULL.

Referenced by BitmapList_AttachAll(), BitmapList_CountMembers(), BitmapList_CountMembersAttached(), BitmapList_Destroy(), BitmapList_DetachAll(), and BitmapList_SetGamma(). 

01295 {
01296 HashNode *pNext;
01297 
01298         assert(pHash);
01299         assert( pHash->MySelf1 == pHash && pHash->MySelf2 == pHash );
01300 
01301         if ( ! pNode )
01302         {
01303                 pNode = pHash->NodeList;
01304                 assert( pNode->Hash == 0 );
01305         }
01306 
01307         pNext = LN_Next(pNode);
01308         assert( pNext->Hash > 0 );
01309         assert( pNext->Hash >= pNode->Hash );
01310 
01311         assert( pNext != pNode );
01312         assert( LN_Prev(pNext) == pNode );
01313 
01314         if ( pNext->Hash == HASH_SIZE )
01315         {
01316                 assert( ((HashNode *)LN_Next(pNext)) == pHash->NodeList );
01317                 return NULL;
01318         }
01319 
01320         assert(pNext->Hash < HASH_SIZE);
01321 
01322 return pNext;
01323 }

uint32 HashNode_Data (  HashNode *  pNode  ) 
 

Definition at line 1371 of file list.c.

References HashNode::Data, and uint32. 

01372 {
01373         assert(pNode);
01374 return pNode->Data;
01375 }

void HashNode_GetData (  HashNode *  pNode,
uint32 *  pKey,
uint32 *  pData
) 
 

Definition at line 1364 of file list.c.

References HashNode::Data, and HashNode::Key.

Referenced by BitmapList_CountMembersAttached(), BitmapList_Destroy(), and BitmapList_DetachAll(). 

01365 {
01366         assert(pNode);
01367         *pKey   = pNode->Key;
01368         *pData  = pNode->Data;
01369 }

uint32 HashNode_Key (  HashNode *  pNode  ) 
 

Definition at line 1377 of file list.c.

References HashNode::Key, and uint32.

Referenced by BitmapList_AttachAll(), and BitmapList_SetGamma(). 

01378 {
01379         assert(pNode);
01380 return pNode->Key;
01381 }

void HashNode_SetData (  HashNode *  pNode,
uint32  Data
) 
 

Definition at line 1358 of file list.c.

References HashNode::Data.

Referenced by BitmapList_Add(), and BitmapList_Remove(). 

01359 {
01360         assert(pNode);
01361         pNode->Data = Data;
01362 }

Link* LISTCALL Link_Create (  void   ) 
 

Definition at line 324 of file list.c.

References Link::Data, LinkPool_g, LISTCALL, MemPool_GetHunk(), Link::Next, and NULL.

Referenced by geTClip_Push(). 

00325 {
00326 Link * pLink;
00327         pLink = MemPool_GetHunk(LinkPool_g);
00328         assert(pLink);
00329         pLink->Next = NULL;
00330         pLink->Data = NULL;
00331 return pLink;
00332 }

void LISTCALL Link_Destroy (  Link *  pLink  ) 
 

Definition at line 313 of file list.c.

References LinkPool_g, LISTCALL, MemPool_FreeHunk(), and Link::Next.

Referenced by geTClip_Pop(), and RadixLink_Destroy(). 

00314 {
00315         while( pLink )
00316         {
00317         Link *Next;
00318                 Next = pLink->Next;
00319                 MemPool_FreeHunk(LinkPool_g,pLink);
00320                 pLink = Next;
00321         }
00322 }

void* LISTCALL Link_Peek (  Link *  pLink  ) 
 

Definition at line 363 of file list.c.

References Link::Data, LISTCALL, Link::Next, and NULL.

Referenced by geTClip_Pop(). 

00364 {
00365 void *pData;
00366 Link * pNode;
00367         if ( ! pLink ) return NULL;
00368 //      DebugWarn(geRam_IsValidPtr(pLink));
00369         pNode = pLink->Next;
00370         if ( ! pNode ) return NULL;
00371 //      DebugWarn(geRam_IsValidPtr(pNode));
00372         pData = pNode->Data;
00373 return pData;
00374 }

void* LISTCALL Link_Pop (  Link *  pLink  ) 
 

Definition at line 348 of file list.c.

References Link::Data, LinkPool_g, LISTCALL, MemPool_FreeHunk(), Link::Next, and NULL.

Referenced by geTClip_Pop(), RadixLink_CutKey(), RadixLink_CutMax(), and RadixLink_CutMin(). 

00349 {
00350 void *pData;
00351 Link * pNode;
00352         if ( ! pLink ) return NULL;
00353 //      DebugWarn(geRam_IsValidPtr(pLink));
00354         pNode = pLink->Next;
00355         if ( ! pNode ) return NULL;
00356 //      DebugWarn(geRam_IsValidPtr(pNode));
00357         pData = pNode->Data;
00358         pLink->Next = pNode->Next;
00359         MemPool_FreeHunk(LinkPool_g,pNode);
00360 return pData;
00361 }

void LISTCALL Link_Push (  Link *  pLink,
void *  Data
) 
 

Definition at line 334 of file list.c.

References Link::Data, LinkPool_g, LISTCALL, MemPool_GetHunk(), and Link::Next.

Referenced by geTClip_Push(), and RadixLink_Add(). 

00335 {
00336 Link * pNode;
00337         assert(pLink);
00338         pNode = MemPool_GetHunk(LinkPool_g);
00339         assert(pNode);
00340 //      DebugWarn(geRam_IsValidPtr(pLink));
00341 //      DebugWarn(geRam_IsValidPtr(pNode));
00342         pNode->Data = Data;
00343 
00344         pNode->Next = pLink->Next;
00345         pLink->Next = pNode;
00346 }

List* LISTCALL List_AddHead (  List *  pList,
void *  Data
) 
 

Definition at line 193 of file list.c.

References List::Data, LISTCALL, ListPool_g, MemPool_GetHunk(), List::Next, and List::Prev. 

00194 {
00195 List * pNew;
00196 
00197         pNew = MemPool_GetHunk(ListPool_g);
00198         assert(pNew);
00199         pNew->Data= Data;
00200 
00201         pNew->Prev = pList;
00202         pNew->Next = pList->Next;
00203         pNew->Next->Prev = pNew;
00204         pNew->Prev->Next = pNew;
00205 return pNew;
00206 }

List* LISTCALL List_AddTail (  List *  pList,
void *  Data
) 
 

Definition at line 177 of file list.c.

References List::Data, LISTCALL, ListPool_g, MemPool_GetHunk(), List::Next, and List::Prev.

Referenced by RadixList_Add(). 

00178 {
00179 List * pNew;
00180 
00181         pNew = MemPool_GetHunk(ListPool_g);
00182         assert(pNew);
00183 
00184         pNew->Next = pList;
00185         pNew->Prev = pList->Prev;
00186         pNew->Next->Prev = pNew;
00187         pNew->Prev->Next = pNew;
00188         
00189         pNew->Data= Data;
00190 return pNew;
00191 }

List* LISTCALL List_Create (  void   ) 
 

Definition at line 166 of file list.c.

References List::Data, LISTCALL, ListPool_g, MemPool_GetHunk(), List::Next, NULL, and List::Prev.

Referenced by RadixList_Create(). 

00167 {
00168 List * pNew;
00169 
00170         pNew = MemPool_GetHunk(ListPool_g);
00171         assert(pNew);
00172         pNew->Data = NULL;
00173         pNew->Next = pNew->Prev = pNew;
00174 return pNew;
00175 }

void* LISTCALL List_CutHead (  List *  pList  ) 
 

Definition at line 208 of file list.c.

References List::Data, LISTCALL, ListPool_g, MemPool_FreeHunk(), List::Next, NULL, and List::Prev.

Referenced by RadixList_CutKey(), RadixList_CutMax(), and RadixList_CutMin(). 

00209 {
00210 List * pNode;
00211 void * pData;
00212         pNode = pList->Next;
00213         if ( pNode == pList ) return NULL;
00214         pData = pNode->Data;
00215 
00216         pList->Next = pNode->Next;
00217         pList->Next->Prev = pList;
00218 
00219         MemPool_FreeHunk(ListPool_g,pNode);
00220 
00221 return pData;
00222 }

void LISTCALL List_CutNode (  List *  pNode  ) 
 

Definition at line 257 of file list.c.

References LISTCALL, List::Next, and List::Prev.

Referenced by List_DeleteNode(). 

00258 {
00259         pNode->Prev->Next = pNode->Next;
00260         pNode->Next->Prev = pNode->Prev;
00261 
00262         pNode->Next = pNode->Prev = pNode;
00263 }

void* LISTCALL List_CutTail (  List *  pList  ) 
 

Definition at line 224 of file list.c.

References List::Data, LISTCALL, ListPool_g, MemPool_FreeHunk(), List::Next, NULL, and List::Prev. 

00225 {
00226 List * pNode;
00227 void * pData;
00228         pNode = pList->Prev;
00229         if ( pNode == pList ) return NULL;
00230         pData = pNode->Data;
00231 
00232         pList->Prev = pNode->Prev;
00233         pList->Prev->Next = pList;
00234 
00235         MemPool_FreeHunk(ListPool_g,pNode);
00236 
00237 return pData;
00238 }

void LISTCALL List_DeleteNode (  List *  pNode  ) 
 

Definition at line 265 of file list.c.

References List_CutNode(), List_FreeNode(), and LISTCALL. 

00266 {
00267         List_CutNode(pNode);
00268         List_FreeNode(pNode);
00269 }

void LISTCALL List_Destroy (  List *  pList  ) 
 

Definition at line 151 of file list.c.

References LISTCALL, ListPool_g, MemPool_FreeHunk(), and List::Next.

Referenced by RadixList_Destroy(). 

00152 {
00153 List * pNode;
00154         assert(pList);
00155         pNode = pList->Next;
00156         while( pNode != pList )
00157         {
00158         List *Next;
00159                 Next = pNode->Next;
00160                 MemPool_FreeHunk(ListPool_g,pNode);
00161                 pNode = Next;
00162         }
00163         MemPool_FreeHunk(ListPool_g,pList);
00164 }

List* List_Find (  List *  pList,
void *  Data
) 
 

Definition at line 292 of file list.c.

References List::Data, List::Next, and NULL. 

00293 {
00294 List *pNode;
00295         assert(pList);
00296         for(pNode = pList->Next; pNode != pList; pNode = pNode->Next )
00297         {
00298                 if ( pNode->Data == Data )
00299                         return pNode;
00300         }
00301         return NULL;
00302 }

void LISTCALL List_FreeNode (  List *  pNode  ) 
 

Definition at line 271 of file list.c.

References LISTCALL, ListPool_g, and MemPool_FreeHunk().

Referenced by List_DeleteNode(). 

00272 {
00273         assert(pNode);
00274         MemPool_FreeHunk(ListPool_g,pNode);
00275 }

List* LISTCALL List_Next (  List *  pNode  ) 
 

Definition at line 283 of file list.c.

References LISTCALL, and List::Next. 

00284 {
00285         return pNode->Next;
00286 }

void* LISTCALL List_NodeData (  List *  pNode  ) 
 

Definition at line 277 of file list.c.

References List::Data, and LISTCALL. 

00278 {
00279         assert(pNode);
00280         return pNode->Data;
00281 }

void* LISTCALL List_PeekHead (  List *  pList  ) 
 

Definition at line 241 of file list.c.

References List::Data, LISTCALL, List::Next, and NULL. 

00242 {
00243 List * pNode;
00244         pNode = pList->Next;
00245         if ( pNode == pList ) return NULL;
00246 return pNode->Data;
00247 }

void* LISTCALL List_PeekTail (  List *  pList  ) 
 

Definition at line 249 of file list.c.

References List::Data, LISTCALL, NULL, and List::Prev. 

00250 {
00251 List * pNode;
00252         pNode = pList->Prev;
00253         if ( pNode == pList ) return NULL;
00254 return pNode->Data;
00255 }

List* LISTCALL List_Prev (  List *  pNode  ) 
 

Definition at line 287 of file list.c.

References LISTCALL, and List::Prev. 

00288 {
00289         return pNode->Prev;
00290 }

geBoolean List_Start (  void   ) 
 

you must wrap any calls to this module with these: *

Definition at line 1385 of file list.c.

References GE_FALSE, GE_TRUE, geBoolean, HashNodePool_g, LinkPool_g, ListPool_g, MemPool_Create(), NULL, and UsageCount.

Referenced by geTClip_Push(), geWorld_Create(), and Sys_EngineCreate(). 

01386 {
01387         assert(UsageCount >= 0 );
01388         if ( UsageCount == 0 )
01389         {
01390                 assert(ListPool_g == NULL && LinkPool_g == NULL);
01391                 if ( ! (ListPool_g = MemPool_Create(sizeof(List),1024,1024) ) )
01392                         return GE_FALSE;
01393                 if ( ! (LinkPool_g = MemPool_Create(sizeof(Link),128,128) ) )
01394                         return GE_FALSE;
01395                 if ( ! (HashNodePool_g = MemPool_Create(sizeof(HashNode),128,128) ) )
01396                         return GE_FALSE;
01397                 // could latch ListFuncs_Stop() on atexit() , but no need, really..
01398         }
01399         UsageCount ++;
01400         return GE_TRUE;
01401 }

geBoolean List_Stop (  void   ) 
 

Definition at line 1403 of file list.c.

References GE_TRUE, geBoolean, HashNodePool_g, LinkPool_g, ListPool_g, MemPool_Destroy(), NULL, and UsageCount.

Referenced by geTClip_Pop(), geWorld_Free(), and Sys_EngineFree(). 

01404 {
01405         assert(UsageCount > 0 );
01406         UsageCount --;
01407         if ( UsageCount == 0 )
01408         {
01409                 assert(ListPool_g && LinkPool_g );
01410                 MemPool_Destroy(&ListPool_g); ListPool_g = NULL;
01411                 MemPool_Destroy(&LinkPool_g); LinkPool_g = NULL;
01412                 MemPool_Destroy(&HashNodePool_g); HashNodePool_g = NULL;
01413         }
01414         return GE_TRUE;
01415 }

void List_TimerReport (  void   ) 
 

Definition at line 817 of file list.c.

References TIMER_REPORT. 

00818 {
00819 #ifdef DO_TIMER
00820         TIMER_REPORT(List_Ram);
00821         TIMER_REPORT(List_RadixWalk);
00822         TIMER_REPORT(List_RadixInit);
00823 #endif
00824 }

LinkNode* LISTCALL LN_CutHead (  LinkNode *  pList  ) 
 

Definition at line 123 of file list.c.

References LISTCALL, LN_Cut, LinkNode::Next, and NULL.

Referenced by RadixLN_CutKey(), RadixLN_CutMax(), and RadixLN_CutMin(). 

00124 {
00125 LinkNode * LN;
00126         assert(pList);
00127         LN = pList->Next;
00128         if ( LN == pList ) return NULL;
00129         LN_Cut(LN);
00130 return LN;
00131 }

LinkNode* LISTCALL LN_CutTail (  LinkNode *  pList  ) 
 

Definition at line 133 of file list.c.

References LISTCALL, LN_Cut, NULL, and LinkNode::Prev. 

00134 {
00135 LinkNode * LN;
00136         assert(pList);
00137         LN = pList->Prev;
00138         if ( LN == pList ) return NULL;
00139         LN_Cut(LN);
00140 return LN;
00141 }

int LN_ListLen (  LinkNode *  pList  ) 
 

Definition at line 111 of file list.c.

References LN_Walk. 

00112 {
00113 LinkNode *pNode;
00114 int Len=0;
00115         if ( ! pList )
00116                 return 0;
00117         LN_Walk(pNode,pList) {
00118                 Len++;
00119         }
00120 return Len;
00121 }

void RadixLink_Add (  RadixLink *  pRadixLink,
void *  Data,
int  Key
) 
 

Definition at line 760 of file list.c.

References Link_Push(), RadixLink::Links, RadixLink::Max, RadixLink::Min, RadixLink::NumLinks, and RadixLink_Grow(). 

00761 {
00762         assert(pRadixLink);
00763         assert( Key >= 0 );
00764 
00765         if ( Key >= pRadixLink->NumLinks )
00766                 RadixLink_Grow(pRadixLink, Key + (Key>>2) );
00767 
00768         Link_Push(&(pRadixLink->Links[Key]),Data);
00769 
00770         if ( Key < pRadixLink->Min ) pRadixLink->Min = Key;
00771         if ( Key > pRadixLink->Max ) pRadixLink->Max = Key;
00772 }

RadixLink* RadixLink_Create (  int  RadixLinkMax  ) 
 

Definition at line 714 of file list.c.

References RadixLink::Links, RadixLink::Max, MemAlloc, RadixLink::Min, and RadixLink::NumLinks. 

00715 {
00716 RadixLink * pRadixLink;
00717         pRadixLink = new(RadixLink);
00718         assert(pRadixLink);
00719         pRadixLink->NumLinks = RadixLinkMax+1;
00720         pRadixLink->Links = MemAlloc(sizeof(Link)*(pRadixLink->NumLinks));
00721         assert(pRadixLink->Links);
00722         //memset(pRadixLink->Links,0,(sizeof(Link)*(pRadixLink->NumLinks)));
00723         pRadixLink->Min = pRadixLink->NumLinks;
00724         pRadixLink->Max = - 1;
00725 return pRadixLink;
00726 }

void* RadixLink_CutKey (  RadixLink *  pRadixLink,
int  Key
) 
 

Definition at line 808 of file list.c.

References Link_Pop(), and RadixLink::Links. 

00809 {
00810         assert(pRadixLink);
00811 return Link_Pop(&(pRadixLink->Links[Key]));
00812 }

void* RadixLink_CutMax (  RadixLink *  pRadixLink,
int *  pKey
) 
 

Definition at line 774 of file list.c.

References Link_Pop(), RadixLink::Links, RadixLink::Max, Link::Next, and NULL. 

00775 {
00776 Link * pLink;
00777         pLink = (pRadixLink->Links) + (pRadixLink->Max);
00778         while ( pRadixLink->Max >= 0 )
00779         {
00780                 if ( pLink->Next )
00781                 {
00782                         if ( pKey ) *pKey = pRadixLink->Max;
00783                         return Link_Pop(pLink);
00784                 }
00785                 pRadixLink->Max --;
00786                 pLink --;
00787         }
00788 return NULL;
00789 }

void* RadixLink_CutMin (  RadixLink *  pRadixLink,
int *  pKey
) 
 

Definition at line 791 of file list.c.

References Link_Pop(), RadixLink::Links, RadixLink::Min, Link::Next, NULL, and RadixLink::NumLinks. 

00792 {
00793 Link * pLink;
00794         pLink = (pRadixLink->Links) + (pRadixLink->Min);
00795         while ( pRadixLink->Min < pRadixLink->NumLinks )
00796         {
00797                 if ( pLink->Next )
00798                 {
00799                         if ( pKey ) *pKey = pRadixLink->Min;
00800                         return Link_Pop(pLink);
00801                 }
00802                 pRadixLink->Min ++;
00803                 pLink ++;
00804         }
00805 return NULL;
00806 }

void RadixLink_Destroy (  RadixLink *  pRadixLink  ) 
 

Definition at line 747 of file list.c.

References Link_Destroy(), RadixLink::Links, MemFree, RadixLink::NumLinks, and r. 

00748 {
00749 int r;
00750         assert(pRadixLink);
00751         for(r=0;r<(pRadixLink->NumLinks);r++)
00752         {
00753                 if ( pRadixLink->Links[r].Next )
00754                         Link_Destroy(pRadixLink->Links[r].Next);
00755         }
00756         MemFree(pRadixLink->Links);
00757         MemFree(pRadixLink);
00758 }

void RadixLink_Grow (  RadixLink *  pRadixLink,
int  NewMax
) 
 

Definition at line 728 of file list.c.

References RadixLink::Links, MemAlloc, MemFree, and RadixLink::NumLinks.

Referenced by RadixLink_Add(). 

00729 {
00730 Link * OldLinks;
00731 int OldNumLinks;
00732 
00733         OldNumLinks = pRadixLink->NumLinks;
00734         OldLinks = pRadixLink->Links;
00735 
00736         pRadixLink->NumLinks = NewMax + 1;
00737         pRadixLink->Links = MemAlloc(sizeof(Link)*(pRadixLink->NumLinks));
00738 
00739         assert(pRadixLink->Links);
00740 
00741         memcpy(pRadixLink->Links, OldLinks, (sizeof(Link)*OldNumLinks));
00742         //memset(pRadixLink->Links + OldNumLinks,0,(sizeof(Link)*(pRadixLink->NumLinks - OldNumLinks)));
00743 
00744         MemFree(OldLinks);
00745 }

List* RadixList_Add (  RadixList *  pRadixList,
void *  Data,
int  Key
) 
 

Definition at line 484 of file list.c.

References List_AddTail(), RadixList::Lists, RadixList::Max, and RadixList::Min. 

00485 {
00486 List * l;
00487         assert(pRadixList);
00488         assert( Key < pRadixList->NumLists && Key >= 0 );
00489         l = List_AddTail(pRadixList->Lists[Key],Data);
00490         if ( Key < pRadixList->Min ) pRadixList->Min = Key;
00491         if ( Key > pRadixList->Max ) pRadixList->Max = Key;
00492 return l;
00493 }

RadixList* RadixList_Create (  int  RadixListMax  ) 
 

Definition at line 453 of file list.c.

References List_Create(), RadixList::Lists, RadixList::Max, MemAlloc, RadixList::Min, RadixList::NumLists, and r. 

00454 {
00455 RadixList * pRadixList;
00456 int r;
00457         pRadixList = new(RadixList);
00458         assert(pRadixList);
00459         pRadixList->NumLists = RadixListMax+1;
00460         pRadixList->Lists = MemAlloc(sizeof(List *)*(pRadixList->NumLists));
00461         assert(pRadixList->Lists);
00462         for(r=0;r<(pRadixList->NumLists);r++)
00463         {
00464                 pRadixList->Lists[r] = List_Create();
00465                 assert(pRadixList->Lists[r]);
00466         }
00467         pRadixList->Min = pRadixList->NumLists;
00468         pRadixList->Max = - 1;
00469 return pRadixList;
00470 }

void* RadixList_CutKey (  RadixList *  pRadixList,
int  Key
) 
 

Definition at line 535 of file list.c.

References List_CutHead(), and RadixList::Lists. 

00536 {
00537         assert(pRadixList);
00538 return List_CutHead(pRadixList->Lists[Key]);
00539 }

void* RadixList_CutMax (  RadixList *  pRadixList,
int *  pKey
) 
 

Definition at line 495 of file list.c.

References List_CutHead(), RadixList::Lists, RadixList::Max, and NULL. 

00496 {
00497         assert(pRadixList);
00498 
00499         while ( pRadixList->Max >= 0 )
00500         {
00501         void * Data;
00502 
00503                 if ( Data = List_CutHead(pRadixList->Lists[pRadixList->Max]) )
00504                 {
00505                         if ( pKey ) *pKey = pRadixList->Max;
00506                         return Data;    
00507                 }
00508                 pRadixList->Max --;
00509 
00510         }
00511 
00512 return NULL;
00513 }

void* RadixList_CutMin (  RadixList *  pRadixList,
int *  pKey
) 
 

Definition at line 515 of file list.c.

References List_CutHead(), RadixList::Lists, RadixList::Min, NULL, and RadixList::NumLists. 

00516 {
00517         assert(pRadixList);
00518 
00519         while ( pRadixList->Min < pRadixList->NumLists )
00520         {
00521         void * Data;
00522 
00523                 if ( Data = List_CutHead(pRadixList->Lists[pRadixList->Min]) )
00524                 {
00525                         if ( pKey ) *pKey = pRadixList->Min;
00526                         return Data;    
00527                 }
00528                 pRadixList->Min ++;
00529 
00530         }
00531 
00532 return NULL;
00533 }

void RadixList_Destroy (  RadixList *  pRadixList  ) 
 

Definition at line 472 of file list.c.

References List_Destroy(), RadixList::Lists, MemFree, RadixList::NumLists, and r. 

00473 {
00474 int r;
00475         assert(pRadixList);
00476         for(r=0;r<(pRadixList->NumLists);r++)
00477         {
00478                 List_Destroy(pRadixList->Lists[r]);
00479         }
00480         MemFree(pRadixList->Lists);
00481         MemFree(pRadixList);
00482 }

void RadixLN_AddHead (  RadixLN *  pRadixLN,
LinkNode *  LN,
int  Key
) 
 

Definition at line 584 of file list.c.

References LN_AddHead, RadixLN::LNs, RadixLN::Max, and RadixLN::Min. 

00585 {
00586         assert(pRadixLN);
00587         assert( Key < pRadixLN->NumLNs && Key >= 0 );
00588         LN_AddHead(&(pRadixLN->LNs[Key]),LN);
00589         if ( Key < pRadixLN->Min ) pRadixLN->Min = Key;
00590         if ( Key > pRadixLN->Max ) pRadixLN->Max = Key;
00591 }

void RadixLN_AddTail (  RadixLN *  pRadixLN,
LinkNode *  LN,
int  Key
) 
 

Definition at line 593 of file list.c.

References LN_AddTail, RadixLN::LNs, RadixLN::Max, and RadixLN::Min. 

00594 {
00595         assert(pRadixLN);
00596         assert( Key < pRadixLN->NumLNs && Key >= 0 );
00597         LN_AddTail(&(pRadixLN->LNs[Key]),LN);
00598         if ( Key < pRadixLN->Min ) pRadixLN->Min = Key;
00599         if ( Key > pRadixLN->Max ) pRadixLN->Max = Key;
00600 }

RadixLN* RadixLN_Create (  int  RadixLNMax  ) 
 

Definition at line 550 of file list.c.

References RadixLN::LNs, RadixLN::Max, MemAlloc, RadixLN::Min, LinkNode::Next, RadixLN::NumLNs, LinkNode::Prev, r, TIMER_P, and TIMER_Q. 

00551 {
00552 RadixLN * pRadixLN;
00553 LinkNode * LNs;
00554 int r;
00555         pRadixLN = new(RadixLN);
00556         assert(pRadixLN);
00557         pRadixLN->NumLNs = RadixLNMax+1;
00558         pRadixLN->LNs = MemAlloc(sizeof(LinkNode)*(pRadixLN->NumLNs));
00559         assert(pRadixLN->LNs);
00560 
00561 TIMER_P(List_RadixInit); // not counting the allocs, tracking in List_Ram
00562 
00563         LNs = pRadixLN->LNs;
00564         for(r=(pRadixLN->NumLNs);r--;LNs++)
00565         {
00566                 // LN_InitList( LNs );
00567                 LNs->Next = LNs->Prev = LNs;
00568         }
00569         pRadixLN->Min = RadixLNMax;
00570         pRadixLN->Max = 0;
00571         
00572 TIMER_Q(List_RadixInit);
00573 
00574 return pRadixLN;
00575 }

LinkNode* RadixLN_CutKey (  RadixLN *  pRadixLN,
int  Key
) 
 

Definition at line 646 of file list.c.

References LN_CutHead(), and RadixLN::LNs. 

00647 {
00648         assert(pRadixLN);
00649 return LN_CutHead(&(pRadixLN->LNs[Key]));
00650 }

LinkNode* RadixLN_CutMax (  RadixLN *  pRadixLN,
int *  pKey
) 
 

Definition at line 602 of file list.c.

References LN_CutHead(), RadixLN::LNs, RadixLN::Max, NULL, TIMER_P, and TIMER_Q. 

00603 {
00604         assert(pRadixLN);
00605 
00606 TIMER_P(List_RadixWalk);
00607         while ( pRadixLN->Max >= 0 )
00608         {
00609         LinkNode * LN;
00610 
00611                 if ( LN = LN_CutHead(&(pRadixLN->LNs[pRadixLN->Max])) )
00612                 {
00613                         if ( pKey ) *pKey = pRadixLN->Max;
00614 TIMER_Q(List_RadixWalk);
00615                         return LN;
00616                 }
00617                 pRadixLN->Max --;
00618         }
00619 TIMER_Q(List_RadixWalk);
00620 
00621 return NULL;
00622 }

LinkNode* RadixLN_CutMin (  RadixLN *  pRadixLN,
int *  pKey
) 
 

Definition at line 624 of file list.c.

References LN_CutHead(), RadixLN::LNs, RadixLN::Max, RadixLN::Min, NULL, RadixLN::NumLNs, TIMER_P, and TIMER_Q. 

00625 {
00626         assert(pRadixLN);
00627 
00628 TIMER_P(List_RadixWalk);
00629         while ( pRadixLN->Min < pRadixLN->NumLNs )
00630         {
00631         LinkNode * LN;
00632 
00633                 if ( LN = LN_CutHead(&(pRadixLN->LNs[pRadixLN->Min])) )
00634                 {
00635                         if ( pKey ) *pKey = pRadixLN->Max;
00636 TIMER_Q(List_RadixWalk);
00637                         return LN;
00638                 }
00639                 pRadixLN->Min ++;
00640         }
00641 TIMER_Q(List_RadixWalk);
00642 
00643 return NULL;
00644 }

void RadixLN_Destroy (  RadixLN *  pRadixLN  ) 
 

Definition at line 577 of file list.c.

References RadixLN::LNs, and MemFree. 

00578 {
00579         assert(pRadixLN);
00580         MemFree(pRadixLN->LNs);
00581         MemFree(pRadixLN);
00582 }

LinkNode* RadixLN_PeekMax (  RadixLN *  pRadixLN,
int *  pKey
) 
 

Definition at line 653 of file list.c.

References RadixLN::LNs, RadixLN::Max, LinkNode::Next, NULL, TIMER_P, and TIMER_Q. 

00654 {
00655 LinkNode * LNs;
00656         assert(pRadixLN);
00657 
00658 TIMER_P(List_RadixWalk);
00659         LNs = & pRadixLN->LNs[pRadixLN->Max];
00660         while ( pRadixLN->Max >= 0 )
00661         {
00662         LinkNode * LN;
00663 
00664                 LN = LNs->Next;
00665                 if ( LN != LNs )
00666                 {
00667                         if ( pKey ) *pKey = pRadixLN->Max;
00668 TIMER_Q(List_RadixWalk);
00669                         return LN;
00670                 }
00671                 pRadixLN->Max --;
00672                 LNs --;
00673         }
00674 TIMER_Q(List_RadixWalk);
00675 
00676 return NULL;
00677 }

LinkNode* RadixLN_PeekMin (  RadixLN *  pRadixLN,
int *  pKey
) 
 

Definition at line 679 of file list.c.

References RadixLN::LNs, RadixLN::Min, LinkNode::Next, NULL, RadixLN::NumLNs, TIMER_P, and TIMER_Q. 

00680 {
00681 LinkNode * LNlist;
00682         assert(pRadixLN);
00683 
00684 TIMER_P(List_RadixWalk);
00685         LNlist = & pRadixLN->LNs[pRadixLN->Min];
00686         while ( pRadixLN->Min < pRadixLN->NumLNs )
00687         {
00688         LinkNode * LN;
00689 
00690                 LN = LNlist->Next;
00691                 if ( LN != LNlist )
00692                 {
00693                         if ( pKey ) *pKey = pRadixLN->Min;
00694 TIMER_Q(List_RadixWalk);
00695                         return LN;
00696                 }
00697                 pRadixLN->Min ++;
00698                 LNlist ++;
00699         }
00700 TIMER_Q(List_RadixWalk);
00701 
00702 return NULL;
00703 }

Stack* LISTCALL Stack_Create (  void   ) 
 

Definition at line 396 of file list.c.

References Stack::Buffer, Stack::End, Stack::Head, LISTCALL, MemAlloc, and Stack::members. 

00397 {
00398 Stack * pStack;
00399         pStack = new(Stack);
00400         assert(pStack);
00401         pStack->members = 4096;
00402         pStack->Buffer = MemAlloc(sizeof(void *)*(pStack->members));
00403         assert(pStack->Buffer);
00404         pStack->End = pStack->Buffer + (pStack->members);
00405         pStack->Head = pStack->Buffer;
00406 return pStack;
00407 }

void LISTCALL Stack_Destroy (  Stack *  pStack  ) 
 

Definition at line 387 of file list.c.

References Stack::Buffer, destroy, and LISTCALL. 

00388 {
00389         if ( pStack )
00390         {
00391                 destroy(pStack->Buffer);
00392                 destroy(pStack);
00393         }
00394 }

int LISTCALL Stack_Extend (  Stack *  pStack  ) 
 

Definition at line 409 of file list.c.

References Stack::Buffer, Stack::End, Stack::Head, LISTCALL, MemAlloc, Stack::members, and MemFree.

Referenced by Stack_Push_Func(). 

00410 {
00411 void ** NewBuffer;
00412 int newmembers;
00413         // realloc
00414         newmembers = pStack->members + 4096;
00415         NewBuffer = MemAlloc(sizeof(void *)*newmembers);
00416         assert(NewBuffer);
00417         memcpy(NewBuffer,pStack->Buffer, sizeof(void *)*(pStack->members));
00418         pStack->Head = NewBuffer + pStack->members;
00419         pStack->members = newmembers;
00420         MemFree(pStack->Buffer);
00421         pStack->Buffer = NewBuffer;
00422 
00423         pStack->End = pStack->Buffer + (pStack->members);
00424 return newmembers;
00425 }

void* LISTCALL Stack_Pop_Func (  Stack *  pStack  ) 
 

Definition at line 435 of file list.c.

References Stack::Buffer, Stack::Head, LISTCALL, and NULL. 

00436 {
00437         assert(pStack);
00438         if ( pStack->Head == pStack->Buffer )
00439                 return NULL;
00440         pStack->Head --;
00441 return *(pStack->Head);
00442 }

void LISTCALL Stack_Push_Func (  Stack *  pStack,
void *  Data
) 
 

Definition at line 427 of file list.c.

References Stack::End, Stack::Head, LISTCALL, and Stack_Extend(). 

00428 {
00429         assert(pStack);
00430         *(pStack->Head)++ = Data;
00431         if ( pStack->Head == pStack->End )
00432                 Stack_Extend(pStack);
00433 }

Variable Documentation

MemPool * HashNodePool_g = NULL [static]
 

Definition at line 106 of file list.c.

Referenced by Hash_Add(), Hash_Create(), Hash_DeleteNode(), Hash_Destroy(), List_Start(), and List_Stop().

MemPool * LinkPool_g = NULL [static]
 

Definition at line 106 of file list.c.

Referenced by Link_Create(), Link_Destroy(), Link_Pop(), Link_Push(), List_Start(), and List_Stop().

MemPool* ListPool_g = NULL [static]
 

Definition at line 106 of file list.c.

Referenced by List_AddHead(), List_AddTail(), List_Create(), List_CutHead(), List_CutTail(), List_Destroy(), List_FreeNode(), List_Start(), and List_Stop().

int UsageCount = 0 [static]
 

Definition at line 107 of file list.c.

Referenced by List_Start(), and List_Stop().

Generated on Tue Sep 30 12:37:45 2003 for GTestAndEngine by doxygen 1.3.2