/* * h.c -- Handle allocation module * * Copyright (c) GoAhead Software Inc., 1995-2000. All Rights Reserved. * See the file "license.txt" for usage and redistribution license requirements */ /******************************** Description *********************************/ /* * This module provides a simple API to allocate and free handles * It maintains a dynamic array of pointers. These usually point to * per-handle structures. */ /********************************* Includes ***********************************/ #if UEMF #include "uemf.h" #else #include "basic/basicInternal.h" #endif /********************************** Defines ***********************************/ /* * The handle list stores the length of the list and the number of used * handles in the first two words. These are hidden from the caller by * returning a pointer to the third word to the caller */ #define H_LEN 0 /* First entry holds length of list */ #define H_USED 1 /* Second entry holds number of used */ #define H_OFFSET 2 /* Offset to real start of list */ #define H_INCR 16 /* Grow handle list in chunks this size */ /*********************************** Code *************************************/ /* * Allocate a new file handle. On the first call, the caller must set the * handle map to be a pointer to a null pointer. *map points to the second * element in the handle array. */ #if B_STATS int HALLOC(B_ARGS_DEC, void ***map) #else int hAlloc(void ***map) #endif { int *mp; int handle, len, memsize, incr; a_assert(map); if (*map == NULL) { incr = H_INCR; memsize = (incr + H_OFFSET) * sizeof(void**); #if B_STATS if ((mp = (int*) balloc(B_ARGS, memsize)) == NULL) { #else if ((mp = (int*) balloc(B_L, memsize)) == NULL) { #endif return -1; } memset(mp, 0, memsize); mp[H_LEN] = incr; mp[H_USED] = 0; *map = (void**) &mp[H_OFFSET]; } else { mp = &((*(int**)map)[-H_OFFSET]); } len = mp[H_LEN]; /* * Find the first null handle */ if (mp[H_USED] < mp[H_LEN]) { for (handle = 0; handle < len; handle++) { if (mp[handle+H_OFFSET] == 0) { mp[H_USED]++; return handle; } } } else { handle = len; } /* * No free handle so grow the handle list. Grow list in chunks of H_INCR. */ len += H_INCR; memsize = (len + H_OFFSET) * sizeof(void**); if ((mp = (int*) brealloc(B_L, (void*) mp, memsize)) == NULL) { return -1; } *map = (void**) &mp[H_OFFSET]; mp[H_LEN] = len; memset(&mp[H_OFFSET + len - H_INCR], 0, sizeof(int*) * H_INCR); mp[H_USED]++; return handle; } /******************************************************************************/ /* * Free a handle. This function returns the value of the largest * handle in use plus 1, to be saved as a max value. */ int hFree(void ***map, int handle) { int *mp; int len; a_assert(map); mp = &((*(int**)map)[-H_OFFSET]); a_assert(mp[H_LEN] >= H_INCR); a_assert(mp[handle + H_OFFSET]); a_assert(mp[H_USED]); mp[handle + H_OFFSET] = 0; if (--(mp[H_USED]) == 0) { bfree(B_L, (void*) mp); *map = NULL; } /* * Find the greatest handle number in use. */ if (*map == NULL) { handle = -1; } else { len = mp[H_LEN]; if (mp[H_USED] < mp[H_LEN]) { for (handle = len - 1; handle >= 0; handle--) { if (mp[handle + H_OFFSET]) break; } } else { handle = len; } } return handle + 1; } /******************************************************************************/ /* * Allocate an entry in the halloc array. */ #if B_STATS int HALLOCENTRY(B_ARGS_DEC, void ***list, int *max, int size) #else int hAllocEntry(void ***list, int *max, int size) #endif { char_t *cp; int id; a_assert(list); a_assert(max); #if B_STATS if ((id = HALLOC(B_ARGS, (void***) list)) < 0) { #else if ((id = hAlloc((void***) list)) < 0) { #endif return -1; } if (size > 0) { #if B_STATS if ((cp = balloc(B_ARGS, size)) == NULL) { #else if ((cp = balloc(B_L, size)) == NULL) { #endif hFree(list, id); return -1; } a_assert(cp); memset(cp, 0, size); (*list)[id] = (void*) cp; } if (id >= *max) { *max = id + 1; } return id; } /******************************************************************************/
