mem_chunk->mem_area->free = mem_chunk->area_size;      mem_chunk->mem_area->used = 0;    }/* * Get the memory and modify the state variables appropriately. */  mem = (vpointer) &(mem_chunk->mem_area->mem[mem_chunk->mem_area->index]);  mem_chunk->mem_area->index += mem_chunk->atom_size;  mem_chunk->mem_area->free -= mem_chunk->atom_size;  mem_chunk->mem_area->used++;#if MEMORY_PADDING==TRUE  set_pad_low(mem_chunk, mem);  set_pad_high(mem_chunk, mem);/*  if (check_pad_low(mem_chunk, mem)!=0) die("LOW MEMORY_PADDING ALREADY CORRUPT!");  if (check_pad_high(mem_chunk, mem)!=0) die("HIGH MEMORY_PADDING ALREADY CORRUPT!");*/  mem = BUMP_UP(mem);#endif  return mem;  }void mem_chunk_free_real(MemChunk *mem_chunk, void *mem)  {  MemArea *temp_area;  FreeAtom *free_atom;  if (!mem_chunk) die("Null pointer to mem_chunk passed.");  if (!mem_chunk->mem_tree) die("MemChunk passed has no freeable atoms.");  if (!mem) die("NULL pointer passed.");#if MEMORY_PADDING==TRUE  mem = BUMP_DOWN(mem);  if (check_pad_low(mem_chunk, mem)!=0)    dief("LOW MEMORY_PADDING CORRUPT! (%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);  if (check_pad_high(mem_chunk, mem)!=0)    dief("HIGH MEMORY_PADDING CORRUPT!(%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);#endif/* * Place the memory on the "free_atoms" list. */  free_atom = (FreeAtom*) mem;  free_atom->next = mem_chunk->free_atoms;  mem_chunk->free_atoms = free_atom;  if (!(temp_area = ordered_search(mem_chunk->mem_tree, mem)) )    die("Unable to find temp_area.");  temp_area->used--;  if (temp_area->used == 0)    {    mem_chunk->num_unused_areas++;    }  return;  }/* This doesn't free the free_area if there is one */void mem_chunk_clean_real(MemChunk *mem_chunk)  {  MemArea *mem_area;  FreeAtom *prev_free_atom;  FreeAtom *temp_free_atom;  void *mem;  if (!mem_chunk) die("Null pointer to mem_chunk passed.");  if (!mem_chunk->mem_tree) die("MemChunk passed has no freeable atoms.");  if (mem_chunk->mem_tree)    {    prev_free_atom = NULL;    temp_free_atom = mem_chunk->free_atoms;    while (temp_free_atom)      {      mem = (vpointer) temp_free_atom;      if (!(mem_area = ordered_search(mem_chunk->mem_tree, mem)) ) die("mem_area not found.");/* * If this memory area is unused, delete the area, list node and decrement the free mem. */      if (mem_area->used==0)        {        if (prev_free_atom)          prev_free_atom->next = temp_free_atom->next;        else          mem_chunk->free_atoms = temp_free_atom->next;        temp_free_atom = temp_free_atom->next;        mem_area->free += mem_chunk->atom_size;        if (mem_area->free == mem_chunk->area_size)          {          mem_chunk->num_mem_areas--;          mem_chunk->num_unused_areas--;          if (mem_area->next)          mem_area->next->prev = mem_area->prev;          if (mem_area->prev)            mem_area->prev->next = mem_area->next;          if (mem_area == mem_chunk->mem_areas)            mem_chunk->mem_areas = mem_chunk->mem_areas->next;          if (mem_area == mem_chunk->mem_area)            mem_chunk->mem_area = NULL;           if (mem_chunk->mem_tree)            {            if (!remove_key(mem_chunk->mem_tree, (Key_t) mem_area))              die("mem_area not found.");            }          free(mem_area);          }        }      else        {        prev_free_atom = temp_free_atom;        temp_free_atom = temp_free_atom->next;        }      }    }  return;  }void mem_chunk_reset_real(MemChunk *mem_chunk)  {  MemArea *mem_areas;  MemArea *temp_area;    if (!mem_chunk) die("Null pointer to mem_chunk passed.");    mem_areas = mem_chunk->mem_areas;  mem_chunk->num_mem_areas = 0;  mem_chunk->mem_areas = NULL;  mem_chunk->mem_area = NULL;    while (mem_areas)    {    temp_area = mem_areas;    mem_areas = mem_areas->next;    free(temp_area);    }    mem_chunk->free_atoms = NULL;    if (mem_chunk->mem_tree)    {    delete(mem_chunk->mem_tree);    mem_chunk->mem_tree = tree_new();    }  return;  }#if MEMORY_PADDING==TRUEstatic int memarea_check_bounds(MemChunk *mem_chunk, MemArea *mem_area)  {  int		count = 0;  unsigned char	*mem;  int		index = 0;  while (index < mem_area->index)    {    mem = (unsigned char*) &mem_area->mem[index];    if (check_pad_low(mem_chunk, mem)!=0) count++;    if (check_pad_high(mem_chunk, mem)!=0) count++;    index += mem_chunk->atom_size;    }  return count;  }boolean mem_chunk_check_all_bounds_real(MemChunk *mem_chunk)  {  MemArea	*mem_area;  int		badcount=0;    if (!mem_chunk) die("Null pointer to mem_chunk passed.");    mem_area = mem_chunk->mem_areas;    while (mem_area)    {    if (mem_chunk->mem_area->used>0)      {      badcount += memarea_check_bounds(mem_chunk, mem_area);      mem_area = mem_area->next;      }    }  printf("%d pads corrupt or free.\n", badcount);    return badcount>0;  }boolean mem_chunk_check_bounds_real(MemChunk *mem_chunk, void *mem)  {  mem = BUMP_DOWN(mem);  if (check_pad_low(mem_chunk, mem)!=0)    dief("Low padding corrupt! (%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);  if (check_pad_high(mem_chunk, mem)!=0)    dief("High padding corrupt!(%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);  return TRUE;  }#elseboolean mem_chunk_check_all_bounds_real(MemChunk *mem_chunk)  {  return TRUE;  }boolean mem_chunk_check_bounds_real(MemChunk *mem_chunk, void *mem)  {  return TRUE;  }#endifboolean mem_chunk_test_real(void)  {  unsigned char	*tmem[10000];  MemChunk	*tmem_chunk=NULL;  size_t	atomsize=40;  int		i, j;  printf("checking mem chunks...\n");  tmem_chunk = mem_chunk_new(atomsize, 100);  printf("alloc*1000...\n");  for (i = 0; i < 1000; i++)    {    tmem[i] = mem_chunk_alloc(tmem_chunk);    *tmem[i] = i%254;    }  for (i = 0; i < 1000; i++)    {    mem_chunk_check_bounds_real(tmem_chunk, tmem[i]);    }  printf("free*500...\n");  for (i = 0; i < 500; i++)    {    mem_chunk_free(tmem_chunk, tmem[i]);    }  for (i = 500; i < 1000; i++)    {    mem_chunk_check_bounds_real(tmem_chunk, tmem[i]);    }  printf("alloc*500...\n");  for (i = 0; i < 500; i++)    {    tmem[i] = mem_chunk_alloc(tmem_chunk);    *tmem[i] = i%254;    }  for (i = 0; i < 1000; i++)    {    mem_chunk_check_bounds_real(tmem_chunk, tmem[i]);    }  printf("free*1000...\n");  for (i = 0; i < 1000; i++)    {    if (*tmem[i] != i%254) die("Uh oh.");    for (j = i; j<1000; j++)      mem_chunk_check_bounds_real(tmem_chunk, tmem[j]);    mem_chunk_free(tmem_chunk, tmem[i]);    }  printf("ok.\n");  return TRUE;  }void mem_chunk_diagnostics_real(void)  {  printf("=== mem_chunk diagnostics ====================================\n");  printf("Version:                   %s\n", GA_VERSION_STRING);  printf("Build date:                %s\n", GA_BUILD_DATE_STRING);  printf("Compilation machine characteristics:\n%s\n", GA_UNAME_STRING);  printf("--------------------------------------------------------------\n");  printf("MEMORY_PADDING:    %s\n", MEMORY_PADDING?"TRUE":"FALSE");  printf("MEMORY_ALIGN_SIZE  %zd\n", MEMORY_ALIGN_SIZE);  printf("MEMORY_AREA_SIZE   %ld\n", MEMORY_AREA_SIZE);  printf("--------------------------------------------------------------\n");  printf("structure          sizeof\n");  printf("FreeAtom           %lu\n", (unsigned long) sizeof(FreeAtom));  printf("MemArea            %lu\n", (unsigned long) sizeof(MemArea));  printf("MemChunk           %lu\n", (unsigned long) sizeof(MemChunk));  printf("==============================================================\n");  return;  }/* * The following functions mimic the Memory chunk API, but are just * wrappers around the system malloc. *//* * Return TRUE is the memory chunk is empty. */boolean mem_chunk_isempty_mimic(MemChunk *mem_chunk)  {  if (!mem_chunk) die("Null pointer to mem_chunk passed.");  return mem_chunk->num_atoms_alloc==0;  }/* * Create new memory chunk. */MemChunk *mem_chunk_new_mimic(size_t atom_size, unsigned int num_atoms)  {  MemChunk	*mem_chunk;  mem_chunk = malloc(sizeof(MemChunk));  if (!mem_chunk) die("Unable to allocate memory.");  mem_chunk->atom_size = atom_size;  mem_chunk->num_atoms_alloc = 0;  return mem_chunk;  }MemChunk *mem_chunk_new_unfreeable_mimic(size_t atom_size, unsigned int num_atoms)  {  return mem_chunk_new(atom_size, num_atoms);  }boolean mem_chunk_has_freeable_atoms_mimic(MemChunk *mem_chunk)  {  return TRUE;  }void mem_chunk_destroy_mimic(MemChunk *mem_chunk)  {  if (!mem_chunk) die("Null pointer to mem_chunk passed.");    free(mem_chunk);  return;  }void *mem_chunk_alloc_mimic(MemChunk *mem_chunk)  {  void	*mem;  if (!mem_chunk) die("Null pointer to mem_chunk passed.");  mem_chunk->num_atoms_alloc++;  mem = malloc(mem_chunk->atom_size);  if (!mem) die("Unable to allocate memory.");    return mem;  }void mem_chunk_free_mimic(MemChunk *mem_chunk, void *mem)  {  if (!mem_chunk) die("Null pointer to mem_chunk passed.");  if (!mem) die("Null pointer to memory passed.");  free(mem);  mem_chunk->num_atoms_alloc--;  return;  }void mem_chunk_clean_mimic(MemChunk *mem_chunk)  {  if (!mem_chunk) die("Null pointer to mem_chunk passed.");  mem_chunk->num_atoms_alloc=0;  return;  }void mem_chunk_reset_mimic(MemChunk *mem_chunk)  {    if (!mem_chunk) die("Null pointer to mem_chunk passed.");    mem_chunk->num_atoms_alloc=0;  return;  }boolean mem_chunk_check_bounds_mimic(MemChunk *mem_chunk, void *mem)  {  return TRUE;  }boolean mem_chunk_test_mimic(void)  {  return TRUE;  }void mem_chunk_diagnostics_mimic(void)  {  printf("=== mem_chunk diagnostics *** MIMIC *** ======================\n");  printf("Version:                   %s\n", GA_VERSION_STRING);  printf("Build date:                %s\n", GA_BUILD_DATE_STRING);  printf("Compilation machine characteristics:\n%s\n", GA_UNAME_STRING);  printf("--------------------------------------------------------------\n");  printf("structure          sizeof\n");  printf("MemChunk           %lu\n", (unsigned long) sizeof(MemChunk));  printf("==============================================================\n");  return;  }