Search  

---

C:/temp/src/j2k/Beta/FreeList.c

Go to the documentation of this file.

#ifndef __J2K__FreeList_C__
#define __J2K__FreeList_C__   1

#include "FreeList.h"

/*
   This function must be call in order to create a valid FreeList.

   GOTCHA:
   =======
     1. Don't hard code 4 bytes (32-bit address space), due to 16 and 64 bit machines !
     
     2. Doing a FreeList of char is equivalent to doing a FreeList of int or double !

     3. Notice that this way we save 4 bytes per FreeLink, so basically the FreeList 
        don't cost any space per item except the FreeList container itself 
        which is merely 8 bytes !
*/
FreeList_t* FreeList_create( register size_t sz )
{
  FreeList_t* fl = (FreeList_t*)malloc( sizeof( FreeList_t ) );

  /* Make sure the memory was allocated */
  assert( fl != NULL );

  /* Initialized the head, else purge and other won't work */
  fl->head = NULL;

  /* Make sure the allocate data can be convert into 'FreeLink_t* next' pointers */
  if ( sz >= sizeof( FreeLink_t* ) )
  {
    /* It's big enough */
    fl->size = sz;
  }
  else
  {
    /* Make it big enough */
    fl->size = sizeof( FreeLink_t* );
  }

#ifdef __J2K__DEBUG_TRACE
  printf( "Needed space:    [%d]\n", sz  );
  printf( "Allocated space: [%d]\n", fl->size );
  printf( "FreeList  space: [%d]\n", sizeof( FreeList_t ) );
  fflush( stdout );
#endif

  /* Here's your initialized empty FreeList */
  return fl;
}

/*
   Allocate the desired amount of memory,
   if no FreeList link available 
*/
void* FreeList_calloc( FreeList_t* this )
{
  /* The current head if ain't NULL 
      - OR -
     the new allocated memory to be used and returned 
  */
  register void* curr = NULL;

  /* Make sure the object pointer is valid */
  assert( this != NULL );

  if ( this->head != NULL )
  {
    /* Pop out of the FreeList stack a dead structure */
          curr = this->head;
    this->head = this->head->next;
  }
  else
  {
    /* No FreeList Link available, so do a real malloc */
    curr = malloc( this->size );  

    /* Make sure the memory was allocated */
    assert( curr != NULL );
  }

  /* Zero out the NEW allocated structure */
  memset( curr, 0, this->size );

  /* Here's your zero'ed out structure */
  return curr;
}

/* 
   Falsely delete the dead structure, 
   by stacking it up to the FreeList,
   for future usage.
*/
void FreeList_free( FreeList_t* this, void* dead )
{
  /* Make sure the object pointer is valid */
  assert( this != NULL );

  /* Convert the dead structure to a link to be stack up */
  FreeLink_t* link = (FreeLink_t*)dead;
  link->next = this->head;
  this->head = link;
}

/*
   Really destroy the entire FreeList elements
*/
void FreeList_purge( FreeList_t* this )
{
  /* Current purging pointer */
  register FreeLink_t* curr = NULL

  /* Make sure the object pointer is valid */
  assert( this != NULL );

  /* Go through the entire list and free every link */
  while( this->head != NULL )
  {
          curr = this->head;
    this->head = this->head->next;
    free( curr );
  }
}

/*
   Really destroy the entire FreeList elements
   including the FreeList itself.
*/
void FreeList_delete( FreeList_t* this )
{
  /* Make sure the object pointer is valid */
  assert( this != NULL );

  /* Free every link */
  FreeList_purge( this );

  /* Free the object itself */
  free( this );
}

#endif

---