~drizzle-trunk/drizzle/development

  mem_root->block_num= 4;                       /* We shift this with >>2 */

  mem_root->first_block_usage= 0;

 

  return;

}

 

        {

          /* remove block from the list and free it */

          *prev= mem->next;

        }

        else

          prev= &mem->next;

      }

      /* Allocate new prealloc block and add it to the end of free list */

      {

        mem->left= pre_alloc_size;

        mem->next= *prev;

      }

      else

      {

 

void *alloc_root(MEM_ROOT *mem_root, size_t length)

{

  size_t get_size, block_size;

  register USED_MEM *next= 0;

  register USED_MEM **prev;

  assert(alloc_root_inited(mem_root));

  {                                             /* Time to alloc new block */

    block_size= mem_root->block_size * (mem_root->block_num >> 2);

    get_size= length+ALIGN_SIZE(sizeof(USED_MEM));

 

    {

      if (mem_root->error_handler)

        (*mem_root->error_handler)();

    *prev=next;

  }

 

  /*TODO: next part may be unneded due to mem_root->first_block_usage counter*/

  if ((next->left-= length) < mem_root->min_malloc)

  {                                             /* Full block */

    mem_root->first_block_usage= 0;

  }

  return((void*) point);

}

 

 

  {

    old=next; next= next->next ;

    if (old != root->pre_alloc)

  }

  for (next=root->free ; next ;)

  {

    old=next; next= next->next;

    if (old != root->pre_alloc)

  }

  root->used=root->free=0;

  if (root->pre_alloc)

char *strmake_root(MEM_ROOT *root, const char *str, size_t len)

{

  char *pos;

  {

    memcpy(pos,str,len);

    pos[len]=0;

 

void *memdup_root(MEM_ROOT *root, const void *str, size_t len)

{

  if ((pos=alloc_root(root,len)))