Jabber WindowGram Client (JWGC)

00079 {
00080     struct xode_pool_free *cur;
00081 
00082     if(p->cleanup == NULL)
00083     {
00084         p->cleanup = pf;
00085         return;
00086     }
00087 
00088     /* fast forward to end of list */
00089     for(cur = p->cleanup; cur->next != NULL; cur = cur->next);
00090 
00091     cur->next = pf;
00092 }

00096 {
00097     struct xode_pool_free *ret;
00098 
00099     /* make the storage for the tracker */
00100     while((ret = _xode_pool__malloc(sizeof(struct xode_pool_free))) == NULL) sleep(1);
00101     ret->f = f;
00102     ret->arg = arg;
00103     ret->next = NULL;
00104 
00105     return ret;
00106 }

00110 {
00111     struct xode_pool_heap *ret;
00112     struct xode_pool_free *clean;
00113 
00114     /* make the return heap */
00115     while((ret = _xode_pool__malloc(sizeof(struct xode_pool_heap))) == NULL) sleep(1);
00116     while((ret->block = _xode_pool__malloc(size)) == NULL) sleep(1);
00117     ret->size = size;
00118     p->size += size;
00119     ret->used = 0;
00120 
00121     /* append to the cleanup list */
00122     clean = _xode_pool_free(p, _xode_pool_heapfree, (void *)ret);
00123     clean->heap = ret; /* for future use in finding used mem for pstrdup */
00124     _xode_pool_cleanup_append(p, clean);
00125 
00126     return ret;
00127 }

00070 {
00071     struct xode_pool_heap *h = (struct xode_pool_heap *)arg;
00072 
00073     _xode_pool__free(h->block);
00074     _xode_pool__free(h);
00075 }

00058 {
00059     xode_pool p;
00060     while((p = _xode_pool__malloc(sizeof(_xode_pool))) == NULL) sleep(1);
00061     p->cleanup = NULL;
00062     p->heap = NULL;
00063     p->size = 0;
00064 
00065     return p;
00066 }

00130 {
00131     xode_pool p;
00132     p = _xode_pool_new();
00133     p->heap = _xode_pool_heap(p,bytes);
00134     return p;
00135 }

00233 {
00234     struct xode_pool_free *clean;
00235 
00236     clean = _xode_pool_free(p, f, arg);
00237     clean->next = p->cleanup;
00238     p->cleanup = clean;
00239 }

00214 {
00215     struct xode_pool_free *cur, *stub;
00216 
00217     if(p == NULL) return;
00218 
00219     cur = p->cleanup;
00220     while(cur != NULL)
00221     {
00222         (*cur->f)(cur->arg);
00223         stub = cur->next;
00224         _xode_pool__free(cur);
00225         cur = stub;
00226     }
00227 
00228     _xode_pool__free(p);
00229 }

00247 {
00248     return _xode_pool_newheap(bytes);
00249 }

00138 {
00139     void *block;
00140 
00141     if(p == NULL)
00142     {
00143         fprintf(stderr,"Memory Leak! xode_pmalloc received NULL pool, unable to track allocation, exiting]\n");
00144         abort();
00145     }
00146 
00147     /* if there is no heap for this pool or it's a big request, just raw, I like how we clean this :) */
00148     if(p->heap == NULL || size > (p->heap->size / 2))
00149     {
00150         while((block = _xode_pool__malloc(size)) == NULL) sleep(1);
00151         p->size += size;
00152         _xode_pool_cleanup_append(p, _xode_pool_free(p, _xode_pool__free, block));
00153         return block;
00154     }
00155 
00156     /* we have to preserve boundaries, long story :) */
00157     if(size >= 4)
00158         while(p->heap->used&7) p->heap->used++;
00159 
00160     /* if we don't fit in the old heap, replace it */
00161     if(size > (p->heap->size - p->heap->used))
00162         p->heap = _xode_pool_heap(p, p->heap->size);
00163 
00164     /* the current heap has room */
00165     block = (char *)p->heap->block + p->heap->used;
00166     p->heap->used += size;
00167     return block;
00168 }

00180 {
00181     void *block = xode_pool_malloc(p, size);
00182     memset(block, 0, size);
00183     return block;
00184 }

00171 {
00172    void* result = xode_pool_malloc(p, size);
00173    if (result != NULL)
00174            memset(result, c, size);
00175    return result;
00176 }

00242 {
00243     return _xode_pool_new();
00244 }

00207 {
00208     if(p == NULL) return 0;
00209 
00210     return p->size;
00211 }

00188 {
00189     char *ret;
00190 
00191     if(src == NULL)
00192         return NULL;
00193 
00194     ret = xode_pool_malloc(p,strlen(src) + 1);
00195     strcpy(ret,src);
00196 
00197     return ret;
00198 }

00202 {
00203     return xode_pool_strdup(p, src);
00204 }


Data Structures
struct	xode_pool_free
Defines
#define	_xode_pool__malloc malloc
#define	_xode_pool__free free
Functions
xode_pool	_xode_pool_new (void)
void	_xode_pool_heapfree (void *arg)
void	_xode_pool_cleanup_append (xode_pool p, struct xode_pool_free *pf)
xode_pool_free *	_xode_pool_free (xode_pool p, xode_pool_cleaner f, void *arg)
xode_pool_heap *	_xode_pool_heap (xode_pool p, int size)
xode_pool	_xode_pool_newheap (int bytes)
void *	xode_pool_malloc (xode_pool p, int size)
void *	xode_pool_mallocx (xode_pool p, int size, char c)
void *	xode_pool_malloco (xode_pool p, int size)
char *	xode_pool_strdup (xode_pool p, const char *src)
char *	xode_pool_strdupx (xode_pool p, const char *src)
int	xode_pool_size (xode_pool p)
void	xode_pool_free (xode_pool p)
void	xode_pool_cleanup (xode_pool p, xode_pool_cleaner f, void *arg)
xode_pool	xode_pool_new (void)
xode_pool	xode_pool_heap (const int bytes)

Jabber WindowGram Client (JWGC)

pool.c File Reference

Data Structures

Defines

Functions

Define Documentation

Function Documentation