[apple/libc.git] / regex / TRE / lib / tre-mem.c

/*
  tre-mem.c - TRE memory allocator

  This software is released under a BSD-style license.
  See the file LICENSE for details and copyright.

*/

/*
  This memory allocator is for allocating small memory blocks efficiently
  in terms of memory overhead and execution speed.  The allocated blocks
  cannot be freed individually, only all at once.  There can be multiple
  allocators, though.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /* HAVE_CONFIG_H */
#include <stdlib.h>
#include <string.h>

#include "tre-internal.h"
#include "tre-mem.h"
#include "xmalloc.h"


/* Returns a new memory allocator or NULL if out of memory. */
tre_mem_t
tre_mem_new_impl(int provided, void *provided_block)
{
  tre_mem_t mem;
  if (provided)
    {
      mem = provided_block;
      memset(mem, 0, sizeof(*mem));
    }
  else
    mem = xcalloc(1, sizeof(*mem));
  if (mem == NULL)
    return NULL;
  return mem;
}


/* Frees the memory allocator and all memory allocated with it. */
void
tre_mem_destroy(tre_mem_t mem)
{
  tre_list_t *tmp, *l = mem->blocks;

  while (l != NULL)
    {
      xfree(l->data);
      tmp = l->next;
      xfree(l);
      l = tmp;
    }
  xfree(mem);
}


/* Allocates a block of `size' bytes from `mem'.  Returns a pointer to the
   allocated block or NULL if an underlying malloc() failed. */
void *
tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
		   int zero, size_t size)
{
  void *ptr;

  if (mem->failed)
    {
      DPRINT(("tre_mem_alloc: oops, called after failure?!\n"));
      return NULL;
    }

#ifdef MALLOC_DEBUGGING
  if (!provided)
    {
      ptr = xmalloc(1);
      if (ptr == NULL)
	{
	  DPRINT(("tre_mem_alloc: xmalloc forced failure\n"));
	  mem->failed = 1;
	  return NULL;
	}
      xfree(ptr);
    }
#endif /* MALLOC_DEBUGGING */

  if (mem->n < size)
    {
      /* We need more memory than is available in the current block.
	 Allocate a new block. */
      tre_list_t *l;
      if (provided)
	{
	  DPRINT(("tre_mem_alloc: using provided block\n"));
	  if (provided_block == NULL)
	    {
	      DPRINT(("tre_mem_alloc: provided block was NULL\n"));
	      mem->failed = 1;
	      return NULL;
	    }
	  mem->ptr = provided_block;
	  mem->n = TRE_MEM_BLOCK_SIZE;
	}
      else
	{
	  size_t block_size;
	  if (size * 8 > TRE_MEM_BLOCK_SIZE)
	    block_size = size * 8;
	  else
	    block_size = TRE_MEM_BLOCK_SIZE;
	  DPRINT(("tre_mem_alloc: allocating new %ld byte block\n",
		  block_size));
	  l = xmalloc(sizeof(*l));
	  if (l == NULL)
	    {
	      mem->failed = 1;
	      return NULL;
	    }
	  l->data = xmalloc(block_size);
	  if (l->data == NULL)
	    {
	      xfree(l);
	      mem->failed = 1;
	      return NULL;
	    }
	  l->next = NULL;
	  if (mem->current != NULL)
	    mem->current->next = l;
	  if (mem->blocks == NULL)
	    mem->blocks = l;
	  mem->current = l;
	  mem->ptr = l->data;
	  mem->n = block_size;
	}
    }

  /* Make sure the next pointer will be aligned. */
  size += ALIGN(mem->ptr + size, long);

  /* Allocate from current block. */
  ptr = mem->ptr;
  mem->ptr += size;
  mem->n -= size;

  /* Set to zero if needed. */
  if (zero)
    memset(ptr, 0, size);

  return ptr;
}

/* EOF */
Commit	Line	Data
ad3c9f2a A	1	/*
	2	tre-mem.c - TRE memory allocator
	3
	4	This software is released under a BSD-style license.
	5	See the file LICENSE for details and copyright.
	6
	7	*/
	8
	9	/*
	10	This memory allocator is for allocating small memory blocks efficiently
	11	in terms of memory overhead and execution speed. The allocated blocks
	12	cannot be freed individually, only all at once. There can be multiple
	13	allocators, though.
	14	*/
	15
	16	#ifdef HAVE_CONFIG_H
	17	#include <config.h>
	18	#endif /* HAVE_CONFIG_H */
	19	#include <stdlib.h>
	20	#include <string.h>
	21
	22	#include "tre-internal.h"
	23	#include "tre-mem.h"
	24	#include "xmalloc.h"
	25
	26
	27	/* Returns a new memory allocator or NULL if out of memory. */
	28	tre_mem_t
	29	tre_mem_new_impl(int provided, void *provided_block)
	30	{
	31	tre_mem_t mem;
	32	if (provided)
	33	{
	34	mem = provided_block;
	35	memset(mem, 0, sizeof(*mem));
	36	}
	37	else
	38	mem = xcalloc(1, sizeof(*mem));
	39	if (mem == NULL)
	40	return NULL;
	41	return mem;
	42	}
	43
	44
	45	/* Frees the memory allocator and all memory allocated with it. */
	46	void
	47	tre_mem_destroy(tre_mem_t mem)
	48	{
	49	tre_list_t tmp, l = mem->blocks;
	50
	51	while (l != NULL)
	52	{
	53	xfree(l->data);
	54	tmp = l->next;
	55	xfree(l);
	56	l = tmp;
	57	}
	58	xfree(mem);
	59	}
	60
	61
	62	/* Allocates a block of `size' bytes from `mem'. Returns a pointer to the
	63	allocated block or NULL if an underlying malloc() failed. */
	64	void *
65	tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
66	int zero, size_t size)
67	{
68	void *ptr;
69
70	if (mem->failed)
71	{
72	DPRINT(("tre_mem_alloc: oops, called after failure?!\n"));
73	return NULL;
74	}
75
76	#ifdef MALLOC_DEBUGGING
77	if (!provided)
78	{
79	ptr = xmalloc(1);
80	if (ptr == NULL)
81	{
82	DPRINT(("tre_mem_alloc: xmalloc forced failure\n"));
83	mem->failed = 1;
84	return NULL;
85	}
86	xfree(ptr);
87	}
88	#endif /* MALLOC_DEBUGGING */
89
90	if (mem->n < size)
91	{
92	/* We need more memory than is available in the current block.
93	Allocate a new block. */
94	tre_list_t *l;
95	if (provided)
96	{
97	DPRINT(("tre_mem_alloc: using provided block\n"));
98	if (provided_block == NULL)
99	{
100	DPRINT(("tre_mem_alloc: provided block was NULL\n"));
101	mem->failed = 1;
102	return NULL;
103	}
104	mem->ptr = provided_block;
105	mem->n = TRE_MEM_BLOCK_SIZE;
106	}
107	else
108	{
5f125488	109	size_t block_size;
ad3c9f2a A	110	if (size * 8 > TRE_MEM_BLOCK_SIZE)
	111	block_size = size * 8;
	112	else
	113	block_size = TRE_MEM_BLOCK_SIZE;
5f125488	114	DPRINT(("tre_mem_alloc: allocating new %ld byte block\n",
ad3c9f2a A	115	block_size));
	116	l = xmalloc(sizeof(*l));
	117	if (l == NULL)
	118	{
	119	mem->failed = 1;
	120	return NULL;
	121	}
	122	l->data = xmalloc(block_size);
	123	if (l->data == NULL)
	124	{
	125	xfree(l);
	126	mem->failed = 1;
	127	return NULL;
	128	}
	129	l->next = NULL;
	130	if (mem->current != NULL)
	131	mem->current->next = l;
	132	if (mem->blocks == NULL)
	133	mem->blocks = l;
	134	mem->current = l;
	135	mem->ptr = l->data;
	136	mem->n = block_size;
	137	}
	138	}
	139
	140	/* Make sure the next pointer will be aligned. */
	141	size += ALIGN(mem->ptr + size, long);
	142
	143	/* Allocate from current block. */
	144	ptr = mem->ptr;
	145	mem->ptr += size;
	146	mem->n -= size;
	147
	148	/* Set to zero if needed. */
	149	if (zero)
	150	memset(ptr, 0, size);
	151
	152	return ptr;
	153	}
	154
	155	/* EOF */