/* * 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); }
/* * 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; }
/* 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; }
/* * 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); }