From 8d337f303d908e6b99f6b9403c5033ff4aacd12b Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sun, 5 Nov 2017 19:40:14 +0100 Subject: Add libsimple.c and libsimple.h MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libsimple.c | 462 ++++++++++++++++++++++++++++++++++++++++++++++++ libsimple.h | 576 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1038 insertions(+) create mode 100644 libsimple.c create mode 100644 libsimple.h diff --git a/libsimple.c b/libsimple.c new file mode 100644 index 0000000..9a58ba1 --- /dev/null +++ b/libsimple.c @@ -0,0 +1,462 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" + + +extern char *argv0; + + +int libsimple_default_failure_exit = 1; + + +void * +libsimple_rawmemchr(const void *s_, int c) +{ + char *s = *(char **)(void *)&s_; + while ((int)*s++ != c); + return &s[-1]; +} + + +void * +libsimple_memrchr(const void *s_, int c, size_t n_) +{ + char *s = *(char **)(void *)&s_; + ssize_t n = n_; + while (n-- && (int)s[n] != c); + return n < 0 ? NULL : &s[n]; +} + + +void * +libsimple_rawmemrchr(const void *s_, int c, size_t n) +{ + char *s = *(char **)(void *)&s_; + while ((int)s[--n] != c); + return &s[n]; +} + + +char * +libsimple_strchrnul(const char *s_, int c) +{ + char *s = *(char **)(void *)&s_; + for (; *s && (int)*s != c; s++) + return s; +} + + +void * +libsimple_memdup(const void *s, size_t n) +{ + void *ret = malloc(n); + if (!ret) + return NULL; + return memcpy(ret, s, n); +} + + +char * +libsimple_strndup(const char *s, size_t n) +{ + void *ret; + if (n == SIZE_MAX) { + errno = ENOMEM; + return NULL; + } + if (!(ret = malloc(n + 1))) + return NULL; + memcpy(ret, s, n); + ((char *)ret)[n] = '\0'; + return ret; +} + + +int +libsimple_isutf8(const char *string, int allow_modified_nul) +{ + static long BYTES_TO_MIN_BITS[] = {0, 0, 8, 12, 17, 22, 37}; + static long BYTES_TO_MAX_BITS[] = {0, 7, 11, 16, 21, 26, 31}; + long int bytes = 0, read_bytes = 0, bits = 0, c, character; + + /* min bits max bits + 0....... 0 7 + 110..... 10...... 8 11 + 1110.... 10...... 10...... 12 16 + 11110... 10...... 10...... 10...... 17 21 + 111110.. 10...... 10...... 10...... 10...... 22 26 + 1111110. 10...... 10...... 10...... 10...... 10...... 27 31 + */ + + while ((c = (long int)(*string++))) { + if (!read_bytes) { + /* First byte of the character. */ + + if (!(c & 0x80)) + /* Single-byte character. */ + continue; + + if ((c & 0xC0) == 0x80) + /* Single-byte character marked as multibyte, or + a non-first byte in a multibyte character. */ + return -1; + + /* Multibyte character. */ + while ((c & 0x80)) + bytes++, c <<= 1; + read_bytes = 1; + character = c & 0x7F; + if (bytes > 6) + /* 31-bit characters can be encoded with 6-bytes, + and UTF-8 does not cover higher code points. */ + return -1; + } else { + /* Not first byte of the character. */ + + if ((c & 0xC0) != 0x80) + /* Beginning of new character before a + multibyte character has ended. */ + return -1; + + character = (character << 6) | (c & 0x7F); + + if (++read_bytes < bytes) + /* Not at last byte yet. */ + continue; + + /* Check that the character is not unnecessarily long. */ + while (character) + character >>= 1, bits++; + bits = (!bits && bytes == 2 && allow_modified_nul) ? 8 : bits; + if (bits < BYTES_TO_MIN_BITS[bytes] || BYTES_TO_MAX_BITS[bytes] < bits) + return -1; + + read_bytes = bytes = bits = 0; + } + } + + /* Make sure we did not stop at the middle of a multibyte character. */ + return !read_bytes; +} + + +int +libsimple_asprintf(char **strp, const char *fmt, ...) +{ + va_list ap; + int r; + va_start(ap, fmt); + r = libsimple_vasprintf(strp, fmt, ap); + va_end(ap); + return r; +} + + +int +libsimple_vasprintf(char **strp, const char *fmt, va_list ap) +{ + FILE *fp; + size_t siz = 0; + int ret; + *strp = NULL; + fp = open_memstream(strp, &siz); + if (!fp) + goto fail; + ret = vfprintf(fp, fmt, ap); + if (ret < 0) + goto fail; + if (fputc(0, fp)) + goto fail; + fclose(fp); + return ret; +fail: + free(*strp); + *strp = NULL; + return -1; +} + + +void * +libsimple_memmem(const void *hay_, size_t hayn, const void *sub_, size_t subn) +{ + char *hay = *(char **)(void *)&hay_, *end; + const char *sub = sub_; + + if (!subn) + return hay; + if (hayn < subn) + return NULL; + if (subn == 1) + return memchr(hay, *sub, hayn); + + for (end = &hay[hayn - subn + 1]; hay != end; hay++) + if (*hay == *sub && !memcmp(hay, sub, subn)) + return hay; + + return NULL; +} + + +char * +libsimple_strcasestr(const char *h_, const char *n) +{ + char *h = *(char **)(void *)&h_; + size_t hn = strlen(h); + size_t nn = strlen(n); + if (hn < nn) + return NULL; + for (hn -= nn; hn--; h++) + if (!strcasecmp(h, n)) + return h; + return NULL; +} + + +int +libsimple_memstarts(const void *s_, size_t n, const void *t_, size_t m) +{ + const char *s = s_, *t = t_; + size_t i = 0; + if (n < m) + return 0; + while (i < m && s[i] == t[i]) i++; + return i == m; +} + + +int +libsimple_memends(const void *s_, size_t n, const void *t_, size_t m) +{ + const char *s = s_, *t = t_; + if (n < m) + return 0; + while (n--, m--) + if (s[n] != t[m]) + return 0; + return 1; +} + + +int +libsimple_strstarts(const char *s, const char *t) +{ + for (; *t && *s == *t; s++, t++); + return !*t; +} + + +int +libsimple_strends(const char *s, const char *t) +{ + return memends(s, strlen(s), t, strlen(t)); +} + + +static inline size_t +alloc_size_product(size_t n, va_list ap) +{ + size_t prod = n; + if (!n) { + errno = EINVAL; + return 0; + } + for (;;) { + n = va_arg(ap, size_t); + if (!n) + break; + if (n >= SIZE_MAX / prod) { + errno = ENOMEM; + return 0; + } + prod *= n; + } + return prod; +} + +void * +libsimple_vmalloczn(int clear, size_t n, va_list ap) +{ + n = alloc_size_product(n, ap); + return !n ? NULL : clear ? calloc(1, n) : malloc(n); +} + +void * +libsimple_vreallocn(void *ptr, size_t n, va_list ap) +{ + n = alloc_size_product(n, ap); + return !n ? NULL : realloc(ptr, n); +} + + +void * +enmalloc(int status, size_t n) +{ + void *ret = malloc(n); + if (!ret) { + fprintf(stderr, "%s: malloc: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +void * +encalloc(int status, size_t n, size_t m) +{ + void *ret = calloc(n, m); + if (!ret) { + fprintf(stderr, "%s: calloc: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +void * +enrealloc(int status, void *ptr, size_t n) +{ + char *ret = realloc(ptr, n); + if (!ret) { + fprintf(stderr, "%s: realloc: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +char * +enstrdup(int status, const char *s) +{ + char *ret = strdup(s); + if (!ret) { + fprintf(stderr, "%s: strdup: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +char * +enstrndup(int status, const char *s, size_t n) +{ + void *ret = strndup(s, n); + if (!ret) { + fprintf(stderr, "%s: strndup: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +void * +enmemdup(int status, const void *s, size_t n) +{ + void *ret = memdup(s, n); + if (!ret) { + fprintf(stderr, "%s: memdup: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +void * +libsimple_envmalloczn(int status, int clear, size_t n, va_list ap) +{ + void *ret = libsimple_vmalloczn(clear, n, ap); + if (!ret) { + fprintf(stderr, "%s: %s: %s\n", argv0, clear ? "calloc" : "malloc", strerror(errno)); + exit(status); + } + return ret; +} + + +void * +libsimple_envreallocn(int status, void *ptr, size_t n, va_list ap) +{ + void *ret = libsimple_vreallocn(ptr, n, ap); + if (!ret) { + fprintf(stderr, "%s: realloc: %s\n", argv0, strerror(errno)); + exit(status); + } + return ret; +} + + +int +vputenvf(const char *fmt, va_list ap) +{ + va_list ap2; + int n; + char *s; + va_copy(ap2, ap); + n = vsnprintf(NULL, 0, fmt, ap2); + va_end(ap2); + if (n < 0) + return -1; + if ((size_t)n == SIZE_MAX) { + errno = ENOMEM; + return -1; + } + s = alloca((size_t)n + 1); + vsprintf(s, fmt, ap); + return putenv(s); +} + + +void +envputenvf(int status, const char *fmt, va_list ap) +{ + if (vputenvf(fmt, ap)) { + fprintf(stderr, "%s: putenvf: %s\n", argv0, strerror(errno)); + exit(status); + } +} + + +void +vweprintf(const char *fmt, va_list ap) +{ + int saved_errno = errno, r; + const char *end = strchr(fmt, '\0'); + const char *prefix1 = argv0; + const char *prefix2 = ": "; + const char *suffix1 = ""; + const char *suffix2 = ""; + const char *suffix3 = ""; + char *message = NULL; + va_list ap1; + va_list ap2; + + if (!argv0 || !strncmp(fmt, "usage: ", strlen("usage: "))) + prefix1 = prefix2 = ""; + + va_copy(ap1, ap); + va_copy(ap2, ap); + r = vsnprintf(NULL, 0, fmt, ap1); + if (0 <= r && (size_t)r < SIZE_MAX) { + message = alloca((size_t)r + 1); + vsprintf(message, fmt, ap2); + } + va_end(ap2); + va_end(ap1); + + if (*end == ':') { + suffix1 = " "; + suffix2 = strerror(saved_errno); + suffix3 = "\n"; + } else if (*end != '\n') { + suffix1 = "\n"; + } + + if (message) { + /* This is to avoid mangling when multiple processes are writting. */ + fprintf(stderr, "%s%s%s%s%s%s", prefix1, prefix2, message, suffix1, suffix2, suffix3); + } else { + fprintf(stderr, "%s%s", prefix1, prefix2); + vfprintf(stderr, fmt, ap); + fprintf(stderr, "%s%s%s", suffix1, suffix2, suffix3); + } + + errno = saved_errno; +} diff --git a/libsimple.h b/libsimple.h new file mode 100644 index 0000000..02fc912 --- /dev/null +++ b/libsimple.h @@ -0,0 +1,576 @@ +/* See LICENSE file for copyright and license details. */ +#ifndef LIBSIMPLE_H +#define LIBSIMPLE_H + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#if defined(__GNUC__) && !defined(__clang__) +# define _LIBSIMPLE_GCC_ONLY(x) x +#else +# define _LIBSIMPLE_GCC_ONLY(x) +#endif + + +extern int libsimple_default_failure_exit; + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +void *libsimple_rawmemchr(const void *, int); +#ifndef rawmemchr +# define rawmemchr libsimple_rawmemchr +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +void *libsimple_memrchr(const void *, int, size_t); +#ifndef memrchr +# define memrchr libsimple_memrchr +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +void *libsimple_rawmemrchr(const void *, int, size_t); +#ifndef rawmemrchr +# define rawmemrchr libsimple_rawmemrchr +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +char *libsimple_strchrnul(const char *, int); +#ifndef strchrnul +# define strchrnul libsimple_strchrnul +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +static inline char *libsimple_strend(const char *__s) { return strchr(__s, '\0'); } +#ifndef strend +# define strend libsimple_strend +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +static inline int libsimple_inchrset(int __c, const char *__s) { return __c && strchr(__s, __c); } +#ifndef inchrset +# define inchrset libsimple_inchrset +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, warn_unused_result))) +void *libsimple_memdup(const void *, size_t); +#ifndef memdup +# define memdup libsimple_memdup +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, warn_unused_result))) +char *libsimple_strndup(const char *, size_t); +#ifndef strndup +# define strndup libsimple_strndup +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void *libsimple_mempcpy(void *__d, const void *__s, size_t __n) +{ return &((char *)memcpy(__d, __s, __n))[__n]; } +#ifndef mempcpy +# define mempcpy libsimple_mempcpy +#endif + + +#ifndef strdupa +# if defined(__GNUC__) || defined(__clang__) +# define strdupa(s)\ + ({\ + const char *__s = (s);\ + size_t __n = strlen(__s) + 1;\ + char *__r = alloca(__n);\ + memcpy(__r, __s, __n);\ + }) +# endif +#endif + + +#ifndef strdupa +# if defined(__GNUC__) || defined(__clang__) +# define strndupa(s, n)\ + ({\ + const char *__s = (s);\ + size_t __n = (n);\ + size_t __m = strlen(__s);\ + char *__r;\ + __n = __n < __m ? __n : __m;\ + __r = alloca(__n + 1);\ + memcpy(__r, __s, __n);\ + __r[n] = '\0';\ + __r;\ + }) +# endif +#endif + + +#ifndef strdupa +# if defined(__GNUC__) || defined(__clang__) +# define memdupa(s, n)\ + ({\ + const char *__s = (s);\ + size_t __n = (n);\ + char *__r = alloca(__n);\ + memcpy(__r, __s, __n);\ + }) +# endif +#endif + + +/** + * Check whether a NUL-terminated string is encoded in UTF-8 + * + * @param string The string + * @param allow_modified_nul Whether Modified UTF-8 is allowed, which allows a two-byte encoding for NUL + * @return 1 if good, 0 on encoding error + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +int libsimple_isutf8(const char *, int); +#ifndef isutf8 +# define isutf8 libsimple_isutf8 +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(1, 2), format(printf, 2, 3)))) +int libsimple_asprintf(char **, const char *, ...); +#ifndef asprintf +# define asprintf libsimple_asprintf +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(1, 2)))) +int libsimple_vasprintf(char **, const char *, va_list); +#ifndef vasprintf +# define vasprintf libsimple_vasprintf +#endif + + +#ifndef asprintfa +# if defined(__GNUC__) && !defined(__clang__) +# define asprintfa(__fmt, ...)\ + ({\ + const char *__f = (__fmt);\ + char *__ret = NULL;\ + int __r = snprintf(NULL, 0, __f, __VA_ARGS__);\ + if (__r < 0) {\ + __ret;\ + } else if ((size_t)__r == SIZE_MAX) {\ + errno = ENOMEM;\ + __ret;\ + } else {\ + __ret = alloca((size_t)__r + 1);\ + sprintf(__ret, __f, __VA_ARGS__);\ + __ret;\ + }\ + }) +# endif +#endif + + +#ifndef vasprintfa +# if defined(__GNUC__) || defined(__clang__) +# define vasprintfa(__fmt, __ap)\ + ({\ + const char *__f = (__fmt);\ + va_list __a = (__ap);\ + va_list __a2;\ + char *__ret = NULL;\ + int __r;\ + va_copy(__a2, __a);\ + __r = vsnprintf(NULL, 0, __f, __a);\ + if (__r < 0);\ + else if ((size_t)__r == SIZE_MAX) {\ + errno = ENOMEM;\ + } else {\ + __ret = alloca((size_t)__r + 1);\ + vsprintf(__ret, __f, __a2);\ + }\ + va_end(__a2);\ + __ret;\ + }) +# endif +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, warn_unused_result))) +void *libsimple_memmem(const void *, size_t, const void *, size_t); +#ifndef memmem +# define memmem libsimple_memmem +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, warn_unused_result))) +int libsimple_memstarts(const void *, size_t, const void *, size_t); +#ifndef memstarts +# define memstarts libsimple_memstarts +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, warn_unused_result))) +int libsimple_memends(const void *, size_t, const void *, size_t); +#ifndef memends +# define memends libsimple_memends +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +int libsimple_strstarts(const char *, const char *); +#ifndef strstarts +# define strstarts libsimple_strstarts +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +int libsimple_strends(const char *, const char *); +#ifndef strends +# define strends libsimple_strends +#endif + + +_LIBSIMPLE_GCC_ONLY(__attribute__((pure, nonnull, warn_unused_result))) +char *libsimple_strcasestr(const char *, const char *); +#ifndef strcasestr +# define strcasestr libsimple_strcasestr +#endif + + +#define malloczn(CLEAR, ...) _libsimple_malloczn((CLEAR), __VA_ARGS__, (size_t)0) +#define mallocn(...) malloczn(0, __VA_ARGS__) +#define callocn(...) malloczn(1, __VA_ARGS__) + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +void *libsimple_vmalloczn(int, size_t, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void *libsimple_vmallocn(size_t __n, va_list __ap) { return libsimple_vmalloczn(0, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void *libsimple_vcallocn(size_t __n, va_list __ap) { return libsimple_vmalloczn(1, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void * +libsimple_malloczn(int __clear, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_vmalloczn(__clear, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void * +libsimple_mallocn(size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_vmalloczn(0, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void * +libsimple_callocn(size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_vmalloczn(1, __n, __ap); + va_end(__ap); +} + + +#define reallocn(PTR, ...) _libsimple_reallocn((PTR), __VA_ARGS__, (size_t)0) +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +void *libsimple_vreallocn(void *, size_t, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result))) +static inline void * +libsimple_reallocn(void *__ptr, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_vreallocn(__ptr, __n, __ap); + va_end(__ap); +} + + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +void *enmalloc(int, size_t); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +void *encalloc(int, size_t, size_t); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +void *enrealloc(int, void *, size_t); + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, warn_unused_result, returns_nonnull))) +char *enstrdup(int, const char *); + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, warn_unused_result, returns_nonnull))) +char *enstrndup(int, const char *, size_t); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +void *enmemdup(int, const void *, size_t); + +#define enmalloczn(STATUS, CLEAR, ...) _libsimple_enmalloczn((STATUS), (CLEAR), __VA_ARGS__, (size_t)0) +#define enmallocn(STATUS, ...) _libsimple_enmallocn((STATUS), (CLEAR), __VA_ARGS__, (size_t)0) +#define encallocn(STATUS, ...) _libsimple_encallocn((STATUS), (CLEAR), __VA_ARGS__, (size_t)0) +#define enreallocn(STATUS, PTR, ...) _libsimple_enreallocn((STATUS), (PTR), __VA_ARGS__, (size_t)0) + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +void *libsimple_envmalloczn(int, int, size_t, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +void *libsimple_envreallocn(int, void *, size_t, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *libsimple_envmallocn(int __st, size_t __n, va_list __ap) { return libsimple_envmalloczn(__st, 0, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *libsimple_envcallocn(int __st, size_t __n, va_list __ap) { return libsimple_envmalloczn(__st, 1, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_enmalloczn(int __status, int __clear, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envmalloczn(__status, __clear, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_enmallocn(int __status, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envmalloczn(__status, 0, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_encallocn(int __status, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envmalloczn(__status, 1, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_enreallocn(int __status, void *__ptr, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envreallocn(__status, __ptr, __n, __ap); + va_end(__ap); +} + + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *emalloc(size_t __n) { return enmalloc(libsimple_default_failure_exit, __n); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *ecalloc(size_t __n, size_t __m) { return encalloc(libsimple_default_failure_exit, __n, __m); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *erealloc(void *__ptr, size_t __n) { return enrealloc(libsimple_default_failure_exit, __ptr, __n); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, warn_unused_result, returns_nonnull))) +static inline char *estrdup(const char *__s) { return enstrdup(libsimple_default_failure_exit, __s); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, warn_unused_result, returns_nonnull))) +static inline char *estrndup(const char *__s, size_t __n) { return enstrndup(libsimple_default_failure_exit, __s, __n); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *ememdup(const void *__s, size_t __n) { return enmemdup(libsimple_default_failure_exit, __s, __n); } + +#define emalloczn(CLEAR, ...) enmalloczn(libsimple_default_failure_exit, (CLEAR), __VA_ARGS__) +#define emallocn(...) enmallocn(libsimple_default_failure_exit, __VA_ARGS__) +#define ecallocn(...) encallocn(libsimple_default_failure_exit, __VA_ARGS__) +#define ereallocn(PTR, ...) enreallocn(libsimple_default_failure_exit, (PTR), __VA_ARGS__) + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *libsimple_evmalloczn(int __clear, size_t __n, va_list __ap) +{ return libsimple_envmalloczn(libsimple_default_failure_exit, __clear, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *libsimple_evmallocn(size_t __n, va_list __ap) +{ return libsimple_envcallocn(libsimple_default_failure_exit, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *libsimple_evcallocn(size_t __n, va_list __ap) +{ return libsimple_envmallocn(libsimple_default_failure_exit, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void *libsimple_evreallocn(void *__ptr, size_t __n, va_list __ap) +{ return libsimple_envreallocn(libsimple_default_failure_exit, __ptr, __n, __ap); } + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_emalloczn(int __c, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envmalloczn(libsimple_default_failure_exit, __c, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_emallocn(size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envmalloczn(libsimple_default_failure_exit, 0, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_ecallocn(size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envmalloczn(libsimple_default_failure_exit, 1, __n, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((warn_unused_result, returns_nonnull))) +static inline void * +libsimple_ereallocn(void *__p, size_t __n, ...) +{ + va_list __ap; + va_start(__ap, __n); + return libsimple_envreallocn(libsimple_default_failure_exit, __p, __n, __ap); + va_end(__ap); +} + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull))) +static inline char * +getenv_ne(const char *__name) +{ + char *__env = getenv(__name); + return (__env && *__env) ? __env : NULL; +} + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull))) +int vputenvf(const char *, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull))) +void envputenvf(int, const char *, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, format(printf, 1, 2)))) +static inline int +putenvf(const char *__fmt, ...) +{ + va_list __ap; + va_start(__ap, __fmt); + return vputenvf(__fmt, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, format(printf, 1, 2)))) +static inline void +eputenvf(const char *__fmt, ...) +{ + va_list __ap; + va_start(__ap, __fmt); + envputenvf(1, __fmt, __ap); + va_end(__ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull))) +static inline void +evputenvf(const char *__fmt, va_list __ap) +{ + envputenvf(libsimple_default_failure_exit, __fmt, __ap); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull, format(printf, 2, 3)))) +static inline void +enputenvf(int __status, const char *__fmt, ...) +{ + va_list __ap; + va_start(__ap, __fmt); + envputenvf(__status, __fmt, __ap); + va_end(__ap); +} + + + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(1)))) +void vweprintf(const char *, va_list); + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(1), format(printf, 1, 2), noreturn))) +static inline void +eprintf(const char *__fmt, ...) +{ + va_list __ap; + va_start(__ap, __fmt); + vweprintf(__fmt, __ap); + va_end(__ap); + exit(libsimple_default_failure_exit); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(1), noreturn))) +static inline void +veprintf(const char *__fmt, va_list __ap) +{ + vweprintf(__fmt, __ap); + exit(libsimple_default_failure_exit); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(2), format(printf, 2, 3), noreturn))) +static inline void +enprintf(int __status, const char *__fmt, ...) +{ + va_list __ap; + va_start(__ap, __fmt); + vweprintf(__fmt, __ap); + va_end(__ap); + exit(__status); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(2), noreturn))) +static inline void +venprintf(int __status, const char *__fmt, va_list __ap) +{ + vweprintf(__fmt, __ap); + exit(__status); +} + +_LIBSIMPLE_GCC_ONLY(__attribute__((nonnull(1), format(printf, 1, 2)))) +static inline void +weprintf(const char *__fmt, ...) +{ + va_list __ap; + va_start(__ap, __fmt); + vweprintf(__fmt, __ap); + va_end(__ap); +} + + +#endif -- cgit v1.2.3-70-g09d2