/*
* xcalloc() - same as calloc(3). Used for portability.
* Never returns NULL; fatal on error.
*/
void *
xcalloc(size_t n, size_t sz)
{
void *p;
PROF_start(xcalloc);
if (n < 1)
n = 1;
if (sz < 1)
sz = 1;
PROF_start(calloc);
p = calloc(n, sz);
PROF_stop(calloc);
if (p == NULL) {
if (failure_notify) {
snprintf(msg, 128, "xcalloc: Unable to allocate %u blocks of %u bytes!\n",
(unsigned int) n, (unsigned int) sz);
(*failure_notify) (msg);
} else {
perror("xcalloc");
}
exit(1);
}
#if XMALLOC_DEBUG
check_malloc(p, sz * n);
#endif
#if XMALLOC_STATISTICS
malloc_stat(sz * n);
#endif
#if XMALLOC_TRACE
xmalloc_show_trace(p, 1);
#endif
#if MEM_GEN_TRACE
if (tracefp)
fprintf(tracefp, "c:%u:%u:%p\n", (unsigned int) n, (unsigned int) sz, p);
#endif
PROF_stop(xcalloc);
return (p);
}
/*
* xmalloc() - same as malloc(3). Used for portability.
* Never returns NULL; fatal on error.
*/
void *
xmalloc(size_t sz)
{
void *p;
PROF_start(xmalloc);
if (sz < 1)
sz = 1;
PROF_start(malloc);
p = malloc(sz);
PROF_stop(malloc);
if (p == NULL) {
if (failure_notify) {
snprintf(msg, 128, "xmalloc: Unable to allocate %d bytes!\n",
(int) sz);
(*failure_notify) (msg);
} else {
perror("malloc");
}
exit(1);
}
#if XMALLOC_DEBUG
check_malloc(p, sz);
#endif
#if XMALLOC_STATISTICS
malloc_stat(sz);
#endif
#if XMALLOC_TRACE
xmalloc_show_trace(p, 1);
#endif
#if MEM_GEN_TRACE
if (tracefp)
fprintf(tracefp, "m:%d:%p\n", sz, p);
#endif
PROF_stop(xmalloc);
return (p);
}
/*
* xstrdup() - same as strdup(3). Used for portability.
* Never returns NULL; fatal on error.
*/
char *
xstrdup(const char *s)
{
size_t sz;
void *p;
PROF_start(xstrdup);
if (s == NULL) {
if (failure_notify) {
(*failure_notify) ("xstrdup: tried to dup a NULL pointer!\n");
} else {
fprintf(stderr, "xstrdup: tried to dup a NULL pointer!\n");
}
exit(1);
}
/* copy string, including terminating character */
sz = strlen(s) + 1;
p = memcpy(xmalloc(sz), s, sz);
PROF_stop(xstrdup);
return p;
}
/*
* xfree() - same as free(3). Will not call free(3) if s == NULL.
*/
void
xfree(void *s)
{
PROF_start(xfree);
#if XMALLOC_TRACE
xmalloc_show_trace(s, -1);
#endif
#if XMALLOC_DEBUG
if (s != NULL)
check_free(s);
#endif
if (s != NULL)
free(s);
#if MEM_GEN_TRACE
if (tracefp && s)
fprintf(tracefp, "f:%p\n", s);
#endif
PROF_stop(xfree);
}
/*
* xrealloc() - same as realloc(3). Used for portability.
* Never returns NULL; fatal on error.
*/
void *
xrealloc(void *s, size_t sz)
{
void *p;
PROF_start(xrealloc);
#if XMALLOC_TRACE
xmalloc_show_trace(s, -1);
#endif
if (sz < 1)
sz = 1;
#if XMALLOC_DEBUG
if (s != NULL)
check_free(s);
#endif
if ((p = realloc(s, sz)) == NULL) {
if (failure_notify) {
snprintf(msg, 128, "xrealloc: Unable to reallocate %d bytes!\n",
(int) sz);
(*failure_notify) (msg);
} else {
perror("realloc");
}
exit(1);
}
#if XMALLOC_DEBUG
check_malloc(p, sz);
#endif
#if XMALLOC_STATISTICS
malloc_stat(sz);
#endif
#if XMALLOC_TRACE
xmalloc_show_trace(p, 1);
#endif
#if MEM_GEN_TRACE
if (tracefp) /* new ptr, old ptr, new size */
fprintf(tracefp, "r:%p:%p:%d\n", p, s, sz);
#endif
PROF_stop(xrealloc);
return (p);
}
/* returns the number of leading white spaces in str; handy in skipping ws */
size_t
xcountws(const char *str)
{
size_t count = 0;
PROF_start(xcountws);
if (str) {
while (xisspace(*str)) {
str++;
count++;
}
}
PROF_stop(xcountws);
return count;
}
/*
* hash_lookup - locates the item under the key 'k' in the hash table
* 'hid'. Returns a pointer to the hash bucket on success; otherwise
* returns NULL.
*/
hash_link *
hash_lookup(hash_table * hid, const void *k)
{
hash_link *walker;
int b;
PROF_start(hash_lookup);
assert(k != NULL);
b = hid->hash(k, hid->size);
for (walker = hid->buckets[b]; walker != NULL; walker = walker->next) {
if ((hid->cmp) (k, walker->key) == 0) {
PROF_stop(hash_lookup);
return (walker);
}
assert(walker != walker->next);
}
PROF_stop(hash_lookup);
return NULL;
}
/*
* xstrncpy() - similar to strncpy(3) but terminates string
* always with '\0' if (n != 0 and dst != NULL),
* and doesn't do padding
*/
char *
xstrncpy(char *dst, const char *src, size_t n)
{
char *r = dst;
PROF_start(xstrncpy);
if (!n || !dst)
return dst;
if (src)
while (--n != 0 && *src != '\0')
*dst++ = *src++;
*dst = '\0';
PROF_stop(xstrncpy);
return r;
}
/*
* xstrndup() - string dup with length limit.
*/
char *
xstrndup(const char *s, size_t n)
{
size_t sz;
void *p;
PROF_start(xstrndup);
assert(s != NULL);
assert(n);
sz = strlen(s) + 1;
if (sz > n)
sz = n;
p = xstrncpy(xmalloc(sz), s, sz);
PROF_stop(xstrndup);
return p;
}
/* xxfree() - like xfree(), but we already know s != NULL */
void
xxfree(const void *s_const)
{
void *s = (void *) s_const;
PROF_start(xxfree);
#if XMALLOC_TRACE
xmalloc_show_trace(s, -1);
#endif
#if XMALLOC_DEBUG
check_free(s);
#endif
free(s);
#if MEM_GEN_TRACE
if (tracefp && s)
fprintf(tracefp, "f:%p\n", s);
#endif
PROF_stop(xxfree);
}
