Fix warnings, replace some static inline with inline + extern inline, and fix glibc support

296 files changed, 5894 insertions, 3540 deletions

diff --git a/.gitignore b/.gitignore
index 9a3192c..99287d5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,3 +12,4 @@
 *.gcno
 *.gcov
 *.lo
+*.to
diff --git a/Makefile b/Makefile
index 88f2130..3299480 100644
--- a/Makefile
+++ b/Makefile
@@ -50,20 +50,30 @@ HDR =\
 
 OBJ =\
 	aligned_memdup.o\
+	aligned_strdup.o\
 	aligned_strndup.o\
+	aligned_wcsdup.o\
 	aligned_wcsndup.o\
 	aligned_wmemdup.o\
 	allocn.o\
 	asprintf.o\
 	close.o\
+	cmptimespec.o\
+	cmptimeval.o\
 	difftimespec.o\
 	difftimeval.o\
 	doubletotimespec.o\
 	doubletotimeval.o\
 	ealigned_memdup.o\
+	ealigned_strdup.o\
 	ealigned_strndup.o\
+	ealigned_wcsdup.o\
 	ealigned_wcsndup.o\
 	ealigned_wmemdup.o\
+	egmtime.o\
+	elocaltime.o\
+	ememalloc.o\
+	ememdup.o\
 	enaligned_allocz.o\
 	enaligned_memdup.o\
 	enaligned_realloc.o\
@@ -77,28 +87,64 @@ OBJ =\
 	engmtime.o\
 	enlocaltime.o\
 	enmalloc.o\
+	enmemalloc.o\
 	enmemdup.o\
+	enposix_memalign.o\
+	enposix_memalignn.o\
 	enposix_memalignz.o\
+	enposix_memalignzn.o\
+	enprintf.o\
 	enputenvf.o\
+	enpvalloc.o\
+	enpvallocn.o\
+	enpvallocz.o\
+	enpvalloczn.o\
 	enrealloc.o\
 	enreallocarray.o\
+	enreallocn.o\
 	enstrdup.o\
 	enstrndup.o\
 	envaligned_alloczn.o\
 	envaligned_reallocn.o\
+	envallocz.o\
+	envalloczn.o\
 	envmalloczn.o\
 	envmemalloc.o\
+	envposix_memalignn.o\
 	envposix_memalignzn.o\
 	envputenvf.o\
+	envpvallocn.o\
+	envpvalloczn.o\
 	envreallocn.o\
+	envvalloczn.o\
 	enwcsdup.o\
 	enwcsndup.o\
 	enwmemdup.o\
-	ememdup.o\
+	eposix_memalign.o\
+	eposix_memalignn.o\
+	eposix_memalignz.o\
+	eposix_memalignzn.o\
+	eprintf.o\
 	eputenvf.o\
+	epvalloc.o\
+	epvallocn.o\
+	epvallocz.o\
+	epvalloczn.o\
+	erealloc.o\
+	ereallocarray.o\
+	ereallocn.o\
 	estrdup.o\
 	estrndup.o\
+	evallocz.o\
+	evalloczn.o\
+	evmemalloc.o\
+	evposix_memalignn.o\
+	evposix_memalignzn.o\
 	evputenvf.o\
+	evpvallocn.o\
+	evpvalloczn.o\
+	evreallocn.o\
+	evvalloczn.o\
 	ewcsdup.o\
 	ewcsndup.o\
 	ewmemdup.o\
@@ -106,10 +152,12 @@ OBJ =\
 	getenv_ne.o\
 	gmtime.o\
 	localtime.o\
+	memalloc.o\
 	memcasechr.o\
 	memcasechr_inv.o\
 	memcasecmp.o\
 	memcaseends.o\
+	memcaseeq.o\
 	memcaseeqlen.o\
 	memcasemem.o\
 	memcasescan.o\
@@ -125,9 +173,13 @@ OBJ =\
 	memelemscan.o\
 	memelemscan_inv.o\
 	memends.o\
+	memeq.o\
 	memeqlen.o\
 	memisutf8.o\
 	memmem.o\
+	mempcpy.o\
+	mempmove.o\
+	mempset.o\
 	mempsetelem.o\
 	memptolower.o\
 	memptoupper.o\
@@ -139,21 +191,33 @@ OBJ =\
 	memrchr_inv.o\
 	memrelem.o\
 	memrelem_inv.o\
+	memreplace.o\
 	memreplaceelem.o\
 	memreqlen.o\
 	memrmem.o\
-	memsetelem.o\
 	memscan.o\
 	memscan_inv.o\
+	memsetelem.o\
 	memstarts.o\
+	memtolower.o\
+	memtoupper.o\
 	minimise_number_string.o\
 	multimespec.o\
 	multimeval.o\
+	posix_memalignn.o\
+	posix_memalignz.o\
+	posix_memalignzn.o\
 	putenvf.o\
+	pvalloc.o\
+	pvallocn.o\
+	pvallocz.o\
+	pvalloczn.o\
 	rawmemcasechr.o\
 	rawmemcasechr_inv.o\
+	rawmemccpy.o\
 	rawmemchr.o\
 	rawmemchr_inv.o\
+	rawmemcmove.o\
 	rawmemelem.o\
 	rawmemelem_inv.o\
 	rawmemelemcpy.o\
@@ -164,6 +228,11 @@ OBJ =\
 	rawmemrchr_inv.o\
 	rawmemrelem.o\
 	rawmemrelem_inv.o\
+	reallocarray.o\
+	reallocarrayf.o\
+	reallocf.o\
+	reallocfn.o\
+	reallocn.o\
 	stpntolower.o\
 	stpntoupper.o\
 	stptolower.o\
@@ -232,14 +301,27 @@ OBJ =\
 	sumtimespec.o\
 	sumtimeval.o\
 	timespec2timeval.o\
+	timespectodouble.o\
 	timespectostr.o\
+	timeval2timespec.o\
+	timevaltodouble.o\
 	timevaltostr.o\
 	unlist.o\
+	vallocz.o\
+	valloczn.o\
 	vasprintf.o\
+	venprintf.o\
+	veprintf.o\
 	vmemalloc.o\
+	vposix_memalignn.o\
 	vputenvf.o\
+	vpvallocn.o\
+	vpvalloczn.o\
+	vreallocfn.o\
+	vvalloczn.o\
 	vweprintf.o\
 	wcsndup.o\
+	weprintf.o\
 	wmemdup.o\
 	libsimple.o
 
@@ -255,21 +337,23 @@ MAN3 =\
 TESTS = $(OBJ:.o=.test) libsimple-arg.test
 
 all: libsimple.a $(TESTS)
-$(OBJ): $(@:.o=.c) $(HDR)
-$(TESTS): $(@:=.o) test.o libsimple.a
-$(TESTS:=.o): $(@:.test.o=.c) $(HDR) test.h
+tests: $(TESTS)
+$(OBJ): $(HDR)
+$(TESTS): test.o libsimple.a
+$(TESTS:.test=.to): $(HDR) test.h
 
 test.o: test.c $(HDR) test.h
 	$(CC) -c -o $@ test.c $(CFLAGS) -DTEST -O0 -ffreestanding
 
 libsimple.a: $(OBJ)
-	$(AR) rc $@ $?
+	@rm -f -- $@
+	$(AR) rc $@ $(OBJ)
 	$(AR) -s $@
 
-.test.o.test:
+.to.test:
 	$(CC) -o $@ $< test.o libsimple.a $(LDFLAGS)
 
-.c.test.o:
+.c.to:
 	$(CC) -c -o $@ $< $(CFLAGS) -DTEST -O0
 
 check: $(TESTS)
@@ -295,9 +379,9 @@ uninstall:
 	-cd -- "$(DESTDIR)$(PREFIX)/share/man" && rm -f -- $(MAN0) $(MAN3)
 
 clean:
-	-rm -rf -- *.o *.su *.a *.so *.so.* *.gch *.gcda *.gcno *.gcov *.lo *.test
+	-rm -rf -- *.o *.su *.a *.so *.so.* *.gch *.gcda *.gcno *.gcov *.lo *.test *.to
 
 .SUFFIXES:
-.SUFFIXES: .test .test.o .o .c
+.SUFFIXES: .test .to .o .c
 
 .PHONY: all check install uninstall clean
diff --git a/aligned_strdup.c b/aligned_strdup.c
new file mode 100644
index 0000000..ed4ddf7
--- /dev/null
+++ b/aligned_strdup.c
@@ -0,0 +1,37 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline char *libsimple_aligned_strdup(const char *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *s;
+
+	assert((s = libsimple_aligned_strdup("test", 4)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(s)));
+		assert(info->size == 8);
+		assert(info->alignment == 4);
+		assert(!info->zeroed);
+	}
+	assert(!memcmp(s, "test", 5));
+	free(s);
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert(!libsimple_aligned_strdup("test", 16) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/aligned_wcsdup.c b/aligned_wcsdup.c
new file mode 100644
index 0000000..abb98e0
--- /dev/null
+++ b/aligned_wcsdup.c
@@ -0,0 +1,37 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline wchar_t *libsimple_aligned_wcsdup(const wchar_t *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *s;
+
+	assert((s = libsimple_aligned_wcsdup(L"test", 4)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(s)));
+		assert(info->size == 5 * sizeof(wchar_t) + (4 - 5 * sizeof(wchar_t) % 4) % 4);
+		assert(info->alignment == 4);
+		assert(!info->zeroed);
+	}
+	assert(!wmemcmp(s, L"test", 5));
+	free(s);
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert(!libsimple_aligned_wcsdup(L"test", 16) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/allocn.c b/allocn.c
index ce4fbad..540772e 100644
--- a/allocn.c
+++ b/allocn.c
@@ -78,7 +78,7 @@ int
 main(void)
 {
 	struct allocinfo *info;
-	void *ptr, *old;
+	void *ptr;
 
 	assert(!libsimple_malloczn(0, 0) && errno == EINVAL);
 	errno = 0;
@@ -88,17 +88,12 @@ main(void)
 	errno = 0;
 	assert(!libsimple_callocn(0) && errno == EINVAL);
 	errno = 0;
-	assert(!libsimple_reallocn(NULL, 0) && errno == EINVAL);
-	errno = 0;
 	assert(!libsimple_aligned_alloczn(0, 128, 0) && errno == EINVAL);
 	errno = 0;
 	assert(!libsimple_aligned_alloczn(1, 128, 0) && errno == EINVAL);
 	errno = 0;
 	assert(!libsimple_aligned_allocn(128, 0) && errno == EINVAL);
 	errno = 0;
-	assert(libsimple_posix_memalignzn(&ptr, 0, 128, 0) == EINVAL && !errno);
-	assert(libsimple_posix_memalignzn(&ptr, 1, 128, 0) == EINVAL && !errno);
-	assert(libsimple_posix_memalignn(&ptr, 128, 0) == EINVAL && !errno);
 
 	assert(!libsimple_malloczn(0, SIZE_MAX, 2, 0) && errno == ENOMEM);
 	errno = 0;
@@ -108,17 +103,12 @@ main(void)
 	errno = 0;
 	assert(!libsimple_callocn(SIZE_MAX, 2, 0) && errno == ENOMEM);
 	errno = 0;
-	assert(!libsimple_reallocn(NULL, SIZE_MAX, 2, 0) && errno == ENOMEM);
-	errno = 0;
 	assert(!libsimple_aligned_alloczn(0, 1024, SIZE_MAX, 2, 0) && errno == ENOMEM);
 	errno = 0;
 	assert(!libsimple_aligned_alloczn(1, 1024, SIZE_MAX, 2, 0) && errno == ENOMEM);
 	errno = 0;
 	assert(!libsimple_aligned_allocn(1024, SIZE_MAX, 2, 0) && errno == ENOMEM);
 	errno = 0;
-	assert(libsimple_posix_memalignzn(&ptr, 0, 1024, SIZE_MAX, 2, 0) == ENOMEM && !errno);
-	assert(libsimple_posix_memalignzn(&ptr, 1, 1024, SIZE_MAX, 2, 0) == ENOMEM && !errno);
-	assert(libsimple_posix_memalignn(&ptr, 1024, SIZE_MAX, 2, 0) == ENOMEM && !errno);
 
 	assert((ptr = libsimple_malloczn(0, 10, 10, 0)));
 	if (have_custom_malloc()) {
@@ -156,27 +146,6 @@ main(void)
 	}
 	free(ptr);
 
-	assert((ptr = libsimple_reallocn(NULL, 5, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5);
-		assert(!info->zeroed);
-		info->refcount += 1;
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	stpcpy(ptr, "test");
-	assert((ptr = libsimple_reallocn(old = ptr, 10, 0)));
-	assert(!strcmp(ptr, "test"));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 10);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		assert(ptr != old);
-		free(old);
-	}
-	free(ptr);
-
 	assert((ptr = libsimple_aligned_alloczn(0, 8, 12, 12, 0)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -207,36 +176,6 @@ main(void)
 	}
 	free(ptr);
 
-	assert(!libsimple_posix_memalignzn(&ptr, 0, sizeof(void *), 12, 12, 0));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 144);
-		assert(info->alignment == sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
-	assert(!libsimple_posix_memalignzn(&ptr, 1, 2 * sizeof(void *), 12, 12, 2, 0));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 288);
-		assert(info->alignment == 2 * sizeof(void *));
-		assert(info->zeroed == 288);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
-	assert(!libsimple_posix_memalignn(&ptr, 2 * sizeof(void *), 12, 12, 3, 0));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 432);
-		assert(info->alignment == 2 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
 	assert(!errno);
 
 	return 0;
diff --git a/asprintf.c b/asprintf.c
index 25bf07b..9c23204 100644
--- a/asprintf.c
+++ b/asprintf.c
@@ -21,10 +21,11 @@ libsimple_asprintf(char **strp, const char *fmt, ...)
 int
 main(void)
 {
-	char *s = "";
+	char empty[1] = "";
+	char *s = empty;
 	char *old = s;
 
-	assert(libsimple_asprintf(&s, "%i %X", 99999, 255) == sizeof("99999 FF") - 1);
+	assert(libsimple_asprintf(&s, "%i %X", 99999, 255U) == sizeof("99999 FF") - 1);
 	assert(s && s != old);
 	assert(!strcmpnul(s, "99999 FF"));
 	free(s);
diff --git a/cmptimespec.c b/cmptimespec.c
new file mode 100644
index 0000000..5a8463b
--- /dev/null
+++ b/cmptimespec.c
@@ -0,0 +1,133 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_cmptimespec(const struct timespec *, const struct timespec *);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct timespec ts1, ts2;
+	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 999999999L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = 0, ts1.tv_nsec = 999999999L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 999999999L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 999999999L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 999999999L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 999999999L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
+	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
+	ts2.tv_sec =  0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
+	ts2.tv_sec =  0, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
+	ts2.tv_sec =  0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
+	ts2.tv_sec =  0, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec =  0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec =  0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec =  0, ts1.tv_nsec = 0L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec =  0, ts1.tv_nsec = 1L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec = 0,        ts1.tv_nsec = 0L;
+	ts2.tv_sec = TIME_MAX, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = 1,        ts1.tv_nsec = 0L;
+	ts2.tv_sec = TIME_MAX, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	ts1.tv_sec = TIME_MAX, ts1.tv_nsec = 0L;
+	ts2.tv_sec = TIME_MAX, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
+	ts1.tv_sec =  1, ts1.tv_nsec = 0L;
+	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
+	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
+	ts2.tv_sec =  1, ts2.tv_nsec = 0L;
+	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
+	return 0;
+}
+
+#endif
diff --git a/cmptimeval.c b/cmptimeval.c
new file mode 100644
index 0000000..7324988
--- /dev/null
+++ b/cmptimeval.c
@@ -0,0 +1,248 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_cmptimeval(const struct timeval *, const struct timeval *);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct timeval tv1, tv2;
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 999999L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 999999L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 999999L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 999999L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 999999L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 999999L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = 0;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 1L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 1L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = 0;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = TIME_MAX;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = TIME_MAX;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	tv1.tv_sec  = TIME_MAX;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = TIME_MAX;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
+
+	tv1.tv_sec  = 1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = -1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
+
+	tv1.tv_sec  = -1;
+	tv1.tv_usec = 0L;
+	tv2.tv_sec  = 1;
+	tv2.tv_usec = 0L;
+	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
+
+	return 0;
+}
+
+#endif
diff --git a/difftimeval.c b/difftimeval.c
index 2f633a2..e4c65e4 100644
--- a/difftimeval.c
+++ b/difftimeval.c
@@ -47,104 +47,138 @@ main(void)
 {
 	struct timeval r, a, b;
 
-	a.tv_sec = 0, a.tv_usec = 0L;
-	b.tv_sec = 0, b.tv_usec = 0L;
+	a.tv_sec  = 0;
+	a.tv_usec = 0L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 0);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = 10, a.tv_usec = 0L;
-	b.tv_sec =  0, b.tv_usec = 0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 0L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 10);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = 10, a.tv_usec = 100L;
-	b.tv_sec =  0, b.tv_usec =   0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 100L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 10);
 	assert(r.tv_usec == 100L);
 
-	a.tv_sec = 10, a.tv_usec = 100L;
-	b.tv_sec =  1, b.tv_usec =   0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 100L;
+	b.tv_sec  = 1;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 9);
 	assert(r.tv_usec == 100L);
 
-	a.tv_sec = 10, a.tv_usec = 100L;
-	b.tv_sec =  0, b.tv_usec =   1L;
+	a.tv_sec  = 10;
+	a.tv_usec = 100L;
+	b.tv_sec  = 0;
+	b.tv_usec = 1L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 10);
 	assert(r.tv_usec == 99L);
 
-	a.tv_sec = -10, a.tv_usec = 100L;
-	b.tv_sec =   0, b.tv_usec =   0L;
+	a.tv_sec  = -10;
+	a.tv_usec = 100L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == -10);
 	assert(r.tv_usec == 100L);
 
-	a.tv_sec = 10, a.tv_usec =   1L;
-	b.tv_sec =  1, b.tv_usec = 100L;
+	a.tv_sec  = 10;
+	a.tv_usec = 1L;
+	b.tv_sec  = 1;
+	b.tv_usec = 100L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 8);
 	assert(r.tv_usec == 1000001L - 100L);
 
-	a.tv_sec = 10, a.tv_usec = 0L;
-	b.tv_sec = 20, b.tv_usec = 0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 0L;
+	b.tv_sec  = 20;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == -10);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = 10, a.tv_usec = 10L;
-	b.tv_sec = 20, b.tv_usec =  0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 10L;
+	b.tv_sec  = 20;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == -10);
 	assert(r.tv_usec == 10L);
 
-	a.tv_sec = 10, a.tv_usec = 10L;
-	b.tv_sec = 20, b.tv_usec = 20L;
+	a.tv_sec  = 10;
+	a.tv_usec = 10L;
+	b.tv_sec  = 20;
+	b.tv_usec = 20L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == -10 - 1);
 	assert(r.tv_usec == 1000010L - 20L);
 
-	a.tv_sec =  10, a.tv_usec = 10L;
-	b.tv_sec = -20, b.tv_usec =  0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 10L;
+	b.tv_sec  = -20;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 30);
 	assert(r.tv_usec == 10L);
 
-	a.tv_sec = 0, a.tv_usec = 10L;
-	b.tv_sec = 0, b.tv_usec =  0L;
+	a.tv_sec  = 0;
+	a.tv_usec = 10L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == 0);
 	assert(r.tv_usec == 10L);
 
-	a.tv_sec = 0, a.tv_usec =  0L;
-	b.tv_sec = 0, b.tv_usec = 10L;
+	a.tv_sec  = 0;
+	a.tv_usec = 0L;
+	b.tv_sec  = 0;
+	b.tv_usec = 10L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == -1);
 	assert(r.tv_usec == 1000000L - 10L);
 
-	a.tv_sec = TIME_MIN, a.tv_usec = 0L;
-	b.tv_sec = 0,        b.tv_usec = 0L;
+	a.tv_sec  = TIME_MIN;
+	a.tv_usec = 0L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == TIME_MIN);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = TIME_MIN, a.tv_usec = 0L;
-	b.tv_sec = 0,        b.tv_usec = 1L;
+	a.tv_sec  = TIME_MIN;
+	a.tv_usec = 0L;
+	b.tv_sec  = 0;
+	b.tv_usec = 1L;
 	assert(libsimple_difftimeval(&r, &a, &b) == -1 && errno == ERANGE);
 	assert(r.tv_sec  == TIME_MIN);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = TIME_MIN, a.tv_usec = 0L;
-	b.tv_sec = -1,       b.tv_usec = 1L;
+	a.tv_sec  = TIME_MIN;
+	a.tv_usec = 0L;
+	b.tv_sec  = -1;
+	b.tv_usec = 1L;
 	assert(!libsimple_difftimeval(&r, &a, &b));
 	assert(r.tv_sec  == TIME_MIN);
 	assert(r.tv_usec == 999999L);
 
-	a.tv_sec = TIME_MAX, a.tv_usec = 0L;
-	b.tv_sec = -1,       b.tv_usec = 0L;
+	a.tv_sec  = TIME_MAX;
+	a.tv_usec = 0L;
+	b.tv_sec  = -1;
+	b.tv_usec = 0L;
 	assert(libsimple_difftimeval(&r, &a, &b) == -1 && errno == ERANGE);
 	assert(r.tv_sec  == TIME_MAX);
 	assert(r.tv_usec == 999999L);
diff --git a/doubletotimespec.c b/doubletotimespec.c
index a104b37..02f40e9 100644
--- a/doubletotimespec.c
+++ b/doubletotimespec.c
@@ -6,7 +6,8 @@
 void
 libsimple_doubletotimespec(struct timespec *ts, double d)
 {
-	double ns = (long long int)d;
+	long long int d_integer = (long long int)d;
+	double ns = (double)d_integer;
 	long int nsi;
 	ns = d - ns;
 	ns *= (double)1000000000L;
diff --git a/doubletotimeval.c b/doubletotimeval.c
index 03bacec..c603703 100644
--- a/doubletotimeval.c
+++ b/doubletotimeval.c
@@ -6,7 +6,8 @@
 void
 libsimple_doubletotimeval(struct timeval *tv, double d)
 {
-	double ns = (long long int)d;
+	long long int d_integer = (long long int)d;
+	double ns = (double)d_integer;
 	long int nsi;
 	ns = d - ns;
 	ns *= (double)1000000L;
diff --git a/ealigned_strdup.c b/ealigned_strdup.c
new file mode 100644
index 0000000..f0fd7e4
--- /dev/null
+++ b/ealigned_strdup.c
@@ -0,0 +1,41 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline char *libsimple_ealigned_strdup(const char *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *s;
+
+	assert((s = libsimple_ealigned_strdup("test", 8)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(s)));
+		assert(info->size == 8);
+		assert(info->alignment == 8);
+		assert(!info->zeroed);
+	}
+	assert(!memcmp(s, "test", 5));
+	free(s);
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 55;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_ealigned_strdup("test", 8));
+		assert(exit_status == 55);
+		assert_stderr("%s: aligned_strdup: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/ealigned_wcsdup.c b/ealigned_wcsdup.c
new file mode 100644
index 0000000..a73a261
--- /dev/null
+++ b/ealigned_wcsdup.c
@@ -0,0 +1,41 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline wchar_t *libsimple_ealigned_wcsdup(const wchar_t *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *s;
+
+	assert((s = libsimple_ealigned_wcsdup(L"test", 8)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(s)));
+		assert(info->size == 5 * sizeof(wchar_t) + (8 - 5 * sizeof(wchar_t) % 8) % 8);
+		assert(info->alignment == 8);
+		assert(!info->zeroed);
+	}
+	assert(!wmemcmp(s, L"test", 5));
+	free(s);
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 55;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_ealigned_wcsdup(L"test", 8));
+		assert(exit_status == 55);
+		assert_stderr("%s: aligned_wcsdup: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/egmtime.c b/egmtime.c
new file mode 100644
index 0000000..85b62ee
--- /dev/null
+++ b/egmtime.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_egmtime(struct tm *, struct timespec *);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/elocaltime.c b/elocaltime.c
new file mode 100644
index 0000000..b3accdd
--- /dev/null
+++ b/elocaltime.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_elocaltime(struct tm *m, struct timespec *);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/ememalloc.c b/ememalloc.c
new file mode 100644
index 0000000..79b2059
--- /dev/null
+++ b/ememalloc.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_ememalloc(size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/enaligned_strdup.c b/enaligned_strdup.c
index 533ff56..b2e505b 100644
--- a/enaligned_strdup.c
+++ b/enaligned_strdup.c
@@ -32,44 +32,12 @@ main(void)
 	assert(!memcmp(s, "hello", 6));
 	free(s);
 
-	assert((s = libsimple_ealigned_strdup("test", 8)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(s)));
-		assert(info->size == 8);
-		assert(info->alignment == 8);
-		assert(!info->zeroed);
-	}
-	assert(!memcmp(s, "test", 5));
-	free(s);
-
-	assert((s = libsimple_aligned_strdup("test", 4)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(s)));
-		assert(info->size == 8);
-		assert(info->alignment == 4);
-		assert(!info->zeroed);
-	}
-	assert(!memcmp(s, "test", 5));
-	free(s);
-
 	if (have_custom_malloc()) {
 		alloc_fail_in = 1;
 		assert_exit_ptr(libsimple_enaligned_strdup(44, "hello", 2));
 		assert(exit_status == 44);
 		assert_stderr("%s: aligned_strdup: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 55;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_ealigned_strdup("test", 8));
-		assert(exit_status == 55);
-		assert_stderr("%s: aligned_strdup: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert(!libsimple_aligned_strdup("test", 16) && errno == ENOMEM);
-		assert(!alloc_fail_in);
 	}
 
 	return 0;
diff --git a/enaligned_wcsdup.c b/enaligned_wcsdup.c
index 10d9669..c048cc8 100644
--- a/enaligned_wcsdup.c
+++ b/enaligned_wcsdup.c
@@ -32,44 +32,12 @@ main(void)
 	assert(!wmemcmp(s, L"hello", 6));
 	free(s);
 
-	assert((s = libsimple_ealigned_wcsdup(L"test", 8)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(s)));
-		assert(info->size == 5 * sizeof(wchar_t) + (8 - 5 * sizeof(wchar_t) % 8) % 8);
-		assert(info->alignment == 8);
-		assert(!info->zeroed);
-	}
-	assert(!wmemcmp(s, L"test", 5));
-	free(s);
-
-	assert((s = libsimple_aligned_wcsdup(L"test", 4)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(s)));
-		assert(info->size == 5 * sizeof(wchar_t) + (4 - 5 * sizeof(wchar_t) % 4) % 4);
-		assert(info->alignment == 4);
-		assert(!info->zeroed);
-	}
-	assert(!wmemcmp(s, L"test", 5));
-	free(s);
-
 	if (have_custom_malloc()) {
 		alloc_fail_in = 1;
 		assert_exit_ptr(libsimple_enaligned_wcsdup(44, L"hello", 2));
 		assert(exit_status == 44);
 		assert_stderr("%s: aligned_wcsdup: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 55;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_ealigned_wcsdup(L"test", 8));
-		assert(exit_status == 55);
-		assert_stderr("%s: aligned_wcsdup: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert(!libsimple_aligned_wcsdup(L"test", 16) && errno == ENOMEM);
-		assert(!alloc_fail_in);
 	}
 
 	return 0;
diff --git a/engmtime.c b/engmtime.c
index 55e6c9c..5cc9a55 100644
--- a/engmtime.c
+++ b/engmtime.c
@@ -4,7 +4,7 @@
 
 
 void
-libsimple_engmtime(int status, struct tm *tm, struct timespec *ts)
+libsimple_engmtime(int status, struct tm *tm, struct timespec *ts) /* TODO test (also libsimple_egmtime) */
 {
 	if (libsimple_gmtime(tm, ts))
 		enprintf(status, "libsimple_gmtime:");
@@ -17,7 +17,6 @@ libsimple_engmtime(int status, struct tm *tm, struct timespec *ts)
 int
 main(void)
 {
-	/* TODO test */
 	return 0;
 }
 
diff --git a/enlocaltime.c b/enlocaltime.c
index af8907e..73fc99e 100644
--- a/enlocaltime.c
+++ b/enlocaltime.c
@@ -4,7 +4,7 @@
 
 
 void
-libsimple_enlocaltime(int status, struct tm *tm, struct timespec *ts)
+libsimple_enlocaltime(int status, struct tm *tm, struct timespec *ts) /* TODO test (also libsimple_elocaltime) */
 {
 	if (libsimple_localtime(tm, ts))
 		enprintf(status, "libsimple_localtime:");
@@ -17,7 +17,6 @@ libsimple_enlocaltime(int status, struct tm *tm, struct timespec *ts)
 int
 main(void)
 {
-	/* TODO test */
 	return 0;
 }
 
diff --git a/enmemalloc.c b/enmemalloc.c
new file mode 100644
index 0000000..b81147b
--- /dev/null
+++ b/enmemalloc.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_enmemalloc(int, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/enposix_memalign.c b/enposix_memalign.c
new file mode 100644
index 0000000..e2978e4
--- /dev/null
+++ b/enposix_memalign.c
@@ -0,0 +1,42 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_enposix_memalign(int, void **, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_enposix_memalign(1, &ptr, sizeof(void *), 8);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 8);
+		assert(info->alignment == sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit(libsimple_enposix_memalign(7, &ptr, sizeof(void *), 4));
+		assert(exit_status == 7);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/enposix_memalignn.c b/enposix_memalignn.c
new file mode 100644
index 0000000..121d7c0
--- /dev/null
+++ b/enposix_memalignn.c
@@ -0,0 +1,45 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_enposix_memalignn(int, void **, size_t, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_enposix_memalignn(1, &ptr, 4 * sizeof(void *), 4, 3, 0);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 12);
+		assert(info->alignment == 4 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit(libsimple_enposix_memalignn(9, &ptr, 4 * sizeof(void *), 1, 0));
+		assert(exit_status == 9);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	assert_exit(libsimple_enposix_memalignn(19, &ptr, sizeof(void *), SIZE_MAX, 2, 0));
+	assert(exit_status == 19);
+	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+
+	return 0;
+}
+
+#endif
diff --git a/enposix_memalignz.c b/enposix_memalignz.c
index 64ae4f0..81844ea 100644
--- a/enposix_memalignz.c
+++ b/enposix_memalignz.c
@@ -35,18 +35,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	libsimple_eposix_memalignz(&ptr, 1, 2 * sizeof(void *), 8);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 8);
-		assert(info->alignment == 2 * sizeof(void *));
-		assert(info->zeroed == 8);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	libsimple_enposix_memalignz(1, &ptr, 0, 2 * sizeof(void *), 8);
 	assert(ptr);
 	if (have_custom_malloc()) {
@@ -59,42 +47,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	libsimple_eposix_memalignz(&ptr, 0, 4 * sizeof(void *), 4);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 4);
-		assert(info->alignment == 4 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	libsimple_enposix_memalign(1, &ptr, sizeof(void *), 8);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 8);
-		assert(info->alignment == sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	libsimple_eposix_memalign(&ptr, 8 * sizeof(void *), 4);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 4);
-		assert(info->alignment == 8 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	if (have_custom_malloc()) {
 		alloc_fail_in = 1;
 		assert_exit(libsimple_enposix_memalignz(3, &ptr, 1, sizeof(void *), 4));
@@ -102,41 +54,11 @@ main(void)
 		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
 
-		libsimple_default_failure_exit = 102;
-		alloc_fail_in = 1;
-		assert_exit(libsimple_eposix_memalignz(&ptr, 1, sizeof(void *), 4));
-		assert(exit_status == 102);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
 		alloc_fail_in = 1;
 		assert_exit(libsimple_enposix_memalignz(5, &ptr, 0, sizeof(void *), 4));
 		assert(exit_status == 5);
 		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 103;
-		alloc_fail_in = 1;
-		assert_exit(libsimple_eposix_memalignz(&ptr, 0, sizeof(void *), 4));
-		assert(exit_status == 103);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert_exit(libsimple_enposix_memalign(7, &ptr, sizeof(void *), 4));
-		assert(exit_status == 7);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 104;
-		alloc_fail_in = 1;
-		assert_exit(libsimple_eposix_memalign(&ptr, sizeof(void *), 4));
-		assert(exit_status == 104);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
 	}
 
 	return 0;
diff --git a/enposix_memalignzn.c b/enposix_memalignzn.c
new file mode 100644
index 0000000..3606e74
--- /dev/null
+++ b/enposix_memalignzn.c
@@ -0,0 +1,68 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_enposix_memalignzn(int, void **, int, size_t, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_enposix_memalignzn(1, &ptr, 0, sizeof(void *), 5, 3, 0);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 15);
+		assert(info->alignment == sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	libsimple_enposix_memalignzn(1, &ptr, 1, 2 * sizeof(void *), 5, 4, 0);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 20);
+		assert(info->alignment == 2 * sizeof(void *));
+		assert(info->zeroed == 20);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit(libsimple_enposix_memalignzn(3, &ptr, 0, 4 * sizeof(void *), 4, 0));
+		assert(exit_status == 3);
+		stderr_buf[stderr_n] = 0;
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		assert_exit(libsimple_enposix_memalignzn(5, &ptr, 1, 4 * sizeof(void *), 2, 0));
+		assert(exit_status == 5);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	assert_exit(libsimple_enposix_memalignzn(13, &ptr, 0, sizeof(void *), SIZE_MAX, 2, 0));
+	assert(exit_status == 13);
+	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+
+	assert_exit(libsimple_enposix_memalignzn(15, &ptr, 1, sizeof(void *), SIZE_MAX, 2, 0));
+	assert(exit_status == 15);
+	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+
+	return 0;
+}
+
+#endif
diff --git a/enprintf.c b/enprintf.c
new file mode 100644
index 0000000..e896228
--- /dev/null
+++ b/enprintf.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_enprintf(int, const char *, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/enpvalloc.c b/enpvalloc.c
new file mode 100644
index 0000000..ab5df3a
--- /dev/null
+++ b/enpvalloc.c
@@ -0,0 +1,42 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_enpvalloc(int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_enpvalloc(1, 127)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_enpvalloc(7, 4));
+		assert(exit_status == 7);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/enpvallocn.c b/enpvallocn.c
new file mode 100644
index 0000000..e4692ec
--- /dev/null
+++ b/enpvallocn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_enpvallocn(int, size_t, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/enpvallocz.c b/enpvallocz.c
new file mode 100644
index 0000000..d20e6f6
--- /dev/null
+++ b/enpvallocz.c
@@ -0,0 +1,59 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_enpvallocz(int, int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_enpvallocz(1, 1, 5 * pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_enpvallocz(1, 0, pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_enpvallocz(3, 1, 4));
+		assert(exit_status == 3);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_enpvallocz(5, 0, 4));
+		assert(exit_status == 5);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/enpvalloczn.c b/enpvalloczn.c
new file mode 100644
index 0000000..94d56bf
--- /dev/null
+++ b/enpvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_enpvalloczn(int, int, size_t, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/enrealloc.c b/enrealloc.c
index b27cb18..fd3fa31 100644
--- a/enrealloc.c
+++ b/enrealloc.c
@@ -43,41 +43,12 @@ main(void)
 	}
 	free(ptr);
 
-	assert((ptr = libsimple_erealloc(NULL, 5)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		info->refcount += 1;
-	}
-	stpcpy(ptr, "test");
-	assert((ptr = libsimple_erealloc(old = ptr, 10)));
-	assert(!strcmp(ptr, "test"));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 10);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		assert(ptr != old);
-		free(old);
-	}
-	free(ptr);
-
 	if (have_custom_malloc()) {
 		alloc_fail_in = 1;
 		assert_exit_ptr(libsimple_enrealloc(2, NULL, 1));
 		assert(exit_status == 2);
 		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 104;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_erealloc(NULL, 1));
-		assert(exit_status == 104);
-		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
 	}
 
 	return 0;
diff --git a/enreallocarray.c b/enreallocarray.c
index c208626..48ac9bd 100644
--- a/enreallocarray.c
+++ b/enreallocarray.c
@@ -43,66 +43,12 @@ main(void)
 	}
 	free(ptr);
 
-	assert((ptr = libsimple_ereallocarray(NULL, 1, 5)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		info->refcount += 1;
-	}
-	stpcpy(ptr, "test");
-	assert((ptr = libsimple_ereallocarray(old = ptr, 10, 10)));
-	assert(!strcmp(ptr, "test"));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 100);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		assert(ptr != old);
-		free(old);
-	}
-	free(ptr);
-
-	assert((ptr = libsimple_reallocarray(NULL, 1, 5)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		info->refcount += 1;
-	}
-	stpcpy(ptr, "test");
-	assert((ptr = libsimple_reallocarray(old = ptr, 10, 10)));
-	assert(!strcmp(ptr, "test"));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 100);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		assert(ptr != old);
-		free(old);
-	}
-	free(ptr);
-
 	if (have_custom_malloc()) {
 		alloc_fail_in = 1;
 		assert_exit_ptr(libsimple_enreallocarray(2, NULL, 1, 1));
 		assert(exit_status == 2);
 		assert_stderr("%s: reallocarray: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 104;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_ereallocarray(NULL, 1, 1));
-		assert(exit_status == 104);
-		assert_stderr("%s: reallocarray: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert(!libsimple_reallocarray(NULL, 1, 1) && errno == ENOMEM);
-		assert(!alloc_fail_in);
 	}
 
 #if defined(__GNUC__) && !defined(__clang)
@@ -114,14 +60,6 @@ main(void)
 	assert(exit_status == 3);
 	assert_stderr("%s: reallocarray: %s\n", argv0, strerror(ENOMEM));
 
-	libsimple_default_failure_exit = 4;
-	assert_exit_ptr(libsimple_ereallocarray(NULL, SIZE_MAX, SIZE_MAX));
-	assert(exit_status == 4);
-	assert_stderr("%s: reallocarray: %s\n", argv0, strerror(ENOMEM));
-	libsimple_default_failure_exit = 1;
-
-	assert(!libsimple_reallocarray(NULL, SIZE_MAX, SIZE_MAX) && errno == ENOMEM);
-
 #if defined(__GNUC__) && !defined(__clang)
 # pragma GCC diagnostic pop
 #endif
diff --git a/enreallocn.c b/enreallocn.c
new file mode 100644
index 0000000..c1817d9
--- /dev/null
+++ b/enreallocn.c
@@ -0,0 +1,50 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_enreallocn(int, void *, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr, *old;
+
+	assert((ptr = libsimple_enreallocn(1, NULL, 5, 3, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 15);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		info->refcount += 1;
+	}
+	stpcpy(ptr, "test");
+	assert((ptr = libsimple_enreallocn(1, old = ptr, 10, 2, 0)));
+	assert(!strcmp(ptr, "test"));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 20);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		assert(ptr != old);
+		free(old);
+	}
+	free(ptr);
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_enreallocn(2, NULL, 1, 0));
+		assert(exit_status == 2);
+		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/envallocz.c b/envallocz.c
new file mode 100644
index 0000000..8e8d9b3
--- /dev/null
+++ b/envallocz.c
@@ -0,0 +1,59 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_envallocz(int, int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_envallocz(1, 1, 5 * pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5 * pagesize - 1);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_envallocz(1, 0, pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize - 1);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_envallocz(3, 1, 4));
+		assert(exit_status == 3);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_envallocz(5, 0, 4));
+		assert(exit_status == 5);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/envalloczn.c b/envalloczn.c
new file mode 100644
index 0000000..c9a68fa
--- /dev/null
+++ b/envalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_envalloczn(int, int, size_t, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/envposix_memalignn.c b/envposix_memalignn.c
new file mode 100644
index 0000000..d408e1a
--- /dev/null
+++ b/envposix_memalignn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_envposix_memalignn(int, void **, size_t, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_enposix_memalignn */
+}
+
+#endif
diff --git a/envposix_memalignzn.c b/envposix_memalignzn.c
index 62cc440..0693ac0 100644
--- a/envposix_memalignzn.c
+++ b/envposix_memalignzn.c
@@ -20,155 +20,7 @@ libsimple_envposix_memalignzn(int status, void **memptr, int clear, size_t align
 int
 main(void)
 {
-	struct allocinfo *info;
-	void *ptr = NULL;
-
-	libsimple_enposix_memalignzn(1, &ptr, 0, sizeof(void *), 5, 3, 0);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 15);
-		assert(info->alignment == sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	libsimple_enposix_memalignzn(1, &ptr, 1, 2 * sizeof(void *), 5, 4, 0);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 20);
-		assert(info->alignment == 2 * sizeof(void *));
-		assert(info->zeroed == 20);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	libsimple_enposix_memalignn(1, &ptr, 4 * sizeof(void *), 4, 3, 0);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 12);
-		assert(info->alignment == 4 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	if (have_custom_malloc()) {
-		alloc_fail_in = 1;
-		assert_exit(libsimple_enposix_memalignzn(3, &ptr, 0, 4 * sizeof(void *), 4, 0));
-		assert(exit_status == 3);
-		stderr_buf[stderr_n] = 0;
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert_exit(libsimple_enposix_memalignzn(5, &ptr, 1, 4 * sizeof(void *), 2, 0));
-		assert(exit_status == 5);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert_exit(libsimple_enposix_memalignn(9, &ptr, 4 * sizeof(void *), 1, 0));
-		assert(exit_status == 9);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-	}
-
-	assert_exit(libsimple_enposix_memalignzn(13, &ptr, 0, sizeof(void *), SIZE_MAX, 2, 0));
-	assert(exit_status == 13);
-	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-
-	assert_exit(libsimple_enposix_memalignzn(15, &ptr, 1, sizeof(void *), SIZE_MAX, 2, 0));
-	assert(exit_status == 15);
-	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-
-	assert_exit(libsimple_enposix_memalignn(19, &ptr, sizeof(void *), SIZE_MAX, 2, 0));
-	assert(exit_status == 19);
-	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-
-	ptr = NULL;
-
-	libsimple_eposix_memalignzn(&ptr, 0, 4 * sizeof(void *), 2, 5, 3, 0);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 30);
-		assert(info->alignment == 4 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	libsimple_eposix_memalignzn(&ptr, 1, sizeof(void *), 2, 5, 4, 0);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 40);
-		assert(info->alignment == sizeof(void *));
-		assert(info->zeroed == 40);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	libsimple_eposix_memalignn(&ptr, 2 * sizeof(void *), 2, 4, 3, 0);
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 24);
-		assert(info->alignment == 2 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	if (have_custom_malloc()) {
-		alloc_fail_in = 1;
-		libsimple_default_failure_exit = 23;
-		assert_exit(libsimple_eposix_memalignzn(&ptr, 0, sizeof(void *), 4, 0));
-		assert(exit_status == 23);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		libsimple_default_failure_exit = 25;
-		assert_exit(libsimple_eposix_memalignzn(&ptr, 1, sizeof(void *), 2, 0));
-		assert(exit_status == 25);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		libsimple_default_failure_exit = 29;
-		assert_exit(libsimple_eposix_memalignn(&ptr, sizeof(void *), 1, 0));
-		assert(exit_status == 29);
-		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-	}
-
-	libsimple_default_failure_exit = 33;
-	assert_exit(libsimple_eposix_memalignzn(&ptr, 0, sizeof(void *), SIZE_MAX, 2, 0));
-	assert(exit_status == 33);
-	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-
-	libsimple_default_failure_exit = 35;
-	assert_exit(libsimple_eposix_memalignzn(&ptr, 1, sizeof(void *), SIZE_MAX, 2, 0));
-	assert(exit_status == 35);
-	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-
-	libsimple_default_failure_exit = 39;
-	assert_exit(libsimple_eposix_memalignn(&ptr, sizeof(void *), SIZE_MAX, 2, 0));
-	assert(exit_status == 39);
-	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
-
-	return 0;
+	return 0; /* Tested via libsimple_enposix_memalignzn */
 }
 
 #endif
diff --git a/envpvallocn.c b/envpvallocn.c
new file mode 100644
index 0000000..46a3acd
--- /dev/null
+++ b/envpvallocn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_envpvallocn(int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_enpvallocn */
+}
+
+#endif
diff --git a/envpvalloczn.c b/envpvalloczn.c
new file mode 100644
index 0000000..16bd5c4
--- /dev/null
+++ b/envpvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_envpvalloczn(int, int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_enpvalloczn */
+}
+
+#endif
diff --git a/envreallocn.c b/envreallocn.c
index 03394a1..7fdc82e 100644
--- a/envreallocn.c
+++ b/envreallocn.c
@@ -19,68 +19,7 @@ libsimple_envreallocn(int status, void *ptr, size_t n, va_list ap)
 int
 main(void)
 {
-	struct allocinfo *info;
-	void *ptr, *old;
-
-	assert((ptr = libsimple_enreallocn(1, NULL, 5, 3, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 15);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		info->refcount += 1;
-	}
-	stpcpy(ptr, "test");
-	assert((ptr = libsimple_enreallocn(1, old = ptr, 10, 2, 0)));
-	assert(!strcmp(ptr, "test"));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 20);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		assert(ptr != old);
-		free(old);
-	}
-	free(ptr);
-
-	assert((ptr = libsimple_ereallocn(NULL, 5, 4, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 20);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		info->refcount += 1;
-	}
-	stpcpy(ptr, "test");
-	assert((ptr = libsimple_ereallocn(old = ptr, 10, 11, 0)));
-	assert(!strcmp(ptr, "test"));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 110);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-		assert(ptr != old);
-		free(old);
-	}
-	free(ptr);
-
-	if (have_custom_malloc()) {
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_enreallocn(2, NULL, 1, 0));
-		assert(exit_status == 2);
-		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 104;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_ereallocn(NULL, 1, 0));
-		assert(exit_status == 104);
-		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-	}
-
-	return 0;
+	return 0; /* Tested via libsimple_enreallocn */
 }
 
 #endif
diff --git a/envvalloczn.c b/envvalloczn.c
new file mode 100644
index 0000000..f7e7886
--- /dev/null
+++ b/envvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_envvalloczn(int, int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_envalloczn */
+}
+
+#endif
diff --git a/eposix_memalign.c b/eposix_memalign.c
new file mode 100644
index 0000000..b471235
--- /dev/null
+++ b/eposix_memalign.c
@@ -0,0 +1,43 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_eposix_memalign(void **, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_eposix_memalign(&ptr, 8 * sizeof(void *), 4);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 4);
+		assert(info->alignment == 8 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 104;
+		alloc_fail_in = 1;
+		assert_exit(libsimple_eposix_memalign(&ptr, sizeof(void *), 4));
+		assert(exit_status == 104);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/eposix_memalignn.c b/eposix_memalignn.c
new file mode 100644
index 0000000..2845fe6
--- /dev/null
+++ b/eposix_memalignn.c
@@ -0,0 +1,47 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_eposix_memalignn(void **, size_t, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_eposix_memalignn(&ptr, 2 * sizeof(void *), 2, 4, 3, 0);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 24);
+		assert(info->alignment == 2 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		libsimple_default_failure_exit = 29;
+		assert_exit(libsimple_eposix_memalignn(&ptr, sizeof(void *), 1, 0));
+		assert(exit_status == 29);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	libsimple_default_failure_exit = 39;
+	assert_exit(libsimple_eposix_memalignn(&ptr, sizeof(void *), SIZE_MAX, 2, 0));
+	assert(exit_status == 39);
+	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+
+	return 0;
+}
+
+#endif
diff --git a/eposix_memalignz.c b/eposix_memalignz.c
new file mode 100644
index 0000000..c0ac5c1
--- /dev/null
+++ b/eposix_memalignz.c
@@ -0,0 +1,63 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_eposix_memalignz(void **, int, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_eposix_memalignz(&ptr, 1, 2 * sizeof(void *), 8);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 8);
+		assert(info->alignment == 2 * sizeof(void *));
+		assert(info->zeroed == 8);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	libsimple_eposix_memalignz(&ptr, 0, 4 * sizeof(void *), 4);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 4);
+		assert(info->alignment == 4 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 102;
+		alloc_fail_in = 1;
+		assert_exit(libsimple_eposix_memalignz(&ptr, 1, sizeof(void *), 4));
+		assert(exit_status == 102);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+
+		libsimple_default_failure_exit = 103;
+		alloc_fail_in = 1;
+		assert_exit(libsimple_eposix_memalignz(&ptr, 0, sizeof(void *), 4));
+		assert(exit_status == 103);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/eposix_memalignzn.c b/eposix_memalignzn.c
new file mode 100644
index 0000000..acb2153
--- /dev/null
+++ b/eposix_memalignzn.c
@@ -0,0 +1,71 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_eposix_memalignzn(void **, int, size_t, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr = NULL;
+
+	libsimple_eposix_memalignzn(&ptr, 0, 4 * sizeof(void *), 2, 5, 3, 0);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 30);
+		assert(info->alignment == 4 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	libsimple_eposix_memalignzn(&ptr, 1, sizeof(void *), 2, 5, 4, 0);
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 40);
+		assert(info->alignment == sizeof(void *));
+		assert(info->zeroed == 40);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		libsimple_default_failure_exit = 23;
+		assert_exit(libsimple_eposix_memalignzn(&ptr, 0, sizeof(void *), 4, 0));
+		assert(exit_status == 23);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		libsimple_default_failure_exit = 25;
+		assert_exit(libsimple_eposix_memalignzn(&ptr, 1, sizeof(void *), 2, 0));
+		assert(exit_status == 25);
+		assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+	}
+
+	libsimple_default_failure_exit = 33;
+	assert_exit(libsimple_eposix_memalignzn(&ptr, 0, sizeof(void *), SIZE_MAX, 2, 0));
+	assert(exit_status == 33);
+	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+
+	libsimple_default_failure_exit = 35;
+	assert_exit(libsimple_eposix_memalignzn(&ptr, 1, sizeof(void *), SIZE_MAX, 2, 0));
+	assert(exit_status == 35);
+	assert_stderr("%s: posix_memalign: %s\n", argv0, strerror(ENOMEM));
+
+	return 0;
+}
+
+#endif
diff --git a/eprintf.c b/eprintf.c
new file mode 100644
index 0000000..039a62f
--- /dev/null
+++ b/eprintf.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_eprintf(const char *, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/epvalloc.c b/epvalloc.c
new file mode 100644
index 0000000..e3e4788
--- /dev/null
+++ b/epvalloc.c
@@ -0,0 +1,44 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_epvalloc(size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_epvalloc(3 * pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 3 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 104;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_epvalloc(4));
+		assert(exit_status == 104);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/epvallocn.c b/epvallocn.c
new file mode 100644
index 0000000..4fcf347
--- /dev/null
+++ b/epvallocn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_epvallocn(size_t, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/epvallocz.c b/epvallocz.c
new file mode 100644
index 0000000..c9da7df
--- /dev/null
+++ b/epvallocz.c
@@ -0,0 +1,63 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_epvallocz(int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_epvallocz(1, 3 * pagesize + 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 4 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_epvallocz(0, pagesize + 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 2 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 102;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_epvallocz(1, 4));
+		assert(exit_status == 102);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+
+		libsimple_default_failure_exit = 103;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_epvallocz(0, 4));
+		assert(exit_status == 103);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/epvalloczn.c b/epvalloczn.c
new file mode 100644
index 0000000..b6880c3
--- /dev/null
+++ b/epvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_epvalloczn(int, size_t, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/erealloc.c b/erealloc.c
new file mode 100644
index 0000000..1150ca2
--- /dev/null
+++ b/erealloc.c
@@ -0,0 +1,52 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_erealloc(void *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr, *old;
+
+	assert((ptr = libsimple_erealloc(NULL, 5)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		info->refcount += 1;
+	}
+	stpcpy(ptr, "test");
+	assert((ptr = libsimple_erealloc(old = ptr, 10)));
+	assert(!strcmp(ptr, "test"));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 10);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		assert(ptr != old);
+		free(old);
+	}
+	free(ptr);
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 104;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_erealloc(NULL, 1));
+		assert(exit_status == 104);
+		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/ereallocarray.c b/ereallocarray.c
new file mode 100644
index 0000000..da022ae
--- /dev/null
+++ b/ereallocarray.c
@@ -0,0 +1,67 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_ereallocarray(void *, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr, *old;
+
+	assert((ptr = libsimple_ereallocarray(NULL, 1, 5)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		info->refcount += 1;
+	}
+	stpcpy(ptr, "test");
+	assert((ptr = libsimple_ereallocarray(old = ptr, 10, 10)));
+	assert(!strcmp(ptr, "test"));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 100);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		assert(ptr != old);
+		free(old);
+	}
+	free(ptr);
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 104;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_ereallocarray(NULL, 1, 1));
+		assert(exit_status == 104);
+		assert_stderr("%s: reallocarray: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+#if defined(__GNUC__) && !defined(__clang)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Walloc-size-larger-than="
+#endif
+
+	libsimple_default_failure_exit = 4;
+	assert_exit_ptr(libsimple_ereallocarray(NULL, SIZE_MAX, SIZE_MAX));
+	assert(exit_status == 4);
+	assert_stderr("%s: reallocarray: %s\n", argv0, strerror(ENOMEM));
+	libsimple_default_failure_exit = 1;
+
+#if defined(__GNUC__) && !defined(__clang)
+# pragma GCC diagnostic pop
+#endif
+
+	return 0;
+}
+
+#endif
diff --git a/ereallocn.c b/ereallocn.c
new file mode 100644
index 0000000..17b1f09
--- /dev/null
+++ b/ereallocn.c
@@ -0,0 +1,52 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_ereallocn(void *, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr, *old;
+
+	assert((ptr = libsimple_ereallocn(NULL, 5, 4, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 20);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		info->refcount += 1;
+	}
+	stpcpy(ptr, "test");
+	assert((ptr = libsimple_ereallocn(old = ptr, 10, 11, 0)));
+	assert(!strcmp(ptr, "test"));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 110);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		assert(ptr != old);
+		free(old);
+	}
+	free(ptr);
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 104;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_ereallocn(NULL, 1, 0));
+		assert(exit_status == 104);
+		assert_stderr("%s: realloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/evallocz.c b/evallocz.c
new file mode 100644
index 0000000..1edd48c
--- /dev/null
+++ b/evallocz.c
@@ -0,0 +1,63 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evallocz(int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_evallocz(1, 3 * pagesize + 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 3 * pagesize + 1);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_evallocz(0, pagesize + 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize + 1);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		libsimple_default_failure_exit = 102;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_evallocz(1, 4));
+		assert(exit_status == 102);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+
+		libsimple_default_failure_exit = 103;
+		alloc_fail_in = 1;
+		assert_exit_ptr(libsimple_evallocz(0, 4));
+		assert(exit_status == 103);
+		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
+		assert(!alloc_fail_in);
+		libsimple_default_failure_exit = 1;
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/evalloczn.c b/evalloczn.c
new file mode 100644
index 0000000..9be9c16
--- /dev/null
+++ b/evalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evalloczn(int, size_t, ...); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/evmemalloc.c b/evmemalloc.c
new file mode 100644
index 0000000..2f04b4b
--- /dev/null
+++ b/evmemalloc.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evmemalloc(size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/evposix_memalignn.c b/evposix_memalignn.c
new file mode 100644
index 0000000..bd13743
--- /dev/null
+++ b/evposix_memalignn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_evposix_memalignn(void **, size_t, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_eposix_memalignn */
+}
+
+#endif
diff --git a/evposix_memalignzn.c b/evposix_memalignzn.c
new file mode 100644
index 0000000..71a5250
--- /dev/null
+++ b/evposix_memalignzn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_evposix_memalignzn(void **, int, size_t, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_eposix_memalignzn */
+}
+
+#endif
diff --git a/evpvallocn.c b/evpvallocn.c
new file mode 100644
index 0000000..4ce9e69
--- /dev/null
+++ b/evpvallocn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evpvallocn(size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_epvallocn */
+}
+
+#endif
diff --git a/evpvalloczn.c b/evpvalloczn.c
new file mode 100644
index 0000000..ddc593b
--- /dev/null
+++ b/evpvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evpvalloczn(int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_epvalloczn */
+}
+
+#endif
diff --git a/evreallocn.c b/evreallocn.c
new file mode 100644
index 0000000..5bddb0e
--- /dev/null
+++ b/evreallocn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evreallocn(void *, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_ereallocn */
+}
+
+#endif
diff --git a/evvalloczn.c b/evvalloczn.c
new file mode 100644
index 0000000..dee0a1c
--- /dev/null
+++ b/evvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_evvalloczn(int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_evalloczn */
+}
+
+#endif
diff --git a/getenv_e.c b/getenv_e.c
index c09859d..95eb34e 100644
--- a/getenv_e.c
+++ b/getenv_e.c
@@ -12,13 +12,16 @@ extern inline const char *libsimple_getenv_e(const char *);
 int
 main(void)
 {
+	char env1[] = "X=xyz";
+	char env2[] = "X=";
+
 	unsetenv("X");
 	assert(!getenv("X"));
 	assert(!strcmpnul(libsimple_getenv_e("X"), ""));
-	putenv("X=xyz");
+	putenv(env1);
 	assert(!strcmpnul(getenv("X"), "xyz"));
 	assert(!strcmpnul(libsimple_getenv_e("X"), "xyz"));
-	putenv("X=");
+	putenv(env2);
 	assert(!strcmpnul(getenv("X"), ""));
 	assert(!strcmpnul(libsimple_getenv_e("X"), ""));
 
diff --git a/getenv_ne.c b/getenv_ne.c
index b502fc8..e3b962a 100644
--- a/getenv_ne.c
+++ b/getenv_ne.c
@@ -12,13 +12,16 @@ extern inline char *libsimple_getenv_ne(const char *);
 int
 main(void)
 {
+	char env1[] = "X=xyz";
+	char env2[] = "X=";
+
 	unsetenv("X");
 	assert(!getenv("X"));
 	assert(!libsimple_getenv_ne("X"));
-	putenv("X=xyz");
+	putenv(env1);
 	assert(!strcmpnul(getenv("X"), "xyz"));
 	assert(!strcmpnul(libsimple_getenv_ne("X"), "xyz"));
-	putenv("X=");
+	putenv(env2);
 	assert(!strcmpnul(getenv("X"), ""));
 	assert(!libsimple_getenv_ne("X"));
 
diff --git a/libsimple-arg.c b/libsimple-arg.c
index 95581bf..7fcb91a 100644
--- a/libsimple-arg.c
+++ b/libsimple-arg.c
@@ -4,25 +4,25 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "test.h"
 #include "libsimple-arg.h"
+#include "test.h"
 
 
 #define PARSER_BEGIN\
 	int old_argc = argc;\
 	char **old_argv = argv;\
-	{
+	/* { */
 
 
 #define PARSER_END\
-	;}\
+	/* } */\
 	assert(argv0 == old_argv[0]);\
 	assert(argv == &old_argv[old_argc - argc]);\
 	return argc
 
 
 #define PARSER_END_NO_ARGV0\
-	}\
+	/* } */\
 	assert(argv0 == NULL);\
 	assert(argv == &old_argv[old_argc - argc]);\
 	return argc
@@ -260,252 +260,253 @@ usage(void)
 static int
 parser1(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	ARGBEGIN {
-	case 'a': SHORT_WITHOUT_ARG("-a"); break;
-	case 'b': SHORT_WITHOUT_ARG("-b"); break;
-	case 'c': SHORT_WITHOUT_ARG("-c"); break;
-	case 'd': SHORT_WITHOUT_ARG("-d"); break;
-	case 'e': SHORT_WITHOUT_ARG("-e"); break;
-	case 'A': SHORT_WITHOUT_ARG("-A"); break;
-	case 'B': SHORT_WITHOUT_ARG("-B"); break;
-	case 'C': SHORT_WITHOUT_ARG("-C"); break;
-	case 'D': SHORT_WITHOUT_ARG("-D"); break;
-	case 'E': SHORT_WITHOUT_ARG("-E"); break;
-	case 'x': SHORT_WITH_ARG("-x"); break;
-	case 'y': SHORT_WITH_ARG("-y"); break;
-	case 'z': SHORT_WITH_ARG("-z"); break;
-	case 'X': SHORT_WITH_ARG("-X"); break;
-	case 'Y': SHORT_WITH_ARG("-Y"); break;
-	case 'Z': SHORT_WITH_ARG("-Z"); break;
-	case '-': SHORT_WITHOUT_ARG("--"); break;
-	case ARGNUM: SHORT_WITH_ARGHERE("-#"); break;
-	case '@': SHORT_WITH_MISSING_ARG("-@"); break;
-	default:
+	PARSER_BEGIN {
+		ARGBEGIN {
+		case 'a': SHORT_WITHOUT_ARG("-a"); break;
+		case 'b': SHORT_WITHOUT_ARG("-b"); break;
+		case 'c': SHORT_WITHOUT_ARG("-c"); break;
+		case 'd': SHORT_WITHOUT_ARG("-d"); break;
+		case 'e': SHORT_WITHOUT_ARG("-e"); break;
+		case 'A': SHORT_WITHOUT_ARG("-A"); break;
+		case 'B': SHORT_WITHOUT_ARG("-B"); break;
+		case 'C': SHORT_WITHOUT_ARG("-C"); break;
+		case 'D': SHORT_WITHOUT_ARG("-D"); break;
+		case 'E': SHORT_WITHOUT_ARG("-E"); break;
+		case 'x': SHORT_WITH_ARG("-x"); break;
+		case 'y': SHORT_WITH_ARG("-y"); break;
+		case 'z': SHORT_WITH_ARG("-z"); break;
+		case 'X': SHORT_WITH_ARG("-X"); break;
+		case 'Y': SHORT_WITH_ARG("-Y"); break;
+		case 'Z': SHORT_WITH_ARG("-Z"); break;
+		case '-': SHORT_WITHOUT_ARG("--"); break;
+		case ARGNUM: SHORT_WITH_ARGHERE("-#"); break;
+		case '@': SHORT_WITH_MISSING_ARG("-@"); break;
+		default:
 		usage();
-	} ARGEND;
-	PARSER_END;
+		} ARGEND;
+	} PARSER_END;
 }
 
 
 static int
 parser2(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	SUBARGBEGIN {
-	case 'a': SHORT_WITHOUT_ARG("-a"); break;
-	case 'b': SHORT_WITHOUT_ARG("-b"); break;
-	case 'c': SHORT_WITHOUT_ARG("-c"); break;
-	case 'd': SHORT_WITHOUT_ARG("-d"); break;
-	case 'e': SHORT_WITHOUT_ARG("-e"); break;
-	case 'A': SHORT_WITHOUT_ARG("-A"); break;
-	case 'B': SHORT_WITHOUT_ARG("-B"); break;
-	case 'C': SHORT_WITHOUT_ARG("-C"); break;
-	case 'D': SHORT_WITHOUT_ARG("-D"); break;
-	case 'E': SHORT_WITHOUT_ARG("-E"); break;
-	case 'x': SHORT_WITH_ARG("-x"); break;
-	case 'y': SHORT_WITH_ARG("-y"); break;
-	case 'z': SHORT_WITH_ARG("-z"); break;
-	case 'X': SHORT_WITH_ARG("-X"); break;
-	case 'Y': SHORT_WITH_ARG("-Y"); break;
-	case 'Z': SHORT_WITH_ARG("-Z"); break;
-	case '-': SHORT_WITHOUT_ARG("--"); break;
-	case ARGNUM: SHORT_WITH_ARGHERE("-#"); break;
-	case '@': SHORT_WITH_MISSING_ARG("-@"); break;
-	default:
-		usage();
-	} ARGEND;
-	PARSER_END_NO_ARGV0;
+	PARSER_BEGIN {
+		SUBARGBEGIN {
+		case 'a': SHORT_WITHOUT_ARG("-a"); break;
+		case 'b': SHORT_WITHOUT_ARG("-b"); break;
+		case 'c': SHORT_WITHOUT_ARG("-c"); break;
+		case 'd': SHORT_WITHOUT_ARG("-d"); break;
+		case 'e': SHORT_WITHOUT_ARG("-e"); break;
+		case 'A': SHORT_WITHOUT_ARG("-A"); break;
+		case 'B': SHORT_WITHOUT_ARG("-B"); break;
+		case 'C': SHORT_WITHOUT_ARG("-C"); break;
+		case 'D': SHORT_WITHOUT_ARG("-D"); break;
+		case 'E': SHORT_WITHOUT_ARG("-E"); break;
+		case 'x': SHORT_WITH_ARG("-x"); break;
+		case 'y': SHORT_WITH_ARG("-y"); break;
+		case 'z': SHORT_WITH_ARG("-z"); break;
+		case 'X': SHORT_WITH_ARG("-X"); break;
+		case 'Y': SHORT_WITH_ARG("-Y"); break;
+		case 'Z': SHORT_WITH_ARG("-Z"); break;
+		case '-': SHORT_WITHOUT_ARG("--"); break;
+		case ARGNUM: SHORT_WITH_ARGHERE("-#"); break;
+		case '@': SHORT_WITH_MISSING_ARG("-@"); break;
+		default:
+			usage();
+		} ARGEND;
+	} PARSER_END_NO_ARGV0;
 }
 
 
 static int
 parser3(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	NOFLAGS(0);
-	PARSER_END;
+	PARSER_BEGIN {
+		NOFLAGS(0);
+	} PARSER_END;
 }
 
 
 static int
 parser4(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	NOFLAGS(argc);
-	PARSER_END;
+	PARSER_BEGIN {
+		NOFLAGS(argc);
+	} PARSER_END;
 }
 
 
 static int
 parser5(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	ARGBEGIN {
-	case 'a': SHORT_WITHOUT_ARG("-a"); break;
-	case 'x': SHORT_WITHOUT_ARG("-x"); break;
-	case '-': SHORT_WITHOUT_ARG("--"); break;
-	default:
-		usage();
-	} ARGALT('+') {
-	case 'a': SHORT_WITHOUT_ARG("+a"); break;
-	case 'y': SHORT_WITHOUT_ARG("+y"); break;
-	case '+': SHORT_WITHOUT_ARG("++"); break;
-	default:
-		usage();
-	} ARGALT('/') {
-	case 'a': SHORT_WITHOUT_ARG("/a"); break;
-	case 'z': SHORT_WITHOUT_ARG("/z"); break;
-	case '/': SHORT_WITHOUT_ARG("//"); break;
-	default:
-		usage();
-	} ARGALT('x') {
-	case 'a': SHORT_WITHOUT_ARG("xa"); break;
-	case 'b': SHORT_WITHOUT_ARG("xb"); break;
-	case 'x': SHORT_WITHOUT_ARG("xx"); break;
-	default:
-		usage();
-	} ARGEND;
-	PARSER_END;
+	PARSER_BEGIN {
+		ARGBEGIN {
+		case 'a': SHORT_WITHOUT_ARG("-a"); break;
+		case 'x': SHORT_WITHOUT_ARG("-x"); break;
+		case '-': SHORT_WITHOUT_ARG("--"); break;
+		default:
+			usage();
+		} ARGALT('+') {
+		case 'a': SHORT_WITHOUT_ARG("+a"); break;
+		case 'y': SHORT_WITHOUT_ARG("+y"); break;
+		case '+': SHORT_WITHOUT_ARG("++"); break;
+		default:
+			usage();
+		} ARGALT('/') {
+		case 'a': SHORT_WITHOUT_ARG("/a"); break;
+		case 'z': SHORT_WITHOUT_ARG("/z"); break;
+		case '/': SHORT_WITHOUT_ARG("//"); break;
+		default:
+			usage();
+		} ARGALT('x') {
+		case 'a': SHORT_WITHOUT_ARG("xa"); break;
+		case 'b': SHORT_WITHOUT_ARG("xb"); break;
+		case 'x': SHORT_WITHOUT_ARG("xx"); break;
+		default:
+			usage();
+		} ARGEND;
+	} PARSER_END;
 }
 
 
 static int
 parser6(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	ARGBEGIN2(1, 1) {
-	default:
-		assert(ARGHERE() == &LFLAG()[1]);
-		argv[0] = LFLAG();
-		goto stop;
-	} ARGALT('+') {
-	case 'a': SHORT_WITHOUT_ARG("+a"); break;
-	case 'b': SHORT_WITHOUT_ARG("+b"); break;
-	case 'c': SHORT_WITHOUT_ARG("+c"); break;
-	case 'd': SHORT_WITHOUT_ARG("+d"); break;
-	case 'e': SHORT_WITHOUT_ARG("+e"); break;
-	case 'A': SHORT_WITHOUT_ARG("+A"); break;
-	case 'B': SHORT_WITHOUT_ARG("+B"); break;
-	case 'C': SHORT_WITHOUT_ARG("+C"); break;
-	case 'D': SHORT_WITHOUT_ARG("+D"); break;
-	case 'E': SHORT_WITHOUT_ARG("+E"); break;
-	case 'x': SHORT_WITH_ARG("+x"); break;
-	case 'y': SHORT_WITH_ARG("+y"); break;
-	case 'z': SHORT_WITH_ARG("+z"); break;
-	case 'X': SHORT_WITH_ARG("+X"); break;
-	case 'Y': SHORT_WITH_ARG("+Y"); break;
-	case 'Z': SHORT_WITH_ARG("+Z"); break;
-	case '+': SHORT_WITHOUT_ARG("++"); break;
-	case ARGNUM: SHORT_WITH_ARGHERE("+#"); break;
-	case '@': SHORT_WITH_MISSING_ARG("+@"); break;
-	default:
-		usage();
-	} ARGEND;
-stop:
-	PARSER_END;
+	PARSER_BEGIN {
+		ARGBEGIN2(1, 1) {
+		default:
+			assert(ARGHERE() == &LFLAG()[1]);
+			argv[0] = LFLAG();
+			goto stop;
+		} ARGALT('+') {
+		case 'a': SHORT_WITHOUT_ARG("+a"); break;
+		case 'b': SHORT_WITHOUT_ARG("+b"); break;
+		case 'c': SHORT_WITHOUT_ARG("+c"); break;
+		case 'd': SHORT_WITHOUT_ARG("+d"); break;
+		case 'e': SHORT_WITHOUT_ARG("+e"); break;
+		case 'A': SHORT_WITHOUT_ARG("+A"); break;
+		case 'B': SHORT_WITHOUT_ARG("+B"); break;
+		case 'C': SHORT_WITHOUT_ARG("+C"); break;
+		case 'D': SHORT_WITHOUT_ARG("+D"); break;
+		case 'E': SHORT_WITHOUT_ARG("+E"); break;
+		case 'x': SHORT_WITH_ARG("+x"); break;
+		case 'y': SHORT_WITH_ARG("+y"); break;
+		case 'z': SHORT_WITH_ARG("+z"); break;
+		case 'X': SHORT_WITH_ARG("+X"); break;
+		case 'Y': SHORT_WITH_ARG("+Y"); break;
+		case 'Z': SHORT_WITH_ARG("+Z"); break;
+		case '+': SHORT_WITHOUT_ARG("++"); break;
+		case ARGNUM: SHORT_WITH_ARGHERE("+#"); break;
+		case '@': SHORT_WITH_MISSING_ARG("+@"); break;
+		default:
+			usage();
+		} ARGEND;
+	stop:;
+	} PARSER_END;
 }
 
 
 static int
 parser7(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	ARGBEGIN {
-	case '-':
-		if (TESTLONG("--alpha", 0))
-			LONG_WITHOUT_ARG("--alpha");
-		else if (TESTLONG("--alpha=", 0))
-			LONG_WITHOUT_ARG("--alpha=");
-		else if (TESTLONG("--beta", 1))
-			LONG_WITH_ARG("--beta");
-		else if (TESTLONG("--gamma=", 1))
-			LONG_WITH_ARG("--gamma");
-		else if (TESTLONG("--gamma", 0))
-			LONG_WITHOUT_ARG("--gamma");
-		else if (TESTLONG("--missing", 1))
-			LONG_WITH_MISSING_ARG("--missing");
-		else
+	PARSER_BEGIN {
+		ARGBEGIN {
+		case '-':
+			if (TESTLONG("--alpha", 0))
+				LONG_WITHOUT_ARG("--alpha");
+			else if (TESTLONG("--alpha=", 0))
+				LONG_WITHOUT_ARG("--alpha=");
+			else if (TESTLONG("--beta", 1))
+				LONG_WITH_ARG("--beta");
+			else if (TESTLONG("--gamma=", 1))
+				LONG_WITH_ARG("--gamma");
+			else if (TESTLONG("--gamma", 0))
+				LONG_WITHOUT_ARG("--gamma");
+			else if (TESTLONG("--missing", 1))
+				LONG_WITH_MISSING_ARG("--missing");
+			else
+				usage();
+			break;
+		default:
 			usage();
-		break;
-	default:
-		usage();
-	} ARGALT('+') {
-	case '+':
-		if (TESTLONG("++alpha", 0))
-			LONG_WITHOUT_ARG("++alpha");
-		else if (TESTLONG("++alpha=", 0))
-			LONG_WITHOUT_ARG("++alpha=");
-		else if (TESTLONG("++beta", 1))
-			LONG_WITH_ARG("++beta");
-		else if (TESTLONG("++gamma=", 1))
-			LONG_WITH_ARG("++gamma");
-		else if (TESTLONG("++gamma", 0))
-			LONG_WITHOUT_ARG("++gamma");
-		else if (TESTLONG("++missing", 1))
-			LONG_WITH_MISSING_ARG("++missing");
-		else
+		} ARGALT('+') {
+		case '+':
+			if (TESTLONG("++alpha", 0))
+				LONG_WITHOUT_ARG("++alpha");
+			else if (TESTLONG("++alpha=", 0))
+				LONG_WITHOUT_ARG("++alpha=");
+			else if (TESTLONG("++beta", 1))
+				LONG_WITH_ARG("++beta");
+			else if (TESTLONG("++gamma=", 1))
+				LONG_WITH_ARG("++gamma");
+			else if (TESTLONG("++gamma", 0))
+				LONG_WITHOUT_ARG("++gamma");
+			else if (TESTLONG("++missing", 1))
+				LONG_WITH_MISSING_ARG("++missing");
+			else
+				usage();
+			break;
+		default:
 			usage();
-		break;
-	default:
-		usage();
-	} ARGEND;
-	PARSER_END;
+		} ARGEND;
+	} PARSER_END;
 }
 
 
 static int
 parser8(int argc, char *argv[])
 {
-	PARSER_BEGIN;
-	ARGBEGIN {
-	case 'a': SHORT_WITHOUT_ARG("-a"); break;
-	case 'A': SHORT_WITHOUT_ARG("-A"); break;
-	case 'b': SHORT_WITH_ARG("-b"); break;
-	case 'g': SHORT_WITH_ARG("-g"); break;
-	case 'G': SHORT_WITHOUT_ARG("-G"); break;
-	case 'm': SHORT_WITH_MISSING_ARG("-m"); break;
-	case '-':
-		ARGMAPLONG(((struct longopt []){
-			{"--alpha", 'a', 0},
-			{"--alpha=", 'A', 0},
-			{"--beta", 'b', 1},
-			{"--gamma=", 'g', 1},
-			{"--gamma", 'G', 0},
-			{"--missing", 'm', 1},
-			{NULL, '\0', 0},
-		}));
-		/* fall through */
-	default:
-		usage();
-	} ARGALT('+') {
-	case 'a': SHORT_WITHOUT_ARG("+a"); break;
-	case 'A': SHORT_WITHOUT_ARG("+A"); break;
-	case 'b': SHORT_WITH_ARG("+b"); break;
-	case 'g': SHORT_WITH_ARG("+g"); break;
-	case 'G': SHORT_WITHOUT_ARG("+G"); break;
-	case 'm': SHORT_WITH_MISSING_ARG("+m"); break;
-	case '+':
-		ARGMAPLONG(((struct longopt []){
-			{"++alpha", 'a', 0},
-			{"++alpha=", 'A', 0},
-			{"++beta", 'b', 1},
-			{"++gamma=", 'g', 1},
-			{"++gamma", 'G', 0},
-			{"++missing", 'm', 1},
-			{NULL, '\0', 0},
-		}));
-		/* fall through */
-	default:
-		usage();
-	} ARGEND;
-	PARSER_END;
+	PARSER_BEGIN {
+		ARGBEGIN {
+		case 'a': SHORT_WITHOUT_ARG("-a"); break;
+		case 'A': SHORT_WITHOUT_ARG("-A"); break;
+		case 'b': SHORT_WITH_ARG("-b"); break;
+		case 'g': SHORT_WITH_ARG("-g"); break;
+		case 'G': SHORT_WITHOUT_ARG("-G"); break;
+		case 'm': SHORT_WITH_MISSING_ARG("-m"); break;
+		case '-':
+			ARGMAPLONG(((struct longopt []){
+				{"--alpha", 'a', 0},
+				{"--alpha=", 'A', 0},
+				{"--beta", 'b', 1},
+				{"--gamma=", 'g', 1},
+				{"--gamma", 'G', 0},
+				{"--missing", 'm', 1},
+				{NULL, '\0', 0},
+			}));
+			/* fall through */
+		default:
+			usage();
+		} ARGALT('+') {
+		case 'a': SHORT_WITHOUT_ARG("+a"); break;
+		case 'A': SHORT_WITHOUT_ARG("+A"); break;
+		case 'b': SHORT_WITH_ARG("+b"); break;
+		case 'g': SHORT_WITH_ARG("+g"); break;
+		case 'G': SHORT_WITHOUT_ARG("+G"); break;
+		case 'm': SHORT_WITH_MISSING_ARG("+m"); break;
+		case '+':
+			ARGMAPLONG(((struct longopt []){
+				{"++alpha", 'a', 0},
+				{"++alpha=", 'A', 0},
+				{"++beta", 'b', 1},
+				{"++gamma=", 'g', 1},
+				{"++gamma", 'G', 0},
+				{"++missing", 'm', 1},
+				{NULL, '\0', 0},
+			}));
+			/* fall through */
+		default:
+			usage();
+		} ARGEND;
+	} PARSER_END;
 }
 
 
 int
 main(void)
 {
+	char buf[10];
 	const char *a1;
 	size_t i;
 
@@ -696,22 +697,22 @@ main(void)
 	ASSERT_ENTRY("+G", NULL, NULL);
 	ASSERT_END();
 
-	argv0_1 = "[1]";
+	argv0_1 = strcpy(buf, "[1]");
 	assert_exit(usage1());
 	assert(exit_status == 1);
 	assert_stderr("usage: [1] -1\n");
 
-	argv0_2 = "[2]";
+	argv0_2 = strcpy(buf, "[2]");
 	assert_exit(usage2());
 	assert_stderr("usage: [2] -2\n");
 	assert(exit_status == 2);
 
-	argv0_3 = "[3]";
+	argv0_3 = strcpy(buf, "[3]");
 	assert_exit(usage3());
 	assert_stderr("usage: [3]\n");
 	assert(exit_status == 3);
 
-	argv0_0 = "[0]";
+	argv0_0 = strcpy(buf, "[0]");
 	assert_exit(usage0());
 	assert_stderr("usage: [0]\n");
 	assert(exit_status == 0);
diff --git a/libsimple-arg.h b/libsimple-arg.h
index 67be5e9..1d52b33 100644
--- a/libsimple-arg.h
+++ b/libsimple-arg.h
@@ -436,7 +436,7 @@ struct longopt {
 	static _LIBSIMPLE_NORETURN void\
 	usage(void)\
 	{\
-		const char *syn = SYNOPSIS ? SYNOPSIS : "";\
+		const char *syn = (const char *)SYNOPSIS ? SYNOPSIS : "";\
 		fprintf(stderr, "usage: %s%s%s\n", argv0, *syn ? " " : "", syn);\
 		exit(STATUS);\
 	}\
diff --git a/libsimple.c b/libsimple.c
index 1230b60..0140b84 100644
--- a/libsimple.c
+++ b/libsimple.c
@@ -89,8 +89,6 @@ main(void)
 {
 	struct allocinfo *volatile info;
 	void *ptr, *old;
-	struct timespec ts, ts1, ts2;
-	struct timeval tv1, tv2;
 	const char *cs;
 	const wchar_t *cws;
 	char buf[1024], *s;
@@ -225,14 +223,20 @@ main(void)
 	assert(MAX3(-3, -1, -2) == -1);
 	assert(MAX3(-3, -2, -1) == -1);
 
-	assert(ELEMSOF((char [1]){}) == 1);
-	assert(ELEMSOF((char [2]){}) == 2);
-	assert(ELEMSOF((char [3]){}) == 3);
-	assert(ELEMSOF((short int [3]){}) == 3);
-	assert(ELEMSOF((int [3]){}) == 3);
-	assert(ELEMSOF((long int [3]){}) == 3);
-	assert(ELEMSOF((float [3]){}) == 3);
-	assert(ELEMSOF((double [3]){}) == 3);
+#define _1 0
+#define _2 0, 0
+#define _3 0, 0, 0
+	assert(ELEMSOF((char []){_1}) == 1);
+	assert(ELEMSOF((char []){_2}) == 2);
+	assert(ELEMSOF((char []){_3}) == 3);
+	assert(ELEMSOF((short int []){_3}) == 3);
+	assert(ELEMSOF((int []){_3}) == 3);
+	assert(ELEMSOF((long int []){_3}) == 3);
+	assert(ELEMSOF((float []){_3}) == 3);
+	assert(ELEMSOF((double []){_3}) == 3);
+#undef _1
+#undef _2
+#undef _3
 
 	assert(STRLEN("") == 0);
 	assert(STRLEN("a") == 1);
@@ -285,10 +289,6 @@ main(void)
 	assert(libsimple_inchrset('z', "xyz") == 1);
 	assert(libsimple_inchrset('\0', "xyz") == 0);
 
-	stpcpy(buf, "abcxyz");
-	assert(libsimple_mempcpy(buf, "123", 3) == &buf[3]);
-	assert(!strcmpnul(buf, "123xyz"));
-
 	assert(libsimple_streq("abc", "abc") == 1);
 	assert(libsimple_streq("abc", "ab") == 0);
 	assert(libsimple_streq("ab", "abc") == 0);
@@ -962,258 +962,6 @@ main(void)
 	assert(test_timeval(0, 0, 0, 0, "+0.000000", "0"));
 	assert(test_timeval(-10, -10, 0, -10, "-10.000000", "-10"));
 
-	libsimple_timeval2timespec(&ts, &(struct timeval){0, 0L});
-	assert(ts.tv_sec  == 0);
-	assert(ts.tv_nsec == 0L);
-	libsimple_timeval2timespec(&ts, &(struct timeval){0, 1L});
-	assert(ts.tv_sec  == 0);
-	assert(ts.tv_nsec == 1000L);
-	libsimple_timeval2timespec(&ts, &(struct timeval){0, 999999L});
-	assert(ts.tv_sec  == 0);
-	assert(ts.tv_nsec == 999999000L);
-	libsimple_timeval2timespec(&ts, &(struct timeval){10, 0L});
-	assert(ts.tv_sec  == 10);
-	assert(ts.tv_nsec == 0L);
-	libsimple_timeval2timespec(&ts, &(struct timeval){10, 1L});
-	assert(ts.tv_sec  == 10);
-	assert(ts.tv_nsec == 1000L);
-	libsimple_timeval2timespec(&ts, &(struct timeval){-10, 0L});
-	assert(ts.tv_sec  == -10);
-	assert(ts.tv_nsec == 0L);
-	libsimple_timeval2timespec(&ts, &(struct timeval){-10, 1L});
-	assert(ts.tv_sec  == -10);
-	assert(ts.tv_nsec == 1000L);
-
-	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 999999999L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = 0, ts1.tv_nsec = 999999999L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 999999999L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 999999999L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 999999999L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 999999999L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = 1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 1, ts1.tv_nsec = 1L;
-	ts2.tv_sec = 1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
-	ts2.tv_sec =  0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
-	ts2.tv_sec =  0, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
-	ts2.tv_sec =  0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
-	ts2.tv_sec =  0, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec =  0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec =  0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec =  0, ts1.tv_nsec = 0L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec =  0, ts1.tv_nsec = 1L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 1L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 1L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec = 0,        ts1.tv_nsec = 0L;
-	ts2.tv_sec = TIME_MAX, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = 1,        ts1.tv_nsec = 0L;
-	ts2.tv_sec = TIME_MAX, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-	ts1.tv_sec = TIME_MAX, ts1.tv_nsec = 0L;
-	ts2.tv_sec = TIME_MAX, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 0);
-	ts1.tv_sec =  1, ts1.tv_nsec = 0L;
-	ts2.tv_sec = -1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == 1);
-	ts1.tv_sec = -1, ts1.tv_nsec = 0L;
-	ts2.tv_sec =  1, ts2.tv_nsec = 0L;
-	assert(libsimple_cmptimespec(&ts1, &ts2) == -1);
-
-	tv1.tv_sec = 0, tv1.tv_usec = 0L;
-	tv2.tv_sec = 0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = 0, tv1.tv_usec = 1L;
-	tv2.tv_sec = 0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 0, tv1.tv_usec = 999999L;
-	tv2.tv_sec = 0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 0, tv1.tv_usec = 0L;
-	tv2.tv_sec = 0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 0, tv1.tv_usec = 1L;
-	tv2.tv_sec = 0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = 0, tv1.tv_usec = 999999L;
-	tv2.tv_sec = 0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 0, tv1.tv_usec = 0L;
-	tv2.tv_sec = 0, tv2.tv_usec = 999999L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 0, tv1.tv_usec = 1L;
-	tv2.tv_sec = 0, tv2.tv_usec = 999999L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 0, tv1.tv_usec = 999999L;
-	tv2.tv_sec = 0, tv2.tv_usec = 999999L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = 1, tv1.tv_usec = 0L;
-	tv2.tv_sec = 0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 1, tv1.tv_usec = 1L;
-	tv2.tv_sec = 0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 1, tv1.tv_usec = 0L;
-	tv2.tv_sec = 0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 1, tv1.tv_usec = 1L;
-	tv2.tv_sec = 0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 0, tv1.tv_usec = 0L;
-	tv2.tv_sec = 1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 0, tv1.tv_usec = 1L;
-	tv2.tv_sec = 1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 0, tv1.tv_usec = 0L;
-	tv2.tv_sec = 1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 0, tv1.tv_usec = 1L;
-	tv2.tv_sec = 1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 1, tv1.tv_usec = 0L;
-	tv2.tv_sec = 1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = 1, tv1.tv_usec = 1L;
-	tv2.tv_sec = 1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = 1, tv1.tv_usec = 0L;
-	tv2.tv_sec = 1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 1, tv1.tv_usec = 1L;
-	tv2.tv_sec = 1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = -1, tv1.tv_usec = 0L;
-	tv2.tv_sec =  0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = -1, tv1.tv_usec = 1L;
-	tv2.tv_sec =  0, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = -1, tv1.tv_usec = 0L;
-	tv2.tv_sec =  0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = -1, tv1.tv_usec = 1L;
-	tv2.tv_sec =  0, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec =  0, tv1.tv_usec = 0L;
-	tv2.tv_sec = -1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec =  0, tv1.tv_usec = 1L;
-	tv2.tv_sec = -1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec =  0, tv1.tv_usec = 0L;
-	tv2.tv_sec = -1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec =  0, tv1.tv_usec = 1L;
-	tv2.tv_sec = -1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = -1, tv1.tv_usec = 0L;
-	tv2.tv_sec = -1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = -1, tv1.tv_usec = 1L;
-	tv2.tv_sec = -1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = -1, tv1.tv_usec = 0L;
-	tv2.tv_sec = -1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = -1, tv1.tv_usec = 1L;
-	tv2.tv_sec = -1, tv2.tv_usec = 1L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec = 0,        tv1.tv_usec = 0L;
-	tv2.tv_sec = TIME_MAX, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = 1,        tv1.tv_usec = 0L;
-	tv2.tv_sec = TIME_MAX, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-	tv1.tv_sec = TIME_MAX, tv1.tv_usec = 0L;
-	tv2.tv_sec = TIME_MAX, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 0);
-	tv1.tv_sec =  1, tv1.tv_usec = 0L;
-	tv2.tv_sec = -1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == 1);
-	tv1.tv_sec = -1, tv1.tv_usec = 0L;
-	tv2.tv_sec =  1, tv2.tv_usec = 0L;
-	assert(libsimple_cmptimeval(&tv1, &tv2) == -1);
-
 	assert((ptr = libsimple_mallocz(0, 11)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1289,30 +1037,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	assert(!libsimple_posix_memalignz(&ptr, 0, 8 * sizeof(void *), 8));
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 8);
-		ASSERT_ALIGNMENT(info, 8 * sizeof(void *));
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert(!libsimple_posix_memalignz(&ptr, 1, 4 * sizeof(void *), 16));
-	assert(ptr);
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 16);
-		ASSERT_ALIGNMENT(info, 4 * sizeof(void *));
-		assert(info->zeroed == 16);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	assert((ptr = libsimple_memalignz(0, 4, 9)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1484,28 +1208,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	assert((ptr = libsimple_vallocz(0, 9)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 9 || info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_vallocz(1, 7)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 7 || info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == 7 || info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	assert((ptr = libsimple_valloc(5)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1517,28 +1219,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	assert((ptr = libsimple_vallocz(1, 3 * pagesize)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 3 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == 3 * pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_vallocz(0, 4 * pagesize)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 4 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	assert((ptr = libsimple_valloc(5 * pagesize)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1550,28 +1230,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	assert((ptr = libsimple_valloczn(1, 3 * pagesize, 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 6 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == 6 * pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_valloczn(0, 4 * pagesize, 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 8 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	assert((ptr = libsimple_vallocn(5 * pagesize, 2, 0)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1583,186 +1241,12 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	assert(!libsimple_valloczn(0, 0) && errno == EINVAL);
-	errno = 0;
-	assert(!libsimple_valloczn(1, 0) && errno == EINVAL);
-	errno = 0;
 	assert(!libsimple_vallocn(0) && errno == EINVAL);
 	errno = 0;
 
-	assert(!libsimple_valloczn(0, SIZE_MAX, 2, 0) && errno == ENOMEM);
-	errno = 0;
-	assert(!libsimple_valloczn(1, SIZE_MAX, 2, 0) && errno == ENOMEM);
-	errno = 0;
 	assert(!libsimple_vallocn(SIZE_MAX, 2, 0) && errno == ENOMEM);
 	errno = 0;
 
-	assert((ptr = libsimple_pvallocz(0, 9)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocz(1, 7)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvalloc(5)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5 || info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocz(1, pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocz(1, pagesize)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocz(1, pagesize + 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 2 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == 2 * pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocz(1, 3 * pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 3 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == 3 * pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocz(0, 4 * pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 4 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvalloc(5 * pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvalloczn(1, 3 * pagesize - 1, 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 6 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == 6 * pagesize);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvalloczn(0, 4 * pagesize - 1, 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 8 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_pvallocn(5 * pagesize - 1, 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 10 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert(!libsimple_pvalloczn(0, 0) && errno == EINVAL);
-	errno = 0;
-	assert(!libsimple_pvalloczn(1, 0) && errno == EINVAL);
-	errno = 0;
-	assert(!libsimple_pvallocn(0) && errno == EINVAL);
-	errno = 0;
-
-	assert(!libsimple_pvalloczn(0, SIZE_MAX, 2, 0) && errno == ENOMEM);
-	errno = 0;
-	assert(!libsimple_pvalloczn(1, SIZE_MAX, 2, 0) && errno == ENOMEM);
-	errno = 0;
-	assert(!libsimple_pvallocn(SIZE_MAX, 2, 0) && errno == ENOMEM);
-	errno = 0;
-
-	assert((ptr = libsimple_valloczn(0, 9, 9, pagesize - 1, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 81 * (pagesize - 1));
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
-	assert((ptr = libsimple_valloczn(1, 9, 8, pagesize - 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 72 * (pagesize - 2));
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
 	assert((ptr = libsimple_vallocn(9, (pagesize - 1), 0)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1773,50 +1257,6 @@ main(void)
 	}
 	free(ptr);
 
-	assert((ptr = libsimple_envallocz(1, 1, 5 * pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5 * pagesize - 1);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_evallocz(1, 3 * pagesize + 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 3 * pagesize + 1);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_envallocz(1, 0, pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize - 1);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_evallocz(0, pagesize + 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize + 1);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	assert((ptr = libsimple_envalloc(1, 127)));
 	if (have_custom_malloc()) {
 		assert((info = get_allocinfo(ptr)));
@@ -1839,102 +1279,6 @@ main(void)
 	free(ptr);
 	ptr = NULL;
 
-	assert((ptr = libsimple_pvalloczn(0, 9, 9, pagesize - 1, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 81 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
-	assert((ptr = libsimple_pvalloczn(1, 9, 8, pagesize - 2, 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 72 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
-	assert((ptr = libsimple_pvallocn(9, (pagesize - 1), 0)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 9 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-
-	assert((ptr = libsimple_enpvallocz(1, 1, 5 * pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 5 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_epvallocz(1, 3 * pagesize + 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 4 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(info->zeroed == info->size);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_enpvallocz(1, 0, pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_epvallocz(0, pagesize + 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 2 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_enpvalloc(1, 127)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
-	assert((ptr = libsimple_epvalloc(3 * pagesize - 1)));
-	if (have_custom_malloc()) {
-		assert((info = get_allocinfo(ptr)));
-		assert(info->size == 3 * pagesize);
-		ASSERT_ALIGNMENT(info, pagesize);
-		assert(!info->zeroed);
-		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
-	}
-	free(ptr);
-	ptr = NULL;
-
 	if (have_custom_malloc()) {
 		alloc_fail_in = 1;
 		assert_exit_ptr(libsimple_enmallocz(5, 0, 20));
@@ -1981,14 +1325,6 @@ main(void)
 		errno = 0;
 
 		alloc_fail_in = 1;
-		assert(libsimple_posix_memalignz(&ptr, 0, 4 * sizeof(void *), 8) == ENOMEM && !errno);
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert(libsimple_posix_memalignz(&ptr, 1, 16 * sizeof(void *), 16) == ENOMEM && !errno);
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
 		assert(!libsimple_memalignz(0, 4 * sizeof(void *), 8) && errno == ENOMEM);
 		assert(!alloc_fail_in);
 
@@ -2039,42 +1375,6 @@ main(void)
 		libsimple_default_failure_exit = 1;
 
 		alloc_fail_in = 1;
-		assert(!libsimple_vallocz(0, 8) && errno == ENOMEM);
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert(!libsimple_vallocz(1, 16) && errno == ENOMEM);
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_envallocz(3, 1, 4));
-		assert(exit_status == 3);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 102;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_evallocz(1, 4));
-		assert(exit_status == 102);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_envallocz(5, 0, 4));
-		assert(exit_status == 5);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 103;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_evallocz(0, 4));
-		assert(exit_status == 103);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
 		assert_exit_ptr(libsimple_envalloc(7, 4));
 		assert(exit_status == 7);
 		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
@@ -2087,56 +1387,6 @@ main(void)
 		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
 		assert(!alloc_fail_in);
 		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert(!libsimple_pvallocz(0, 8) && errno == ENOMEM);
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert(!libsimple_pvallocz(1, 16) && errno == ENOMEM);
-		assert(!alloc_fail_in);
-
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_enpvallocz(3, 1, 4));
-		assert(exit_status == 3);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 102;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_epvallocz(1, 4));
-		assert(exit_status == 102);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_enpvallocz(5, 0, 4));
-		assert(exit_status == 5);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 103;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_epvallocz(0, 4));
-		assert(exit_status == 103);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
-
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_enpvalloc(7, 4));
-		assert(exit_status == 7);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-
-		libsimple_default_failure_exit = 104;
-		alloc_fail_in = 1;
-		assert_exit_ptr(libsimple_epvalloc(4));
-		assert(exit_status == 104);
-		assert_stderr("%s: libsimple_vmemalloc: %s\n", argv0, strerror(ENOMEM));
-		assert(!alloc_fail_in);
-		libsimple_default_failure_exit = 1;
 	}
 
 	assert_exit_ptr(libsimple_enmemalignz(3, 1, 0, 4));
@@ -2259,28 +1509,6 @@ main(void)
 	assert(libsimple_aligned_reallocarray(NULL, 8, 1, 1) && errno == ENOSYS);
 #endif
 
-	assert(libsimple_memeq("abcxyz", "abc123", 3));
-	assert(!libsimple_memeq("abcxyz", "abc123", 4));
-	assert(libsimple_memeq("abcxyz", "abcx23", 4));
-	assert(libsimple_memeq("1", "2", 0));
-	assert(!libsimple_memeq("1", "2", 1));
-	assert(!libsimple_memeq("abc", "ABC", 3));
-	assert(!libsimple_memeq("ABC", "abc", 3));
-	assert(libsimple_memeq("ABC", "ABC", 3));
-
-	assert(libsimple_memcaseeq("abcxyz", "abc123", 3));
-	assert(!libsimple_memcaseeq("abcxyz", "abc123", 4));
-	assert(libsimple_memcaseeq("abcxyz", "abcx23", 4));
-	assert(libsimple_memcaseeq("1", "2", 0));
-	assert(!libsimple_memcaseeq("1", "2", 1));
-	assert(libsimple_memcaseeq("abc", "ABC", 3));
-	assert(libsimple_memcaseeq("ABC", "abc", 3));
-	assert(libsimple_memcaseeq("ABC", "ABC", 3));
-
-	stpcpy(buf, "abc123");
-	assert(!strcmpnul(libsimple_mempset(buf, '.', 3), "123"));
-	assert(!strcmp(buf, "...123"));
-
 #ifdef libsimple_asprintfa
 	s = libsimple_asprintfa("%sxyz%s", "abc", "123");
 	assert(s);
@@ -2443,15 +1671,6 @@ main(void)
 
 
 	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
-	assert(libsimple_memreplace(buf, 'o', 'x', 46) == &buf[46]);
-	assert(!memcmp(buf, "hellx wxrld\0gxxdbye wxrld", 26));
-
-	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
-	assert(libsimple_memreplace(buf, 'o', 'x', 12) == &buf[12]);
-	assert(!memcmp(buf, "hellx wxrld\0goodbye world", 26));
-
-
-	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
 	assert(libsimple_strreplace(buf, 'o', 'x') == &buf[11]);
 	assert(!memcmp(buf, "hellx wxrld\0goodbye world", 26));
 
@@ -2708,64 +1927,6 @@ main(void)
 	assert(!strncmp(buf, "helx", 4));
 
 
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_rawmemcmove(&buf[5], &buf[5], 'o') == &buf[5 + 5]);
-	assert(!strncmp(buf, "-----hello-", 11));
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';;
-	assert(libsimple_rawmemcmove(&buf[5], &buf[5], 'l') == &buf[5 + 3]);
-	assert(!strncmp(buf, "-----hello-", 11));
-
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_rawmemcmove(&buf[3], &buf[5], 'o') == &buf[3 + 5]);
-	assert(!strncmp(buf, "---hellolo-", 11));
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_rawmemcmove(&buf[3], &buf[5], 'l') == &buf[3 + 3]);
-	assert(!strncmp(buf, "---helello-", 11));
-
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_rawmemcmove(&buf[8], &buf[5], 'o') == &buf[8 + 5]);
-	assert(!strncmp(buf, "-----helhello-", 14));
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_rawmemcmove(&buf[8], &buf[5], 'l') == &buf[8 + 3]);
-	assert(!strncmp(buf, "-----helhel-", 12));
-
-
-	memset(buf, 'x', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	assert(libsimple_rawmemccpy(buf, "hello", 'o') == &buf[5]);
-	assert(!strncmp(buf, "hellox", 6));
-
-	memset(buf, 'x', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	assert(libsimple_rawmemccpy(buf, "hello", 'l') == &buf[3]);
-	assert(!strncmp(buf, "helx", 4));
-
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_mempmove(&buf[5], &buf[5], 5) == &buf[5 + 5]);
-	assert(!strncmp(buf, "-----hello-", 11));
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_mempmove(&buf[3], &buf[5], 5) == &buf[3 + 5]);
-	assert(!strncmp(buf, "---hellolo-", 11));
-
-	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';
-	assert(libsimple_mempmove(&buf[8], &buf[5], 5) == &buf[8 + 5]);
-	assert(!strncmp(buf, "-----helhello-", 14));
-
-
 	if (!have_custom_malloc()) {
 		stderr_real = 1;
 		fprintf(stderr, "\nSome tests have not been ran because malloc(3) was not "
diff --git a/libsimple.h b/libsimple.h
index 2dda0c2..8af98e8 100644
--- a/libsimple.h
+++ b/libsimple.h
@@ -43,51 +43,56 @@
 #include <wctype.h>
 
 
+#if defined(__GLIBC__) && (__GLIBC_PREREQ(2, 29) ? defined(_DEFAULT_SOURCE) : (__GLIBC_PREREQ(2, 26) && defined(_GNU_SOURCE)))
+# define reallocarray reallocarray
+#endif
+
+
 
 #if defined(__GNUC__) && !defined(__clang__)
-# define _LIBSIMPLE_GCC_ONLY(x) x
-# define _LIBSIMPLE_NON_GCC_ONLY(x)
+# define LIBSIMPLE_GCC_ONLY__(x) x
+# define LIBSIMPLE_NON_GCC_ONLY__(x)
 #else
-# define _LIBSIMPLE_GCC_ONLY(x)
-# define _LIBSIMPLE_NON_GCC_ONLY(x) x
+# define LIBSIMPLE_GCC_ONLY__(x)
+# define LIBSIMPLE_NON_GCC_ONLY__(x) x
 #endif
 
 #if __STDC_VERSION__ >= 199409L
-# define _LIBSIMPLE_C95_ONLY(x) x
-# define _LIBSIMPLE_PRE_C95_ONLY(x)
+# define LIBSIMPLE_C95_ONLY__(x) x
+# define LIBSIMPLE_PRE_C95_ONLY__(x)
 #else
-# define _LIBSIMPLE_C95_ONLY(x)
-# define _LIBSIMPLE_PRE_C95_ONLY(x) x
+# define LIBSIMPLE_C95_ONLY__(x)
+# define LIBSIMPLE_PRE_C95_ONLY__(x) x
 #endif
 
 #if __STDC_VERSION__ >= 199901L
-# define _LIBSIMPLE_C99_ONLY(x) x
-# define _LIBSIMPLE_PRE_C99_ONLY(x)
+# define LIBSIMPLE_C99_ONLY__(x) x
+# define LIBSIMPLE_PRE_C99_ONLY__(x)
 #else
-# define _LIBSIMPLE_C99_ONLY(x)
-# define _LIBSIMPLE_PRE_C99_ONLY(x) x
+# define LIBSIMPLE_C99_ONLY__(x)
+# define LIBSIMPLE_PRE_C99_ONLY__(x) x
 #endif
 
 #if __STDC_VERSION__ >= 201112L
-# define _LIBSIMPLE_C11_ONLY(x) x
-# define _LIBSIMPLE_PRE_C11_ONLY(x)
+# define LIBSIMPLE_C11_ONLY__(x) x
+# define LIBSIMPLE_PRE_C11_ONLY__(x)
 #else
-# define _LIBSIMPLE_C11_ONLY(x)
-# define _LIBSIMPLE_PRE_C11_ONLY(x) x
+# define LIBSIMPLE_C11_ONLY__(x)
+# define LIBSIMPLE_PRE_C11_ONLY__(x) x
 #endif
 
 #if __STDC_VERSION__ >= 201710L
-# define _LIBSIMPLE_C17_ONLY(x) x
-# define _LIBSIMPLE_PRE_C17_ONLY(x)
+# define LIBSIMPLE_C17_ONLY__(x) x
+# define LIBSIMPLE_PRE_C17_ONLY__(x)
 #else
-# define _LIBSIMPLE_C17_ONLY(x)
-# define _LIBSIMPLE_PRE_C17_ONLY(x) x
+# define LIBSIMPLE_C17_ONLY__(x)
+# define LIBSIMPLE_PRE_C17_ONLY__(x) x
 #endif
 
 
-#define _libsimple_assume_aligned_as(TYPE)\
-	_LIBSIMPLE_C11_ONLY(__assume_aligned__(_Alignof(TYPE)))\
-	_LIBSIMPLE_PRE_C11_ONLY(_LIBSIMPLE_GCC_ONLY__assume_aligned__(__alignof(TYPE)))
+#define libsimple_assume_aligned_as__(TYPE)\
+	LIBSIMPLE_C11_ONLY__(__assume_aligned__(_Alignof(TYPE)))\
+	LIBSIMPLE_PRE_C11_ONLY__(LIBSIMPLE_GCC_ONLY__(__assume_aligned__(__alignof(TYPE))))
 
 
 #include "libsimple/overflow.h"
@@ -141,16 +146,16 @@
  * @return       Return value of close(3) (0 on success,
  *               -1 on error), 0 if `*fdp < 0`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 inline int
-libsimple_close(int *__fdp)
+libsimple_close(int *fdp__)
 {
-	int __ret;
-	if (*__fdp < 0)
+	int ret__;
+	if (*fdp__ < 0)
 		return 0;
-	__ret = close(*__fdp);
-	*__fdp = -1;
-	return __ret;
+	ret__ = close(*fdp__);
+	*fdp__ = -1;
+	return ret__;
 }
 
 
@@ -179,45 +184,45 @@ libsimple_close(int *__fdp)
  * @param  n      Pointer to the number of items in the list, will be updated
  * @param  width  The width, in bytes, of each item in the list
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 inline void
-libsimple_unlist(void *__list, size_t __i, size_t *__np, size_t __width)
+libsimple_unlist(void *list__, size_t i__, size_t *np__, size_t width__)
 {
-        char *__lst = __list;
-        memmove(&__lst[__i * __width], &__lst[(__i + 1) * __width], (--*__np - __i) * __width);
+        char *lst__ = list__;
+        memmove(&lst__[i__ * width__], &lst__[(i__ + 1) * width__], (--*np__ - i__) * width__);
 }
 #ifndef unlist
 # define unlist libsimple_unlist
 #endif
 
 
-#define _LIBSIMPLE_REMOVE_CONST(X, TYPE, ...) (*(TYPE *)(void *)&(X))
-#define LIBSIMPLE_REMOVE_CONST(...) _LIBSIMPLE_REMOVE_CONST(__VA_ARGS__, void *) /* TODO test, doc, man */
+#define LIBSIMPLE_REMOVE_CONST__(X, TYPE, ...) (*(TYPE *)(void *)&(X))
+#define LIBSIMPLE_REMOVE_CONST(...) LIBSIMPLE_REMOVE_CONST__(__VA_ARGS__, void *) /* TODO test, doc, man */
 #ifndef REMOVE_CONST
 # define REMOVE_CONST(...) LIBSIMPLE_REMOVE_CONST(__VA_ARGS__)
 #endif
 
 
 #define LIBSIMPLE_PREFETCH_RDONLY(ADDRESS, LOCALITY) /* void */ /* TODO test, doc, man */\
-	_LIBSIMPLE_GCC_ONLY(__builtin_prefetch(ADDRESS, 0, LOCALITY))
+	LIBSIMPLE_GCC_ONLY__(__builtin_prefetch(ADDRESS, 0, LOCALITY))
 #ifndef PREFETCH_RDONLY
 # define PREFETCH_RDONLY(...) LIBSIMPLE_PREFETCH_RDONLY(__VA_ARGS__)
 #endif
 
 
 #define LIBSIMPLE_PREFETCH_RDWR(ADDRESS, LOCALITY) /* void */ /* TODO test, doc, man */\
-	_LIBSIMPLE_GCC_ONLY(__builtin_prefetch(ADDRESS, 1, LOCALITY))
+	LIBSIMPLE_GCC_ONLY__(__builtin_prefetch(ADDRESS, 1, LOCALITY))
 #ifndef PREFETCH_RDWR
 # define PREFETCH_RDWR(...) LIBSIMPLE_PREFETCH_RDWR(__VA_ARGS__)
 #endif
 
 
-#define _LIBSIMPLE_ASSUME_ALIGNED(PTR, ALIGNMENT, ...)\
-	_LIBSIMPLE_GCC_ONLY(__builtin_assume_aligned(PTR, ALIGNMENT))
+#define LIBSIMPLE_ASSUME_ALIGNED__(PTR, ALIGNMENT, ...)\
+	LIBSIMPLE_GCC_ONLY__(__builtin_assume_aligned(PTR, ALIGNMENT))
 #if defined(__GNUC__) && !defined(__clang__)
 # define LIBSIMPLE_ASSUME_ALIGNED(PTR, ...) /* returns PTR */ /* TODO test, doc, man */\
-	_LIBSIMPLE_GCC_ONLY(__builtin_assume_aligned(PTR, ##__VA_ARGS__,\
-	                                             _LIBSIMPLE_C11_ONLY(_Alignof(PTR))\
+	LIBSIMPLE_GCC_ONLY__(__builtin_assume_aligned(PTR, ##__VA_ARGS__,\
+	                                             LIBSIMPLE_C11_ONLY__(_Alignof(PTR))\
 	                                             _LIBSIMPLE_PREC11_ONLY(__alignof(PTR))))
 #endif
 #ifndef ASSUME_ALIGNED
@@ -232,13 +237,13 @@ libsimple_unlist(void *__list, size_t __i, size_t *__np, size_t __width)
 #endif
 
 
-#define LIBSIMPLE_UNROLLED(N) _LIBSIMPLE_GCC_ONLY(_LIBSIMPLE_C11_ONLY(_Pragma("GCC unroll "#N))) /* TODO test, doc, man */
+#define LIBSIMPLE_UNROLLED(N) LIBSIMPLE_GCC_ONLY__(LIBSIMPLE_C11_ONLY__(_Pragma("GCC unroll "#N))) /* TODO test, doc, man */
 #ifndef UNROLLED
 # define UNROLLED(N) LIBSIMPLE_UNROLLED(N)
 #endif
 
 
-#define LIBSIMPLE_SIMDLOOP _LIBSIMPLE_GCC_ONLY(_LIBSIMPLE_C11_ONLY(_Pragma("GCC ivdep"))) /* TODO test, doc, man */
+#define LIBSIMPLE_SIMDLOOP LIBSIMPLE_GCC_ONLY__(LIBSIMPLE_C11_ONLY__(_Pragma("GCC ivdep"))) /* TODO test, doc, man */
 #ifndef SIMDLOOP
 # define SIMDLOOP LIBSIMPLE_SIMDLOOP
 #endif
diff --git a/libsimple/aligned_alloc.h b/libsimple/aligned_alloc.h
index b2a60f1..a4fe0fc 100644
--- a/libsimple/aligned_alloc.h
+++ b/libsimple/aligned_alloc.h
@@ -19,9 +19,12 @@
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
-static inline void *libsimple_valigned_allocn(size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_valigned_alloczn(0, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
+static inline void *
+libsimple_valigned_allocn(size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_valigned_alloczn(0, alignment__, n__, ap__);
+}
 #ifndef valigned_allocn
 # define valigned_allocn libsimple_valigned_allocn
 #endif
@@ -38,14 +41,14 @@ static inline void *libsimple_valigned_allocn(size_t __alignment, size_t __n, va
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_allocn(size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_aligned_allocn(size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_valigned_allocn(__alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_valigned_allocn(alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef aligned_allocn
 # define aligned_allocn libsimple_aligned_allocn
@@ -67,9 +70,12 @@ libsimple_aligned_allocn(size_t __alignment, size_t __n, ... /*, (size_t)0 */)
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_enaligned_alloc(int __status, size_t __alignment, size_t __n)
-{ return libsimple_enaligned_allocz(__status, 0, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_enaligned_alloc(int status__, size_t alignment__, size_t n__)
+{
+	return libsimple_enaligned_allocz(status__, 0, alignment__, n__);
+}
 #ifndef enaligned_alloc
 # define enaligned_alloc libsimple_enaligned_alloc
 #endif
@@ -96,9 +102,12 @@ static inline void *libsimple_enaligned_alloc(int __status, size_t __alignment,
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envaligned_allocn(int __status, size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envaligned_alloczn(__status, 0, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_envaligned_allocn(int status__, size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envaligned_alloczn(status__, 0, alignment__, n__, ap__);
+}
 #ifndef envaligned_allocn
 # define envaligned_allocn libsimple_envaligned_allocn
 #endif
@@ -125,14 +134,14 @@ static inline void *libsimple_envaligned_allocn(int __status, size_t __alignment
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enaligned_allocn(int __status, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_enaligned_allocn(int status__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envaligned_alloczn(__status, 0, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envaligned_alloczn(status__, 0, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enaligned_allocn
 # define enaligned_allocn libsimple_enaligned_allocn
@@ -153,9 +162,12 @@ libsimple_enaligned_allocn(int __status, size_t __alignment, size_t __n, ... /*,
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ealigned_alloc(size_t __alignment, size_t __n)
-{ return libsimple_enaligned_alloc(libsimple_default_failure_exit, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ealigned_alloc(size_t alignment__, size_t n__)
+{
+	return libsimple_enaligned_alloc(libsimple_default_failure_exit, alignment__, n__);
+}
 #ifndef ealigned_alloc
 # define ealigned_alloc libsimple_ealigned_alloc
 #endif
@@ -181,9 +193,12 @@ static inline void *libsimple_ealigned_alloc(size_t __alignment, size_t __n)
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evaligned_allocn(size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envaligned_allocn(libsimple_default_failure_exit, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evaligned_allocn(size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envaligned_allocn(libsimple_default_failure_exit, alignment__, n__, ap__);
+}
 #ifndef evaligned_allocn
 # define evaligned_allocn libsimple_evaligned_allocn
 #endif
@@ -209,14 +224,14 @@ static inline void *libsimple_evaligned_allocn(size_t __alignment, size_t __n, v
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_ealigned_allocn(size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_ealigned_allocn(size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evaligned_allocn(__alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evaligned_allocn(alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef ealigned_allocn
 # define ealigned_allocn libsimple_ealigned_allocn
diff --git a/libsimple/aligned_allocz.h b/libsimple/aligned_allocz.h
index 9380a50..7213c9b 100644
--- a/libsimple/aligned_allocz.h
+++ b/libsimple/aligned_allocz.h
@@ -20,7 +20,7 @@
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
 void *libsimple_valigned_alloczn(int, size_t, size_t, va_list);
 #ifndef valigned_alloczn
 # define valigned_alloczn libsimple_valigned_alloczn
@@ -40,14 +40,14 @@ void *libsimple_valigned_alloczn(int, size_t, size_t, va_list);
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_allocz(int __clear, size_t __alignment, size_t __n)
+libsimple_aligned_allocz(int clear__, size_t alignment__, size_t n__)
 {
-	void *__ret = aligned_alloc(__alignment, __n);
-	if (__ret && __clear)
-		memset(__ret, 0, __n);
-	return __ret;
+	void *ret__ = aligned_alloc(alignment__, n__);
+	if (ret__ && clear__)
+		memset(ret__, 0, n__);
+	return ret__;
 }
 #ifndef aligned_allocz
 # define aligned_allocz libsimple_aligned_allocz
@@ -73,14 +73,14 @@ libsimple_aligned_allocz(int __clear, size_t __alignment, size_t __n)
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_alloczn(int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_aligned_alloczn(int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_valigned_alloczn(__clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_valigned_alloczn(clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef aligned_alloczn
 # define aligned_alloczn libsimple_aligned_alloczn
@@ -103,7 +103,7 @@ libsimple_aligned_alloczn(int __clear, size_t __alignment, size_t __n, ... /*, (
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enaligned_allocz(int, int, size_t, size_t);
 #ifndef enaligned_allocz
 # define enaligned_allocz libsimple_enaligned_allocz
@@ -132,7 +132,7 @@ void *libsimple_enaligned_allocz(int, int, size_t, size_t);
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_envaligned_alloczn(int, int, size_t, size_t, va_list);
 #ifndef envaligned_alloczn
 # define envaligned_alloczn libsimple_envaligned_alloczn
@@ -161,14 +161,14 @@ void *libsimple_envaligned_alloczn(int, int, size_t, size_t, va_list);
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enaligned_alloczn(int __status, int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_enaligned_alloczn(int status__, int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envaligned_alloczn(__status, __clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envaligned_alloczn(status__, clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enaligned_alloczn
 # define enaligned_alloczn libsimple_enaligned_alloczn
@@ -189,9 +189,12 @@ libsimple_enaligned_alloczn(int __status, int __clear, size_t __alignment, size_
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ealigned_allocz(int __clear, size_t __alignment, size_t __n)
-{ return libsimple_enaligned_allocz(libsimple_default_failure_exit, __clear, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ealigned_allocz(int clear__, size_t alignment__, size_t n__)
+{
+	return libsimple_enaligned_allocz(libsimple_default_failure_exit, clear__, alignment__, n__);
+}
 #ifndef ealigned_allocz
 # define ealigned_allocz libsimple_ealigned_allocz
 #endif
@@ -218,9 +221,12 @@ static inline void *libsimple_ealigned_allocz(int __clear, size_t __alignment, s
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evaligned_alloczn(int __clear, size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envaligned_alloczn(libsimple_default_failure_exit, __clear, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evaligned_alloczn(int clear__, size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envaligned_alloczn(libsimple_default_failure_exit, clear__, alignment__, n__, ap__);
+}
 #ifndef evaligned_alloczn
 # define evaligned_alloczn libsimple_evaligned_alloczn
 #endif
@@ -247,14 +253,14 @@ static inline void *libsimple_evaligned_alloczn(int __clear, size_t __alignment,
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_ealigned_alloczn(int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_ealigned_alloczn(int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evaligned_alloczn(__clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evaligned_alloczn(clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef ealigned_alloczn
 # define ealigned_alloczn libsimple_ealigned_alloczn
diff --git a/libsimple/aligned_memdup.h b/libsimple/aligned_memdup.h
index 7c17375..d612be0 100644
--- a/libsimple/aligned_memdup.h
+++ b/libsimple/aligned_memdup.h
@@ -11,6 +11,7 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_aligned_memdupa(s, alignment, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
 		const char *__s = (s);\
 		size_t __n = (n);\
@@ -40,7 +41,7 @@
  * @param   n          The number of bytes to copy
  * @return             Duplicate of `s`, `NULL` on failure
  */	
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3), __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3), __nonnull__, __warn_unused_result__)))
 void *libsimple_aligned_memdup(const void *, size_t, size_t);
 #ifndef aligned_memdup
 # define aligned_memdup libsimple_aligned_memdup
@@ -56,7 +57,7 @@ void *libsimple_aligned_memdup(const void *, size_t, size_t);
  * @param   n          The number of bytes to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enaligned_memdup(int, const void *, size_t, size_t);
 #ifndef enaligned_memdup
 # define enaligned_memdup libsimple_enaligned_memdup
@@ -71,11 +72,11 @@ void *libsimple_enaligned_memdup(int, const void *, size_t, size_t);
  * @param   n          The number of bytes to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
 inline void *
-libsimple_ealigned_memdup(const void *__s, size_t __alignment, size_t __n)
+libsimple_ealigned_memdup(const void *s__, size_t alignment__, size_t n__)
 {
-	return libsimple_enaligned_memdup(libsimple_default_failure_exit, __s, __alignment, __n);
+	return libsimple_enaligned_memdup(libsimple_default_failure_exit, s__, alignment__, n__);
 }
 #ifndef ealigned_memdup
 # define ealigned_memdup libsimple_ealigned_memdup
diff --git a/libsimple/aligned_realloc.h b/libsimple/aligned_realloc.h
index 1da7ba7..bc66d84 100644
--- a/libsimple/aligned_realloc.h
+++ b/libsimple/aligned_realloc.h
@@ -27,33 +27,33 @@
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
 #if defined(__GLIBC__)
 # define LIBSIMPLE_HAVE_ALIGNED_REALLOC
 # include <malloc.h>
 static inline void *
-libsimple_aligned_realloc(void *__ptr, size_t __alignment, size_t __n) /* TODO musl */
+libsimple_aligned_realloc(void *ptr__, size_t alignment__, size_t n__) /* TODO musl */
 {
-	size_t __old = malloc_usable_size(__ptr);
+	size_t old__ = malloc_usable_size(ptr__);
 #if __STDC_VERSION__ >= 201112L || defined(_ISOC11_SOURCE)
-	size_t __extra = (__alignment - __n % __alignment) % __alignment;
-	void *__new = aligned_alloc(__alignment, __n + __extra);
+	size_t extra__ = (alignment__ - n__ % alignment__) % alignment__;
+	void *new__ = aligned_alloc(alignment__, n__ + extra__);
 #else
-	void *__new = memalign(__alignment, __n);
+	void *new__ = memalign(alignment__, n__);
 #endif
-	if (__new) {
-		memcpy(__new, __ptr, __old < __n ? __old : __n);
-		free(__ptr);
+	if (new__) {
+		memcpy(new__, ptr__, old__ < n__ ? old__ : n__);
+		free(ptr__);
 	}
-	return __new;
+	return new__;
 }
 #else
 static inline void *
-libsimple_aligned_realloc(void *__ptr, size_t __alignment, size_t __n)
+libsimple_aligned_realloc(void *ptr__, size_t alignment__, size_t n__)
 {
-	(void) __ptr;
-	(void) __alignment;
-	(void) __n;
+	(void) ptr__;
+	(void) alignment__;
+	(void) n__;
 	errno = ENOSYS;
 	return NULL;
 }
@@ -89,7 +89,7 @@ libsimple_aligned_realloc(void *__ptr, size_t __alignment, size_t __n)
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enaligned_realloc(int, void *, size_t, size_t);
 #ifndef enaligned_realloc
 # define enaligned_realloc libsimple_enaligned_realloc
@@ -121,9 +121,12 @@ void *libsimple_enaligned_realloc(int, void *, size_t, size_t);
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ealigned_realloc(void *__ptr, size_t __alignment, size_t __n)
-{ return libsimple_enaligned_realloc(libsimple_default_failure_exit, __ptr, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ealigned_realloc(void *ptr__, size_t alignment__, size_t n__)
+{
+	return libsimple_enaligned_realloc(libsimple_default_failure_exit, ptr__, alignment__, n__);
+}
 #ifndef ealigned_realloc
 # define ealigned_realloc libsimple_ealigned_realloc
 #endif
@@ -155,13 +158,13 @@ static inline void *libsimple_ealigned_realloc(void *__ptr, size_t __alignment,
  * @throws  EINVAL     `alignment` is not a valid alignment
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_reallocf(void *__ptr, size_t __alignment, size_t __n) /* TODO test */
+libsimple_aligned_reallocf(void *ptr__, size_t alignment__, size_t n__) /* TODO test */
 {
-	void *__new = __n ? libsimple_aligned_realloc(__ptr, __alignment, __n) : NULL;
-	if (!__new)
-		free(__ptr);
+	void *new__ = n__ ? libsimple_aligned_realloc(ptr__, alignment__, n__) : NULL;
+	if (!new__)
+		free(ptr__);
 	return NULL;
 }
 #ifndef aligned_reallocf
@@ -198,15 +201,15 @@ libsimple_aligned_reallocf(void *__ptr, size_t __alignment, size_t __n) /* TODO
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3, 4), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3, 4), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_reallocarray(void *__ptr, size_t __alignment, size_t __n, size_t __m)
+libsimple_aligned_reallocarray(void *ptr__, size_t alignment__, size_t n__, size_t m__)
 {
-	if (LIBSIMPLE_UMUL_OVERFLOW(__n, __m, &__n, SIZE_MAX)) {
+	if (LIBSIMPLE_UMUL_OVERFLOW(n__, m__, &n__, SIZE_MAX)) {
 		errno = ENOMEM;
 		return NULL;
 	}
-	return libsimple_aligned_realloc(__ptr, __alignment, __n);
+	return libsimple_aligned_realloc(ptr__, alignment__, n__);
 }
 #ifndef aligned_reallocarray
 # define aligned_reallocarray libsimple_aligned_reallocarray
@@ -242,7 +245,7 @@ libsimple_aligned_reallocarray(void *__ptr, size_t __alignment, size_t __n, size
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(3), __alloc_size__(4, 5), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(3), __alloc_size__(4, 5), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enaligned_reallocarray(int, void *, size_t, size_t, size_t);
 #ifndef enaligned_reallocarray
 # define enaligned_reallocarray libsimple_enaligned_reallocarray
@@ -278,9 +281,12 @@ void *libsimple_enaligned_reallocarray(int, void *, size_t, size_t, size_t);
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3, 4), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ealigned_reallocarray(void *__ptr, size_t __alignment, size_t __n, size_t __m)
-{ return libsimple_enaligned_reallocarray(libsimple_default_failure_exit, __ptr, __alignment, __n, __m); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3, 4), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ealigned_reallocarray(void *ptr__, size_t alignment__, size_t n__, size_t m__)
+{
+	return libsimple_enaligned_reallocarray(libsimple_default_failure_exit, ptr__, alignment__, n__, m__);
+}
 #ifndef ealigned_reallocarray
 # define ealigned_reallocarray libsimple_ealigned_reallocarray
 #endif
@@ -311,13 +317,13 @@ static inline void *libsimple_ealigned_reallocarray(void *__ptr, size_t __alignm
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __alloc_size__(3, 4), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __alloc_size__(3, 4), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_reallocarrayf(void *__ptr, size_t __alignment, size_t __n, size_t __m) /* TODO test */
+libsimple_aligned_reallocarrayf(void *ptr__, size_t alignment__, size_t n__, size_t m__) /* TODO test */
 {
-	void *__new = (__n && __m) ? libsimple_aligned_reallocarray(__ptr, __alignment, __n, __m) : NULL;
-	if (!__new)
-		free(__ptr);
+	void *new__ = (n__ && m__) ? libsimple_aligned_reallocarray(ptr__, alignment__, n__, m__) : NULL;
+	if (!new__)
+		free(ptr__);
 	return NULL;
 }
 #ifndef aligned_reallocarrayf
@@ -355,7 +361,7 @@ libsimple_aligned_reallocarrayf(void *__ptr, size_t __alignment, size_t __n, siz
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __warn_unused_result__)))
 void *libsimple_valigned_reallocn(void *, size_t, size_t, va_list);
 #ifndef valigned_reallocn
 # define valigned_reallocn libsimple_valigned_reallocn
@@ -393,7 +399,7 @@ void *libsimple_valigned_reallocn(void *, size_t, size_t, va_list);
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_envaligned_reallocn(int, void *, size_t, size_t, va_list);
 #ifndef envaligned_reallocn
 # define envaligned_reallocn libsimple_envaligned_reallocn
@@ -430,9 +436,12 @@ void *libsimple_envaligned_reallocn(int, void *, size_t, size_t, va_list);
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evaligned_reallocn(void *__ptr, size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envaligned_reallocn(libsimple_default_failure_exit, __ptr, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evaligned_reallocn(void *ptr__, size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envaligned_reallocn(libsimple_default_failure_exit, ptr__, alignment__, n__, ap__);
+}
 #ifndef evaligned_reallocn
 # define evaligned_reallocn libsimple_evaligned_reallocn
 #endif
@@ -464,14 +473,14 @@ static inline void *libsimple_evaligned_reallocn(void *__ptr, size_t __alignment
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __warn_unused_result__)))
 static inline void *
-libsimple_valigned_reallocfn(void *__ptr, size_t __alignment, size_t __n, va_list __ap) /* TODO test (aligned_reallocfn) */
+libsimple_valigned_reallocfn(void *ptr__, size_t alignment__, size_t n__, va_list ap__) /* TODO test (aligned_reallocfn) */
 {
-	void *__new = libsimple_valigned_reallocn(__ptr, __alignment, __n, __ap);
-	if (!__new)
-		free(__ptr);
-	return __new;
+	void *new__ = libsimple_valigned_reallocn(ptr__, alignment__, n__, ap__);
+	if (!new__)
+		free(ptr__);
+	return new__;
 }
 #ifndef valigned_reallocfn
 # define valigned_reallocfn libsimple_aligned_reallocnf
@@ -508,14 +517,14 @@ libsimple_valigned_reallocfn(void *__ptr, size_t __alignment, size_t __n, va_lis
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_reallocn(void *__ptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_aligned_reallocn(void *ptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_valigned_reallocn(__ptr, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_valigned_reallocn(ptr__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef aligned_reallocn
 # define aligned_reallocn libsimple_aligned_reallocn
@@ -553,14 +562,14 @@ libsimple_aligned_reallocn(void *__ptr, size_t __alignment, size_t __n, ... /*,
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enaligned_reallocn(int __status, void *__ptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_enaligned_reallocn(int status__, void *ptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envaligned_reallocn(__status, __ptr, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envaligned_reallocn(status__, ptr__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enaligned_reallocn
 # define enaligned_reallocn libsimple_enaligned_reallocn
@@ -597,14 +606,14 @@ libsimple_enaligned_reallocn(int __status, void *__ptr, size_t __alignment, size
  * @return             Either `ptr` or a unique pointer with at least
  *                     the specified size
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_ealigned_reallocn(void *__ptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_ealigned_reallocn(void *ptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evaligned_reallocn(__ptr, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evaligned_reallocn(ptr__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef ealigned_reallocn
 # define ealigned_reallocn libsimple_ealigned_reallocn
@@ -641,14 +650,14 @@ libsimple_ealigned_reallocn(void *__ptr, size_t __alignment, size_t __n, ... /*,
  * @throws  ENOMEM     Could not allocated enough memory
  * @throws  ENOSYS     Not implemented (requires non-standard libc functions)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_align__(2), __warn_unused_result__)))
 static inline void *
-libsimple_aligned_reallocfn(void *__ptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_aligned_reallocfn(void *ptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_valigned_reallocfn(__ptr, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_valigned_reallocfn(ptr__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef aligned_reallocfn
 # define aligned_reallocfn libsimple_aligned_reallocfn
diff --git a/libsimple/aligned_strdup.h b/libsimple/aligned_strdup.h
index 07b7edf..c7b713e 100644
--- a/libsimple/aligned_strdup.h
+++ b/libsimple/aligned_strdup.h
@@ -10,18 +10,19 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_aligned_strdupa(s, alignment)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__s = (s);\
-		size_t __n = strlen(__s) + 1;\
-		size_t __a = (alignment);\
-		uintptr_t __misalignment;\
-		char *__r;\
-		__a += !__a;\
-		__r = alloca(__n + (__a - 1));\
-		__misalignment = (uintptr_t)__r % (uintptr_t)__a;\
-		if (__misalignment)\
-			__r += (uintptr_t)__a - __misalignment;\
-		memcpy(__r, __s, __n);\
+		const char *s__ = (s);\
+		size_t n__ = strlen(s__) + 1;\
+		size_t a__ = (alignment);\
+		uintptr_t misalignment__;\
+		char *r__;\
+		a__ += !a__;\
+		r__ = alloca(n__ + (a__ - 1));\
+		misalignment__ = (uintptr_t)r__ % (uintptr_t)a__;\
+		if (misalignment__)\
+			r__ += (uintptr_t)a__ - misalignment__;\
+		memcpy(r__, s__, n__);\
 	})
 # ifndef aligned_strdupa
 #  define aligned_strdupa(s, alignment) libsimple_aligned_strdupa(s, alignment)
@@ -36,9 +37,12 @@
  * @param   alignment  The alignment of the returned pointer
  * @return             Duplicate of `s`, `NULL` on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
-static inline char *libsimple_aligned_strdup(const char * __s, size_t __alignment)
-{ return libsimple_aligned_memdup(__s, __alignment, strlen(__s) + 1); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
+inline char *
+libsimple_aligned_strdup(const char *s__, size_t alignment__)
+{
+	return libsimple_aligned_memdup(s__, alignment__, strlen(s__) + 1);
+}
 #ifndef aligned_strdup
 # define aligned_strdup libsimple_aligned_strdup
 #endif
@@ -52,7 +56,7 @@ static inline char *libsimple_aligned_strdup(const char * __s, size_t __alignmen
  * @param   alignment  The alignment of the returned pointer
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 char *libsimple_enaligned_strdup(int, const char *, size_t);
 #ifndef enaligned_strdup
 # define enaligned_strdup libsimple_enaligned_strdup
@@ -66,9 +70,12 @@ char *libsimple_enaligned_strdup(int, const char *, size_t);
  * @param   alignment  The alignment of the returned pointer
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
-static inline char *libsimple_ealigned_strdup(const char *__s, size_t __alignment)
-{ return libsimple_enaligned_strdup(libsimple_default_failure_exit, __s, __alignment); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+inline char *
+libsimple_ealigned_strdup(const char *s__, size_t alignment__)
+{
+	return libsimple_enaligned_strdup(libsimple_default_failure_exit, s__, alignment__);
+}
 #ifndef ealigned_strdup
 # define ealigned_strdup libsimple_ealigned_strdup
 #endif
diff --git a/libsimple/aligned_strndup.h b/libsimple/aligned_strndup.h
index 68b9d00..201afef 100644
--- a/libsimple/aligned_strndup.h
+++ b/libsimple/aligned_strndup.h
@@ -11,20 +11,21 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_aligned_strndupa(s, alignment, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__s = (s);\
-		size_t __n = strnlen(__s, n);\
-		size_t __a = (alignment);\
-		uintptr_t __misalignment;\
-		char *__r;\
-		__a += !__a;\
-		__r = alloca(__n + 1 + (__a - 1));\
-		__misalignment = (uintptr_t)__r % (uintptr_t)__a;\
-		if (__misalignment)\
-			__r += (uintptr_t)__a - __misalignment;\
-		memcpy(__r, __s, __n);\
-		__r[__n] = '\0';\
-		__r;\
+		const char *s__ = (s);\
+		size_t n__ = strnlen(s__, n);\
+		size_t a__ = (alignment);\
+		uintptr_t misalignment__;\
+		char *r__;\
+		a__ += !a__;\
+		r__ = alloca(n__ + 1 + (a__ - 1));\
+		misalignment__ = (uintptr_t)r__ % (uintptr_t)a__;\
+		if (misalignment__)\
+			r__ += (uintptr_t)a__ - misalignment__;\
+		memcpy(r__, s__, n__);\
+		r__[n__] = '\0';\
+		r__;\
 	})
 # ifndef aligned_strndupa
 #  define aligned_strndupa(s, alignment, n) libsimple_aligned_strndupa(s, alignment, n)
@@ -40,8 +41,8 @@
  * @param   n          The maximum number of bytes to copy
  * @return             Duplicate of `s`, `NULL` on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
-char *libsimple_aligned_strndup(const char * __s, size_t __alignment, size_t __n);
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
+char *libsimple_aligned_strndup(const char * s__, size_t alignment__, size_t n__);
 #ifndef aligned_strndup
 # define aligned_strndup libsimple_aligned_strndup
 #endif
@@ -56,7 +57,7 @@ char *libsimple_aligned_strndup(const char * __s, size_t __alignment, size_t __n
  * @param   n          The maximum number of bytes to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 char *libsimple_enaligned_strndup(int, const char *, size_t, size_t);
 #ifndef enaligned_strndup
 # define enaligned_strndup libsimple_enaligned_strndup
@@ -71,11 +72,11 @@ char *libsimple_enaligned_strndup(int, const char *, size_t, size_t);
  * @param   n          The maximum number of bytes to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline char *
-libsimple_ealigned_strndup(const char *__s, size_t __alignment, size_t __n)
+libsimple_ealigned_strndup(const char *s__, size_t alignment__, size_t n__)
 {
-	return libsimple_enaligned_strndup(libsimple_default_failure_exit, __s, __alignment, __n);
+	return libsimple_enaligned_strndup(libsimple_default_failure_exit, s__, alignment__, n__);
 }
 #ifndef ealigned_strndup
 # define ealigned_strndup libsimple_ealigned_strndup
diff --git a/libsimple/aligned_wcsdup.h b/libsimple/aligned_wcsdup.h
index 527d210..c9fc0cf 100644
--- a/libsimple/aligned_wcsdup.h
+++ b/libsimple/aligned_wcsdup.h
@@ -10,18 +10,19 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_aligned_wcsdupa(s, alignment)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const wchar_t *__s = (s);\
-		size_t __n = wcslen(__s) + 1;\
-		size_t __a = (alignment);\
-		uintptr_t __misalignment;\
-		wchar_t *__r;\
-		__a += !__a;\
-		__r = alloca(__n * sizeof(wchar_t) + (__a - 1));\
-		__misalignment = (uintptr_t)__r % (uintptr_t)__a;\
-		if (__misalignment)\
-			__r += (uintptr_t)__a - __misalignment;\
-		wmemcpy(__r, __s, __n);\
+		const wchar_t *s__ = (s);\
+		size_t n__ = wcslen(s__) + 1;\
+		size_t a__ = (alignment);\
+		uintptr_t misalignment__;\
+		wchar_t *r__;\
+		a__ += !a__;\
+		r__ = alloca(n__ * sizeof(wchar_t) + (a__ - 1));\
+		misalignment__ = (uintptr_t)r__ % (uintptr_t)a__;\
+		if (misalignment__)\
+			r__ += (uintptr_t)a__ - misalignment__;\
+		wmemcpy(r__, s__, n__);\
 	})
 # ifndef aligned_wcsdupa
 #  define aligned_wcsdupa(s, alignment) libsimple_aligned_wcsdupa(s, alignment)
@@ -36,9 +37,12 @@
  * @param   alignment  The alignment of the returned pointer
  * @return             Duplicate of `s`, `NULL` on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
-static inline wchar_t *libsimple_aligned_wcsdup(const wchar_t * __s, size_t __alignment)
-{ return libsimple_aligned_wmemdup(__s, __alignment, wcslen(__s) + 1); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
+inline wchar_t *
+libsimple_aligned_wcsdup(const wchar_t *s__, size_t alignment__)
+{
+	return libsimple_aligned_wmemdup(s__, alignment__, wcslen(s__) + 1);
+}
 #ifndef aligned_wcsdup
 # define aligned_wcsdup libsimple_aligned_wcsdup
 #endif
@@ -52,7 +56,7 @@ static inline wchar_t *libsimple_aligned_wcsdup(const wchar_t * __s, size_t __al
  * @param   alignment  The alignment of the returned pointer
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 wchar_t *libsimple_enaligned_wcsdup(int, const wchar_t *, size_t);
 #ifndef enaligned_wcsdup
 # define enaligned_wcsdup libsimple_enaligned_wcsdup
@@ -66,9 +70,12 @@ wchar_t *libsimple_enaligned_wcsdup(int, const wchar_t *, size_t);
  * @param   alignment  The alignment of the returned pointer
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
-static inline wchar_t *libsimple_ealigned_wcsdup(const wchar_t *__s, size_t __alignment)
-{ return libsimple_enaligned_wcsdup(libsimple_default_failure_exit, __s, __alignment); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+inline wchar_t *
+libsimple_ealigned_wcsdup(const wchar_t *s__, size_t alignment__)
+{
+	return libsimple_enaligned_wcsdup(libsimple_default_failure_exit, s__, alignment__);
+}
 #ifndef ealigned_wcsdup
 # define ealigned_wcsdup libsimple_ealigned_wcsdup
 #endif
diff --git a/libsimple/aligned_wcsndup.h b/libsimple/aligned_wcsndup.h
index 4e081ee..cd06ff8 100644
--- a/libsimple/aligned_wcsndup.h
+++ b/libsimple/aligned_wcsndup.h
@@ -11,20 +11,21 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_aligned_wcsndupa(s, alignment, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const wchar_t *__s = (s);\
-		size_t __n = wcsnlen(__s, n);\
-		size_t __a = (alignment);\
-		uintptr_t __misalignment;\
-		wchar_t *__r;\
-		__a += !__a;\
-		__r = alloca((__n + 1) * sizeof(wchar_t) + (__a - 1));\
-		__misalignment = (uintptr_t)__r % (uintptr_t)__a;\
-		if (__misalignment)\
-			__r += (uintptr_t)__a - __misalignment;\
-		wmemcpy(__r, __s, __n);\
-		__r[__n] = 0;\
-		__r;\
+		const wchar_t *s__ = (s);\
+		size_t n__ = wcsnlen(s__, n);\
+		size_t a__ = (alignment);\
+		uintptr_t misalignment__;\
+		wchar_t *r__;\
+		a__ += !a__;\
+		r__ = alloca((n__ + 1) * sizeof(wchar_t) + (a__ - 1));\
+		misalignment__ = (uintptr_t)r__ % (uintptr_t)a__;\
+		if (misalignment__)\
+			r__ += (uintptr_t)a__ - misalignment__;\
+		wmemcpy(r__, s__, n__);\
+		r__[n__] = 0;\
+		r__;\
 	})
 # ifndef aligned_wcsndupa
 #  define aligned_wcsndupa(s, alignment, n) libsimple_aligned_wcsndupa(s, alignment, n)
@@ -40,8 +41,8 @@
  * @param   n          The maximum number of wide characters to copy
  * @return             Duplicate of `s`, `NULL` on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
-wchar_t *libsimple_aligned_wcsndup(const wchar_t * __s, size_t __alignment, size_t __n);
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__)))
+wchar_t *libsimple_aligned_wcsndup(const wchar_t * s__, size_t alignment__, size_t n__);
 #ifndef aligned_wcsndup
 # define aligned_wcsndup libsimple_aligned_wcsndup
 #endif
@@ -56,7 +57,7 @@ wchar_t *libsimple_aligned_wcsndup(const wchar_t * __s, size_t __alignment, size
  * @param   n          The maximum number of wide characters to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 wchar_t *libsimple_enaligned_wcsndup(int, const wchar_t *, size_t, size_t);
 #ifndef enaligned_wcsndup
 # define enaligned_wcsndup libsimple_enaligned_wcsndup
@@ -71,11 +72,11 @@ wchar_t *libsimple_enaligned_wcsndup(int, const wchar_t *, size_t, size_t);
  * @param   n          The maximum number of wide characters to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline wchar_t *
-libsimple_ealigned_wcsndup(const wchar_t *__s, size_t __alignment, size_t __n)
+libsimple_ealigned_wcsndup(const wchar_t *s__, size_t alignment__, size_t n__)
 {
-	return libsimple_enaligned_wcsndup(libsimple_default_failure_exit, __s, __alignment, __n);
+	return libsimple_enaligned_wcsndup(libsimple_default_failure_exit, s__, alignment__, n__);
 }
 #ifndef ealigned_wcsndup
 # define ealigned_wcsndup libsimple_ealigned_wcsndup
diff --git a/libsimple/aligned_wmemdup.h b/libsimple/aligned_wmemdup.h
index 79b59dd..56148d8 100644
--- a/libsimple/aligned_wmemdup.h
+++ b/libsimple/aligned_wmemdup.h
@@ -11,20 +11,21 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_aligned_wmemdupa(s, alignment, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const wchar_t *__s = (s);\
-		size_t __n = (n);\
-		size_t __a = (alignment);\
-		size_t __size;\
-		uintptr_t __misalignment;\
-		wchar_t *__r;\
-		__a += !__a;\
-		__size = __n * sizeof(wchar_t) + (__a - 1);\
-		__r = alloca(__size + !__size);\
-		__misalignment = (uintptr_t)__r % (uintptr_t)__a;\
-		if (__misalignment)\
-			__r += (uintptr_t)__a - __misalignment;\
-		wmemcpy(__r, __s, __n);\
+		const wchar_t *s__ = (s);\
+		size_t n__ = (n);\
+		size_t a__ = (alignment);\
+		size_t size__;\
+		uintptr_t misalignment__;\
+		wchar_t *r__;\
+		a__ += !a__;\
+		size__ = n__ * sizeof(wchar_t) + (a__ - 1);\
+		r__ = alloca(size__ + !size__);\
+		misalignment__ = (uintptr_t)r__ % (uintptr_t)a__;\
+		if (misalignment__)\
+			r__ += (uintptr_t)a__ - misalignment__;\
+		wmemcpy(r__, s__, n__);\
 	})
 # ifndef aligned_wmemdupa
 #  define aligned_wmemdupa(s, alignment, n) libsimple_aligned_wmemdupa(s, alignment, n)
@@ -40,7 +41,7 @@
  * @param   n          The number of wide characters to copy
  * @return             Duplicate of `s`, `NULL` on failure
  */	
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __nonnull__, __warn_unused_result__)))
 wchar_t *libsimple_aligned_wmemdup(const wchar_t *, size_t, size_t);
 #ifndef aligned_wmemdup
 # define aligned_wmemdup libsimple_aligned_wmemdup
@@ -56,7 +57,7 @@ wchar_t *libsimple_aligned_wmemdup(const wchar_t *, size_t, size_t);
  * @param   n          The number of wide characters to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
 wchar_t *libsimple_enaligned_wmemdup(int, const wchar_t *, size_t, size_t);
 #ifndef enaligned_wmemdup
 # define enaligned_wmemdup libsimple_enaligned_wmemdup
@@ -71,11 +72,11 @@ wchar_t *libsimple_enaligned_wmemdup(int, const wchar_t *, size_t, size_t);
  * @param   n          The number of wide characters to copy
  * @return             Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
 inline wchar_t *
-libsimple_ealigned_wmemdup(const wchar_t *__s, size_t __alignment, size_t __n)
+libsimple_ealigned_wmemdup(const wchar_t *s__, size_t alignment__, size_t n__)
 {
-	return libsimple_enaligned_wmemdup(libsimple_default_failure_exit, __s, __alignment, __n);
+	return libsimple_enaligned_wmemdup(libsimple_default_failure_exit, s__, alignment__, n__);
 }
 #ifndef ealigned_wmemdup
 # define ealigned_wmemdup libsimple_ealigned_wmemdup
diff --git a/libsimple/calloc.h b/libsimple/calloc.h
index 7b373e9..28f284d 100644
--- a/libsimple/calloc.h
+++ b/libsimple/calloc.h
@@ -18,9 +18,12 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *libsimple_vcallocn(size_t __n, va_list __ap)
-{ return libsimple_vmalloczn(1, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+static inline void *
+libsimple_vcallocn(size_t n__, va_list ap__)
+{
+	return libsimple_vmalloczn(1, n__, ap__);
+}
 #ifndef vcallocn
 # define vcallocn libsimple_vcallocn
 #endif
@@ -43,14 +46,14 @@ static inline void *libsimple_vcallocn(size_t __n, va_list __ap)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 static inline void *
-libsimple_callocn(size_t __n, ... /*, (size_t)0 */)
+libsimple_callocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vmalloczn(1, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vmalloczn(1, n__, ap__);
+	va_end(ap__);
 }
 #ifndef callocn
 # define callocn libsimple_callocn
@@ -73,8 +76,11 @@ libsimple_callocn(size_t __n, ... /*, (size_t)0 */)
  * @return          A unique pointer with at least the size `n * m`
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__)))
+#ifndef LIBSIMPLE_DEFINED_LIBSIMPLE_ENCALLOC__
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_encalloc(int, size_t, size_t);
+# define LIBSIMPLE_DEFINED_LIBSIMPLE_ENCALLOC__
+#endif
 #ifndef encalloc
 # define encalloc libsimple_encalloc
 #endif
@@ -99,9 +105,12 @@ void *libsimple_encalloc(int, size_t, size_t);
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envcallocn(int __status, size_t __n, va_list __ap)
-{ return libsimple_envmalloczn(__status, 1, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_envcallocn(int status__, size_t n__, va_list ap__)
+{
+	return libsimple_envmalloczn(status__, 1, n__, ap__);
+}
 #ifndef envcallocn
 # define envcallocn libsimple_envcallocn
 #endif
@@ -126,14 +135,14 @@ static inline void *libsimple_envcallocn(int __status, size_t __n, va_list __ap)
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_encallocn(int __status, size_t __n, ... /*, (size_t)0 */)
+libsimple_encallocn(int status__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envcallocn(__status, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envcallocn(status__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef encallocn
 # define encallocn libsimple_encallocn
@@ -155,9 +164,12 @@ libsimple_encallocn(int __status, size_t __n, ... /*, (size_t)0 */)
  * @return     A unique pointer with at least the size `n * m`
  *             and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(1, 2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ecalloc(size_t __n, size_t __m)
-{ return encalloc(libsimple_default_failure_exit, __n, __m); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(1, 2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ecalloc(size_t n__, size_t m__)
+{
+	return encalloc(libsimple_default_failure_exit, n__, m__);
+}
 #ifndef ecalloc
 # define ecalloc libsimple_ecalloc
 #endif
@@ -181,9 +193,12 @@ static inline void *libsimple_ecalloc(size_t __n, size_t __m)
  * @return      A unique pointer with at least the specified size
  *              and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evcallocn(size_t __n, va_list __ap)
-{ return libsimple_envcallocn(libsimple_default_failure_exit, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evcallocn(size_t n__, va_list ap__)
+{
+	return libsimple_envcallocn(libsimple_default_failure_exit, n__, ap__);
+}
 #ifndef evcallocn
 # define evcallocn libsimple_evcallocn
 #endif
@@ -207,14 +222,14 @@ static inline void *libsimple_evcallocn(size_t __n, va_list __ap)
  * @return       A unique pointer with at least the specified size
  *               and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_ecallocn(size_t __n, ... /*, (size_t)0 */)
+libsimple_ecallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evcallocn(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evcallocn(n__, ap__);
+	va_end(ap__);
 }
 #ifndef ecallocn
 # define ecallocn libsimple_ecallocn
diff --git a/libsimple/env.h b/libsimple/env.h
index f9139c7..530b21e 100644
--- a/libsimple/env.h
+++ b/libsimple/env.h
@@ -7,12 +7,12 @@
  * @param   var  The environment variable's name
  * @return       The environment variable's value, `NULL` if empty or not defined
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __warn_unused_result__)))
 inline char *
-libsimple_getenv_ne(const char *__name)
+libsimple_getenv_ne(const char *name__)
 {
-	char *__env = getenv(__name);
-	return (__env && *__env) ? __env : NULL;
+	char *env__ = getenv(name__);
+	return (env__ && *env__) ? env__ : NULL;
 }
 #ifndef getenv_ne
 # define getenv_ne libsimple_getenv_ne
@@ -25,12 +25,12 @@ libsimple_getenv_ne(const char *__name)
  * @param   var  The environment variable's name
  * @return       The environment variable's value, "" if empty or not defined
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline const char *
-libsimple_getenv_e(const char *__name)
+libsimple_getenv_e(const char *name__)
 {
-	const char *__env = getenv(__name);
-	return (__env && *__env) ? __env : "";
+	const char *env__ = getenv(name__);
+	return (env__ && *env__) ? env__ : "";
 }
 #ifndef getenv_e
 # define getenv_e libsimple_getenv_e
@@ -50,7 +50,7 @@ libsimple_getenv_e(const char *__name)
  * @param   ap   Format arguments, see vsprintf(3)
  * @return       0 on success, -1 on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_vputenvf(const char *, va_list);
 #ifndef vputenvf
 # define vputenvf libsimple_vputenvf
@@ -70,14 +70,14 @@ int libsimple_vputenvf(const char *, va_list);
  * @param   ...  Format arguments, see vsprintf(3)
  * @return       0 on success, -1 on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __format__(__printf__, 1, 2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __format__(__printf__, 1, 2))))
 inline int
-libsimple_putenvf(const char *__fmt, ...)
+libsimple_putenvf(const char *fmt__, ...)
 {
-	va_list __ap;
-	va_start(__ap, __fmt);
-	return libsimple_vputenvf(__fmt, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, fmt__);
+	return libsimple_vputenvf(fmt__, ap__);
+	va_end(ap__);
 }
 #ifndef putenvf
 # define putenvf libsimple_putenvf
@@ -101,7 +101,7 @@ libsimple_putenvf(const char *__fmt, ...)
  * @param  fmt     Format string, see vsprintf(3)
  * @param  ap      Format arguments, see vsprintf(3)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 void libsimple_envputenvf(int, const char *, va_list);
 #ifndef envputenvf
 # define envputenvf libsimple_envputenvf
@@ -125,14 +125,14 @@ void libsimple_envputenvf(int, const char *, va_list);
  * @param  fmt     Format string, see vsprintf(3)
  * @param  ap      Format arguments, see vsprintf(3)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __format__(__printf__, 2, 3))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __format__(__printf__, 2, 3))))
 inline void
-libsimple_enputenvf(int __status, const char *__fmt, ...)
+libsimple_enputenvf(int status__, const char *fmt__, ...)
 {
-	va_list __ap;
-	va_start(__ap, __fmt);
-	libsimple_envputenvf(__status, __fmt, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, fmt__);
+	libsimple_envputenvf(status__, fmt__, ap__);
+	va_end(ap__);
 }
 #ifndef enputenvf
 # define enputenvf libsimple_enputenvf
@@ -155,11 +155,11 @@ libsimple_enputenvf(int __status, const char *__fmt, ...)
  * @param  fmt  Format string, see vsprintf(3)
  * @param  ap   Format arguments, see vsprintf(3)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 inline void
-libsimple_evputenvf(const char *__fmt, va_list __ap)
+libsimple_evputenvf(const char *fmt__, va_list ap__)
 {
-	libsimple_envputenvf(libsimple_default_failure_exit, __fmt, __ap);
+	libsimple_envputenvf(libsimple_default_failure_exit, fmt__, ap__);
 }
 #ifndef evputenvf
 # define evputenvf libsimple_evputenvf
@@ -182,14 +182,14 @@ libsimple_evputenvf(const char *__fmt, va_list __ap)
  * @param  fmt  Format string, see vsprintf(3)
  * @param  ap   Format arguments, see vsprintf(3)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __format__(__printf__, 1, 2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __format__(__printf__, 1, 2))))
 inline void
-libsimple_eputenvf(const char *__fmt, ...)
+libsimple_eputenvf(const char *fmt__, ...)
 {
-	va_list __ap;
-	va_start(__ap, __fmt);
-	libsimple_evputenvf(__fmt, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, fmt__);
+	libsimple_evputenvf(fmt__, ap__);
+	va_end(ap__);
 }
 #ifndef eputenvf
 # define eputenvf libsimple_eputenvf
diff --git a/libsimple/malloc.h b/libsimple/malloc.h
index b57f81f..ca057da 100644
--- a/libsimple/malloc.h
+++ b/libsimple/malloc.h
@@ -18,9 +18,12 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *libsimple_vmallocn(size_t __n, va_list __ap)
-{ return libsimple_vmalloczn(0, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+static inline void *
+libsimple_vmallocn(size_t n__, va_list ap__)
+{
+	return libsimple_vmalloczn(0, n__, ap__);
+}
 #ifndef vmallocn
 # define vmallocn libsimple_vmallocn
 #endif
@@ -43,14 +46,14 @@ static inline void *libsimple_vmallocn(size_t __n, va_list __ap)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 static inline void *
-libsimple_mallocn(size_t __n, ... /*, (size_t)0 */)
+libsimple_mallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vmalloczn(0, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vmalloczn(0, n__, ap__);
+	va_end(ap__);
 }
 #ifndef mallocn
 # define mallocn libsimple_mallocn
@@ -71,8 +74,11 @@ libsimple_mallocn(size_t __n, ... /*, (size_t)0 */)
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+#ifndef LIBSIMPLE_DEFINED_LIBSIMPLE_ENMALLOC__
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enmalloc(int, size_t);
+# define LIBSIMPLE_DEFINED_LIBSIMPLE_ENMALLOC__
+#endif
 #ifndef enmalloc
 # define enmalloc libsimple_enmalloc
 #endif
@@ -97,9 +103,12 @@ void *libsimple_enmalloc(int, size_t);
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envmallocn(int __status, size_t __n, va_list __ap)
-{ return libsimple_envmalloczn(__status, 0, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_envmallocn(int status__, size_t n__, va_list ap__)
+{
+	return libsimple_envmalloczn(status__, 0, n__, ap__);
+}
 #ifndef envmallocn
 # define envmallocn libsimple_envmallocn
 #endif
@@ -124,14 +133,14 @@ static inline void *libsimple_envmallocn(int __status, size_t __n, va_list __ap)
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enmallocn(int __status, size_t __n, ... /*, (size_t)0 */)
+libsimple_enmallocn(int status__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envmallocn(__status, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envmallocn(status__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enmallocn
 # define enmallocn libsimple_enmallocn
@@ -151,9 +160,12 @@ libsimple_enmallocn(int __status, size_t __n, ... /*, (size_t)0 */)
  * @return     A unique pointer with at least the specified size
  *             and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_emalloc(size_t __n)
-{ return libsimple_enmalloc(libsimple_default_failure_exit, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_emalloc(size_t n__)
+{
+	return libsimple_enmalloc(libsimple_default_failure_exit, n__);
+}
 #ifndef emalloc
 # define emalloc libsimple_emalloc
 #endif
@@ -177,9 +189,12 @@ static inline void *libsimple_emalloc(size_t __n)
  * @return      A unique pointer with at least the specified size
  *              and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evmallocn(size_t __n, va_list __ap)
-{ return libsimple_envmallocn(libsimple_default_failure_exit, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evmallocn(size_t n__, va_list ap__)
+{
+	return libsimple_envmallocn(libsimple_default_failure_exit, n__, ap__);
+}
 #ifndef evmallocn
 # define evmallocn libsimple_evmallocn
 #endif
@@ -203,14 +218,14 @@ static inline void *libsimple_evmallocn(size_t __n, va_list __ap)
  * @return       A unique pointer with at least the specified size
  *               and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_emallocn(size_t __n, ... /*, (size_t)0 */)
+libsimple_emallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evmallocn(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evmallocn(n__, ap__);
+	va_end(ap__);
 }
 #ifndef emallocn
 # define emallocn libsimple_emallocn
diff --git a/libsimple/mallocz.h b/libsimple/mallocz.h
index 2bbd607..7bd9999 100644
--- a/libsimple/mallocz.h
+++ b/libsimple/mallocz.h
@@ -3,11 +3,17 @@
 
 /* Properly declared elsewhere { */
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__)))
+#ifndef LIBSIMPLE_DEFINED_LIBSIMPLE_ENCALLOC__
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_encalloc(int, size_t, size_t);
+# define LIBSIMPLE_DEFINED_LIBSIMPLE_ENCALLOC__
+#endif
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+#ifndef LIBSIMPLE_DEFINED_LIBSIMPLE_ENMALLOC__
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enmalloc(int, size_t);
+# define LIBSIMPLE_DEFINED_LIBSIMPLE_ENMALLOC__
+#endif
 
 /* } */
 
@@ -30,7 +36,7 @@ void *libsimple_enmalloc(int, size_t);
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 void *libsimple_vmalloczn(int, size_t, va_list);
 #ifndef vmalloczn
 # define vmalloczn libsimple_vmalloczn
@@ -49,9 +55,12 @@ void *libsimple_vmalloczn(int, size_t, va_list);
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__)))
-static inline void *libsimple_mallocz(int __clear, size_t __n)
-{ return __clear ? calloc(1, __n) : malloc(__n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__)))
+static inline void *
+libsimple_mallocz(int clear__, size_t n__)
+{
+	return clear__ ? calloc(1, n__) : malloc(n__);
+}
 #ifndef mallocz
 # define mallocz libsimple_mallocz
 #endif
@@ -75,14 +84,14 @@ static inline void *libsimple_mallocz(int __clear, size_t __n)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 static inline void *
-libsimple_malloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
+libsimple_malloczn(int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vmalloczn(__clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vmalloczn(clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef malloczn
 # define malloczn libsimple_malloczn
@@ -103,9 +112,12 @@ libsimple_malloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_enmallocz(int __status, int __clear, size_t __n)
-{ return __clear ? libsimple_encalloc(__status, 1, __n) : libsimple_enmalloc(__status, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_enmallocz(int status__, int clear__, size_t n__)
+{
+	return clear__ ? libsimple_encalloc(status__, 1, n__) : libsimple_enmalloc(status__, n__);
+}
 #ifndef enmallocz
 # define enmallocz libsimple_enmallocz
 #endif
@@ -132,7 +144,7 @@ static inline void *libsimple_enmallocz(int __status, int __clear, size_t __n)
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_envmalloczn(int, int, size_t, va_list);
 #ifndef envmalloczn
 # define envmalloczn libsimple_envmalloczn
@@ -160,14 +172,14 @@ void *libsimple_envmalloczn(int, int, size_t, va_list);
  * @return          A unique pointer with at least the specified size
  *                  and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enmalloczn(int __status, int __clear, size_t __n, ... /*, (size_t)0 */)
+libsimple_enmalloczn(int status__, int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envmalloczn(__status, __clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envmalloczn(status__, clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enmalloczn
 # define enmalloczn libsimple_enmalloczn
@@ -187,9 +199,12 @@ libsimple_enmalloczn(int __status, int __clear, size_t __n, ... /*, (size_t)0 */
  * @return         A unique pointer with at least the specified size
  *                 and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_emallocz(int __clear, size_t __n)
-{ return libsimple_enmallocz(libsimple_default_failure_exit, __clear, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_emallocz(int clear__, size_t n__)
+{
+	return libsimple_enmallocz(libsimple_default_failure_exit, clear__, n__);
+}
 #ifndef emallocz
 # define emallocz libsimple_emallocz
 #endif
@@ -214,9 +229,12 @@ static inline void *libsimple_emallocz(int __clear, size_t __n)
  * @return         A unique pointer with at least the specified size
  *                 and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __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__((__malloc__, __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__);
+}
 #ifndef evmalloczn
 # define evmalloczn libsimple_evmalloczn
 #endif
@@ -241,14 +259,14 @@ static inline void *libsimple_evmalloczn(int __clear, size_t __n, va_list __ap)
  * @return         A unique pointer with at least the specified size
  *                 and with the alignment `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_emalloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
+libsimple_emalloczn(int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evmalloczn(__clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evmalloczn(clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef emalloczn
 # define emalloczn libsimple_emalloczn
diff --git a/libsimple/mem.h b/libsimple/mem.h
index f4c01dc..a7cf038 100644
--- a/libsimple/mem.h
+++ b/libsimple/mem.h
@@ -12,7 +12,7 @@
  *             where `r` is the returned pointer, `&s[n]` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_memscan(const void *, int, size_t);
 #ifndef memscan
 # define memscan libsimple_memscan
@@ -30,7 +30,7 @@ void *libsimple_memscan(const void *, int, size_t);
  *             where `r` is the returned pointer, `NULL` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memcasechr(const void *, int, size_t);
 #ifndef memcasechr
 # define memcasechr libsimple_memcasechr
@@ -48,7 +48,7 @@ void *libsimple_memcasechr(const void *, int, size_t);
  *             where `r` is the returned pointer, `&s[n]` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_memcasescan(const void *, int, size_t);
 #ifndef memcasescan
 # define memcasescan libsimple_memcasescan
@@ -69,7 +69,7 @@ void *libsimple_memcasescan(const void *, int, size_t);
  * @return     `s` with a miminal offset such that `*r == c`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemchr(const void *, int);
 #ifndef rawmemchr
 # define rawmemchr libsimple_rawmemchr
@@ -90,7 +90,7 @@ void *libsimple_rawmemchr(const void *, int);
  * @return     `s` with a miminal offset such that `tolower(*r) == tolower(c)`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemcasechr(const void *, int);
 #ifndef rawmemcasechr
 # define rawmemcasechr libsimple_rawmemcasechr
@@ -108,7 +108,7 @@ void *libsimple_rawmemcasechr(const void *, int);
  *             where `r` is the returned pointer `NULL` if no
  *             such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrchr(const void *, int, size_t);
 #ifndef memrchr
 # define memrchr libsimple_memrchr
@@ -126,7 +126,7 @@ void *libsimple_memrchr(const void *, int, size_t);
  *             where `r` is the returned pointer `NULL` if no
  *             such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrcasechr(const void *, int, size_t);
 #ifndef memrcasechr
 # define memrcasechr libsimple_memrcasechr
@@ -148,7 +148,7 @@ void *libsimple_memrcasechr(const void *, int, size_t);
  * @return     `s` with a maximal offset such that `*r == c`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemrchr(const void *, int, size_t);
 #ifndef rawmemrchr
 # define rawmemrchr libsimple_rawmemrchr
@@ -170,7 +170,7 @@ void *libsimple_rawmemrchr(const void *, int, size_t);
  * @return     `s` with a maximal offset such that `tolower(*r) == tolower(c)`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemrcasechr(const void *, int, size_t);
 #ifndef rawmemrcasechr
 # define rawmemrcasechr libsimple_rawmemrcasechr
@@ -188,7 +188,7 @@ void *libsimple_rawmemrcasechr(const void *, int, size_t);
  *             where `r` is the returned pointer, `NULL` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memchr_inv(const void *, int, size_t);
 #ifndef memchr_inv
 # define memchr_inv libsimple_memchr_inv
@@ -206,7 +206,7 @@ void *libsimple_memchr_inv(const void *, int, size_t);
  *             where `r` is the returned pointer, `&s[n]` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_memscan_inv(const void *, int, size_t);
 #ifndef memscan_inv
 # define memscan_inv libsimple_memscan_inv
@@ -224,7 +224,7 @@ void *libsimple_memscan_inv(const void *, int, size_t);
  *             where `r` is the returned pointer, `NULL` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memcasechr_inv(const void *, int, size_t);
 #ifndef memcasechr_inv
 # define memcasechr_inv libsimple_memcasechr_inv
@@ -242,7 +242,7 @@ void *libsimple_memcasechr_inv(const void *, int, size_t);
  *             where `r` is the returned pointer, `&s[n]` if
  *             no such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_memcasescan_inv(const void *, int, size_t);
 #ifndef memcasescan_inv
 # define memcasescan_inv libsimple_memcasescan_inv
@@ -263,7 +263,7 @@ void *libsimple_memcasescan_inv(const void *, int, size_t);
  * @return     `s` with a miminal offset such that `*r != c`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemchr_inv(const void *, int);
 #ifndef rawmemchr_inv
 # define rawmemchr_inv libsimple_rawmemchr_inv
@@ -284,7 +284,7 @@ void *libsimple_rawmemchr_inv(const void *, int);
  * @return     `s` with a miminal offset such that `tolower(*r) != tolower(c)`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemcasechr_inv(const void *, int);
 #ifndef rawmemcasechr_inv
 # define rawmemcasechr_inv libsimple_rawmemcasechr_inv
@@ -302,7 +302,7 @@ void *libsimple_rawmemcasechr_inv(const void *, int);
  *             where `r` is the returned pointer `NULL` if no
  *             such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrchr_inv(const void *, int, size_t);
 #ifndef memrchr_inv
 # define memrchr_inv libsimple_memrchr_inv
@@ -320,7 +320,7 @@ void *libsimple_memrchr_inv(const void *, int, size_t);
  *             where `r` is the returned pointer `NULL` if no
  *             such offset exists within [s, &s[n])
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrcasechr_inv(const void *, int, size_t);
 #ifndef memrcasechr_inv
 # define memrcasechr_inv libsimple_memrcasechr_inv
@@ -342,7 +342,7 @@ void *libsimple_memrcasechr_inv(const void *, int, size_t);
  * @return     `s` with a maximal offset such that `*r != c`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemrchr_inv(const void *, int, size_t);
 #ifndef rawmemrchr_inv
 # define rawmemrchr_inv libsimple_rawmemrchr_inv
@@ -364,7 +364,7 @@ void *libsimple_rawmemrchr_inv(const void *, int, size_t);
  * @return     `s` with a maximal offset such that `tolower(*r) != tolower(c)`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemrcasechr_inv(const void *, int, size_t);
 #ifndef rawmemrcasechr_inv
 # define rawmemrcasechr_inv libsimple_rawmemrcasechr_inv
@@ -382,7 +382,7 @@ void *libsimple_rawmemrcasechr_inv(const void *, int, size_t);
  *                     `!memcmp(r, needle, nneedle)` where `r` is the
  *                     returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+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
@@ -400,7 +400,7 @@ void *libsimple_memmem(const void *, size_t, const void *, size_t);
  *                     `!memcasecmp(r, needle, nneedle)` where `r` is the
  *                     returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memcasemem(const void *, size_t, const void *, size_t);
 #ifndef memcasemem
 # define memcasemem libsimple_memcasemem
@@ -418,7 +418,7 @@ void *libsimple_memcasemem(const void *, size_t, const void *, size_t);
  *                     `!memcmp(r, needle, nneedle)` where `r` is the
  *                     returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrmem(const void *, size_t, const void *, size_t);
 #ifndef memrmem
 # define memrmem libsimple_memrmem
@@ -436,7 +436,7 @@ void *libsimple_memrmem(const void *, size_t, const void *, size_t);
  *                     `!memcasecmp(r, needle, nneedle)` where `r` is the
  *                     returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrcasemem(const void *, size_t, const void *, size_t);
 #ifndef memrcasemem
 # define memrcasemem libsimple_memrcasemem
@@ -452,7 +452,7 @@ void *libsimple_memrcasemem(const void *, size_t, const void *, size_t);
  * @param   m  The length of `t`
  * @return     1 if `s` begins with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+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
@@ -468,7 +468,7 @@ int libsimple_memstarts(const void *, size_t, const void *, size_t);
  * @param   m  The length of `t`
  * @return     1 if `s` begins with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 int libsimple_memcasestarts(const void *, size_t, const void *, size_t);
 #ifndef memcasestarts
 # define memcasestarts libsimple_memcasestarts
@@ -484,7 +484,7 @@ int libsimple_memcasestarts(const void *, size_t, const void *, size_t);
  * @param   m  The length of `t`
  * @return     1 if `s` ends with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+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
@@ -500,7 +500,7 @@ int libsimple_memends(const void *, size_t, const void *, size_t);
  * @param   m  The length of `t`
  * @return     1 if `s` ends with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 int libsimple_memcaseends(const void *, size_t, const void *, size_t);
 #ifndef memcaseends
 # define memcaseends libsimple_memcaseends
@@ -515,7 +515,7 @@ int libsimple_memcaseends(const void *, size_t, const void *, size_t);
  * @param   n  The lengths of the arrays
  * @return     1 if the arrays are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 int libsimple_memcasecmp(const void *, const void *, size_t);
 #ifndef memcasecmp
 # define memcasecmp libsimple_memcasecmp
@@ -530,9 +530,12 @@ int libsimple_memcasecmp(const void *, const void *, size_t);
  * @param   n  The lengths of the arrays
  * @return     1 if the arrays are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_memeq(const void *__a, const void *__b, size_t __n)
-{ return !memcmp(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+inline int
+libsimple_memeq(const void *a__, const void *b__, size_t n__)
+{
+	return !memcmp(a__, b__, n__);
+}
 #ifndef memeq
 # define memeq libsimple_memeq
 #endif
@@ -546,9 +549,12 @@ static inline int libsimple_memeq(const void *__a, const void *__b, size_t __n)
  * @param   n  The lengths of the arrays
  * @return     1 if the arrays are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_memcaseeq(const void *__a, const void *__b, size_t __n)
-{ return !memcasecmp(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+inline int
+libsimple_memcaseeq(const void *a__, const void *b__, size_t n__)
+{
+	return !memcasecmp(a__, b__, n__);
+}
 #ifndef memcaseeq
 # define memcaseeq libsimple_memcaseeq
 #endif
@@ -562,8 +568,11 @@ static inline int libsimple_memcaseeq(const void *__a, const void *__b, size_t _
  * @param   n  The number of bytes to copy
  * @return     `&d[n]`
  */
-static inline void *libsimple_mempcpy(void *restrict __d, const void *restrict __s, size_t __n)
-{ return &((char *)memcpy(__d, __s, __n))[__n]; }
+inline void *
+libsimple_mempcpy(void *restrict d__, const void *restrict s__, size_t n__)
+{
+	return &((char *)memcpy(d__, s__, n__))[n__];
+}
 #ifndef mempcpy
 # define mempcpy libsimple_mempcpy
 #endif
@@ -577,8 +586,11 @@ static inline void *libsimple_mempcpy(void *restrict __d, const void *restrict _
  * @param   n  The number of bytes to move
  * @return     `&d[n]`
  */
-static inline void *libsimple_mempmove(void *__d, const void *__s, size_t __n)
-{ return &((char *)memmove(__d, __s, __n))[__n]; }
+inline void *
+libsimple_mempmove(void *d__, const void *s__, size_t n__)
+{
+	return &((char *)memmove(d__, s__, n__))[n__];
+}
 #ifndef mempmove
 # define mempmove libsimple_mempmove
 #endif
@@ -592,8 +604,11 @@ static inline void *libsimple_mempmove(void *__d, const void *__s, size_t __n)
  * @param   n  The number of bytes to write to `s`
  * @return     `&s[n]`
  */
-static inline void *libsimple_mempset(void *__s, int __c, size_t __n)
-{ return &((char *)memset(__s, __c, __n))[__n]; }
+inline void *
+libsimple_mempset(void *s__, int c__, size_t n__)
+{
+	return &((char *)memset(s__, c__, n__))[n__];
+}
 #ifndef mempset
 # define mempset libsimple_mempset
 #endif
@@ -612,13 +627,13 @@ static inline void *libsimple_mempset(void *__s, int __c, size_t __n)
  * @param   c  The byte that stops the copying
  * @return     `&rawmemchr(d, c)[1]` (after copying)
  */
-static inline void *
-libsimple_rawmemccpy(void *restrict __d_, const void *restrict __s_, int __c_)
+inline void *
+libsimple_rawmemccpy(void *restrict d___, const void *restrict s___, int c___)
 {
-	char __c = (char)__c_, *restrict __d = __d_;
-	const char *restrict __s = __s_;
-	for (; (*__d++ = *__s) != __c; __s++);
-	return __d;
+	char c__ = (char)c___, *restrict d__ = d___;
+	const char *restrict s__ = s___;
+	for (; (*d__++ = *s__) != c__; s__++);
+	return d__;
 }
 #ifndef rawmemccpy
 # define rawmemccpy libsimple_rawmemccpy
@@ -655,24 +670,24 @@ void *libsimple_memcmove(void *, const void *, int, size_t);
  * @param   c  The byte that stops the copying
  * @return     `&rawmemchr(d, c)[1]` (after copying)
  */
-static inline void *
-libsimple_rawmemcmove(void *__d_, const void *__s_, int __c_)
+inline void *
+libsimple_rawmemcmove(void *d___, const void *s___, int c___)
 {
-	char *__d = __d_, *__p, __c = (char)__c_;
-	const char *__s = __s_;
-	size_t __n;
-	if (__d <= __s) {
-		for (; (*__d++ = *__s) != __c; __s++);
-		return __d;
+	char *d__ = d___, *p__, c__ = (char)c___;
+	const char *s__ = s___;
+	size_t n__;
+	if (d__ <= s__) {
+		for (; (*d__++ = *s__) != c__; s__++);
+		return d__;
 	} else {
-		for (__p = *(char **)(void *)&__s; *__p++ != __c;);
-		__n = (size_t)(__p - __s);
-		__p = &__d[__n];
-		while (__n) {
-			__n--;
-			__d[__n] = __s[__n];
+		for (p__ = *(char **)(void *)&s__; *p__++ != c__;);
+		n__ = (size_t)(p__ - s__);
+		p__ = &d__[n__];
+		while (n__) {
+			n__--;
+			d__[n__] = s__[n__];
 		}
-		return __p;
+		return p__;
 	}
 }
 #ifndef rawmemcmove
@@ -689,15 +704,15 @@ libsimple_rawmemcmove(void *__d_, const void *__s_, int __c_)
  * @param   n    The length of `s`
  * @return       `(void *)&((char *)s)[n]`
  */
-static inline void *
-libsimple_memreplace(void *__s_, int __old_, int __new_, size_t __n)
+inline void *
+libsimple_memreplace(void *s___, int old___, int new___, size_t n__)
 {
-	char __old = (char)__old_, __new = (char)__new_, *__s = __s_;
-	char *__ret = &__s[__n];
-	while (__n)
-		if (__s[--__n] == __old)
-			__s[__n] = __new;
-	return __ret;
+	char old__ = (char)old___, new__ = (char)new___, *s__ = s___;
+	char *ret__ = &s__[n__];
+	while (n__)
+		if (s__[--n__] == old__)
+			s__[n__] = new__;
+	return ret__;
 }
 #ifndef memreplace
 # define memreplace libsimple_memreplace
@@ -755,8 +770,12 @@ void *libsimple_memptoupper(void *, const void *, size_t);
  * @param   n  The number of bytes to copy or covert
  * @return     `d`
  */
-static inline void *libsimple_memtolower(void *__d, const void *__s, size_t __n)
-{ libsimple_memptolower(__d, __s, __n); return __d; }
+inline void *
+libsimple_memtolower(void *d__, const void *s__, size_t n__)
+{
+	libsimple_memptolower(d__, s__, n__);
+	return d__;
+}
 #ifndef memtolower
 # define memtolower libsimple_memtolower
 #endif
@@ -775,8 +794,12 @@ static inline void *libsimple_memtolower(void *__d, const void *__s, size_t __n)
  * @param   n  The number of bytes to copy or covert
  * @return     `d`
  */
-static inline void *libsimple_memtoupper(void *__d, const void *__s, size_t __n)
-{ libsimple_memptoupper(__d, __s, __n); return __d; }
+inline void *
+libsimple_memtoupper(void *d__, const void *s__, size_t n__)
+{
+	libsimple_memptoupper(d__, s__, n__);
+	return d__;
+}
 #ifndef memtoupper
 # define memtoupper libsimple_memtoupper
 #endif
@@ -792,7 +815,7 @@ static inline void *libsimple_memtoupper(void *__d, const void *__s, size_t __n)
  * @return     The number of bytes `a` and `b` have
  *             in common in their beginnings
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 size_t libsimple_memeqlen(const void *, size_t, const void *, size_t);
 #ifndef memeqlen
 # define memeqlen libsimple_memeqlen
@@ -809,7 +832,7 @@ size_t libsimple_memeqlen(const void *, size_t, const void *, size_t);
  * @return     The number of bytes `a` and `b` have
  *             in common in their beginnings
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 size_t libsimple_memcaseeqlen(const void *, size_t, const void *, size_t);
 #ifndef memcaseeqlen
 # define memcaseeqlen libsimple_memcaseeqlen
@@ -826,7 +849,7 @@ size_t libsimple_memcaseeqlen(const void *, size_t, const void *, size_t);
  * @return     The number of bytes `a` and `b` have
  *             in common in their ends
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 size_t libsimple_memreqlen(const void *, size_t, const void *, size_t);
 #ifndef memreqlen
 # define memreqlen libsimple_memreqlen
@@ -843,7 +866,7 @@ size_t libsimple_memreqlen(const void *, size_t, const void *, size_t);
  * @return     The number of bytes `a` and `b` have
  *             in common in their ends
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 size_t libsimple_memrcaseeqlen(const void *, size_t, const void *, size_t);
 #ifndef memrcaseeqlen
 # define memrcaseeqlen libsimple_memrcaseeqlen
@@ -859,7 +882,7 @@ size_t libsimple_memrcaseeqlen(const void *, size_t, const void *, size_t);
  *                              allows a two-byte encoding for NUL
  * @return                      1 if good, 0 on encoding error
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 int libsimple_memisutf8(const char *, size_t, int);
 #ifndef memisutf8
 # define memisutf8 libsimple_memisutf8
diff --git a/libsimple/memalign.h b/libsimple/memalign.h
index d533751..e36c6f9 100644
--- a/libsimple/memalign.h
+++ b/libsimple/memalign.h
@@ -19,9 +19,12 @@
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
-static inline void *libsimple_vmemalignn(size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_vmemalignzn(0, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
+static inline void *
+libsimple_vmemalignn(size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_vmemalignzn(0, alignment__, n__, ap__);
+}
 #ifndef vmemalignn
 # define vmemalignn libsimple_vmemalignn
 #endif
@@ -38,9 +41,12 @@ static inline void *libsimple_vmemalignn(size_t __alignment, size_t __n, va_list
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __alloc_size__(2), __warn_unused_result__)))
-static inline void *libsimple_memalign(size_t __alignment, size_t __n)
-{ return libsimple_memalignz(0, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __alloc_size__(2), __warn_unused_result__)))
+static inline void *
+libsimple_memalign(size_t alignment__, size_t n__)
+{
+	return libsimple_memalignz(0, alignment__, n__);
+}
 #ifndef memalign
 # define memalign libsimple_memalign
 #endif
@@ -64,14 +70,14 @@ static inline void *libsimple_memalign(size_t __alignment, size_t __n)
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__)))
 static inline void *
-libsimple_memalignn(size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_memalignn(size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vmemalignn(__alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vmemalignn(alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef memalignn
 # define memalignn libsimple_memalignn
@@ -93,9 +99,12 @@ libsimple_memalignn(size_t __alignment, size_t __n, ... /*, (size_t)0 */)
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_enmemalign(int __status, size_t __alignment, size_t __n)
-{ return libsimple_enmemalignz(__status, 0, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_enmemalign(int status__, size_t alignment__, size_t n__)
+{
+	return libsimple_enmemalignz(status__, 0, alignment__, n__);
+}
 #ifndef enmemalign
 # define enmemalign libsimple_enmemalign
 #endif
@@ -122,9 +131,12 @@ static inline void *libsimple_enmemalign(int __status, size_t __alignment, size_
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envmemalignn(int __status, size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envmemalignzn(__status, 0, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_envmemalignn(int status__, size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envmemalignzn(status__, 0, alignment__, n__, ap__);
+}
 #ifndef envmemalignn
 # define envmemalignn libsimple_envmemalignn
 #endif
@@ -151,14 +163,14 @@ static inline void *libsimple_envmemalignn(int __status, size_t __alignment, siz
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enmemalignn(int __status, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_enmemalignn(int status__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envmemalignzn(__status, 0, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envmemalignzn(status__, 0, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enmemalignn
 # define enmemalignn libsimple_enmemalignn
@@ -179,9 +191,12 @@ libsimple_enmemalignn(int __status, size_t __alignment, size_t __n, ... /*, (siz
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ememalign(size_t __alignment, size_t __n)
-{ return libsimple_enmemalign(libsimple_default_failure_exit, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ememalign(size_t alignment__, size_t n__)
+{
+	return libsimple_enmemalign(libsimple_default_failure_exit, alignment__, n__);
+}
 #ifndef ememalign
 # define ememalign libsimple_ememalign
 #endif
@@ -208,9 +223,12 @@ static inline void *libsimple_ememalign(size_t __alignment, size_t __n)
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evmemalignn(size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envmemalignn(libsimple_default_failure_exit, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evmemalignn(size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envmemalignn(libsimple_default_failure_exit, alignment__, n__, ap__);
+}
 #ifndef evmemalignn
 # define evmemalignn libsimple_evmemalignn
 #endif
@@ -236,14 +254,14 @@ static inline void *libsimple_evmemalignn(size_t __alignment, size_t __n, va_lis
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(1), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_ememalignn(size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_ememalignn(size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evmemalignn(__alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evmemalignn(alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef ememalignn
 # define ememalignn libsimple_ememalignn
diff --git a/libsimple/memalignz.h b/libsimple/memalignz.h
index 7eab805..62ab444 100644
--- a/libsimple/memalignz.h
+++ b/libsimple/memalignz.h
@@ -20,17 +20,17 @@
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
 static inline void *
-libsimple_vmemalignzn(int __clear, size_t __alignment, size_t __n, va_list __ap)
+libsimple_vmemalignzn(int clear__, size_t alignment__, size_t n__, va_list ap__)
 {
-	if (!__alignment || (__alignment & (__alignment - 1UL))) {
+	if (!alignment__ || (alignment__ & (alignment__ - 1UL))) {
 		errno = EINVAL;
 		return NULL;
 	}
-	return libsimple_memalloc(0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, __n, __ap,
-	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
-	                          LIBSIMPLE_MEMALLOC_ALIGNMENT, __alignment,
+	return libsimple_memalloc(0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, n__, ap__,
+	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
+	                          LIBSIMPLE_MEMALLOC_ALIGNMENT, alignment__,
 	                          LIBSIMPLE_MEMALLOC_END);
 }
 #ifndef vmemalignzn
@@ -50,17 +50,17 @@ libsimple_vmemalignzn(int __clear, size_t __alignment, size_t __n, va_list __ap)
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__)))
 static inline void *
-libsimple_memalignz(int __clear, size_t __alignment, size_t __n)
+libsimple_memalignz(int clear__, size_t alignment__, size_t n__)
 {
-	if (!__alignment || (__alignment & (__alignment - 1UL))) {
+	if (!alignment__ || (alignment__ & (alignment__ - 1UL))) {
 		errno = EINVAL;
 		return NULL;
 	}
-	return libsimple_memalloc(__n,
-	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
-	                          LIBSIMPLE_MEMALLOC_ALIGNMENT, __alignment,
+	return libsimple_memalloc(n__,
+	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
+	                          LIBSIMPLE_MEMALLOC_ALIGNMENT, alignment__,
 	                          LIBSIMPLE_MEMALLOC_END);
 }
 #ifndef memalignz
@@ -87,14 +87,14 @@ libsimple_memalignz(int __clear, size_t __alignment, size_t __n)
  * @throws  EINVAL     `n` is 0 or `alignment` is not a power of 2
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__)))
 static inline void *
-libsimple_memalignzn(int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_memalignzn(int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vmemalignzn(__clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vmemalignzn(clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef memalignzn
 # define memalignzn libsimple_memalignzn
@@ -117,17 +117,17 @@ libsimple_memalignzn(int __clear, size_t __alignment, size_t __n, ... /*, (size_
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __alloc_size__(4), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enmemalignz(int __status, int __clear, size_t __alignment, size_t __n)
+libsimple_enmemalignz(int status__, int clear__, size_t alignment__, size_t n__)
 {
-	if (!__alignment || (__alignment & (__alignment - 1UL))) {
+	if (!alignment__ || (alignment__ & (alignment__ - 1UL))) {
 		errno = EINVAL;
-		libsimple_enprintf(__status, "libsimple_vmemalignz:");
+		libsimple_enprintf(status__, "libsimple_vmemalignz:");
 	}
-	return libsimple_enmemalloc(__status, __n,
-	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
-	                            LIBSIMPLE_MEMALLOC_ALIGNMENT, __alignment,
+	return libsimple_enmemalloc(status__, n__,
+	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
+	                            LIBSIMPLE_MEMALLOC_ALIGNMENT, alignment__,
 	                            LIBSIMPLE_MEMALLOC_END);
 }
 #ifndef enmemalignz
@@ -157,18 +157,18 @@ libsimple_enmemalignz(int __status, int __clear, size_t __alignment, size_t __n)
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_envmemalignzn(int __status, int __clear, size_t __alignment, size_t __n, va_list __ap)
+libsimple_envmemalignzn(int status__, int clear__, size_t alignment__, size_t n__, va_list ap__)
 {
-	if (!__alignment || (__alignment & (__alignment - 1UL))) {
+	if (!alignment__ || (alignment__ & (alignment__ - 1UL))) {
 		errno = EINVAL;
 		return NULL;
 	}
-	return libsimple_enmemalloc(__status,
-	                            0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, __n, __ap,
-	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
-	                            LIBSIMPLE_MEMALLOC_ALIGNMENT, __alignment,
+	return libsimple_enmemalloc(status__,
+	                            0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, n__, ap__,
+	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
+	                            LIBSIMPLE_MEMALLOC_ALIGNMENT, alignment__,
 	                            LIBSIMPLE_MEMALLOC_END);
 }
 #ifndef envmemalignzn
@@ -198,14 +198,14 @@ libsimple_envmemalignzn(int __status, int __clear, size_t __alignment, size_t __
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(3), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_enmemalignzn(int __status, int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_enmemalignzn(int status__, int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envmemalignzn(__status, __clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envmemalignzn(status__, clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enmemalignzn
 # define enmemalignzn libsimple_enmemalignzn
@@ -227,9 +227,12 @@ libsimple_enmemalignzn(int __status, int __clear, size_t __alignment, size_t __n
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ememalignz(int __clear, size_t __alignment, size_t __n)
-{ return libsimple_enmemalignz(libsimple_default_failure_exit, __clear, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_ememalignz(int clear__, size_t alignment__, size_t n__)
+{
+	return libsimple_enmemalignz(libsimple_default_failure_exit, clear__, alignment__, n__);
+}
 #ifndef ememalignz
 # define ememalignz libsimple_ememalignz
 #endif
@@ -256,9 +259,12 @@ static inline void *libsimple_ememalignz(int __clear, size_t __alignment, size_t
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evmemalignzn(int __clear, size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_envmemalignzn(libsimple_default_failure_exit, __clear, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evmemalignzn(int clear__, size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_envmemalignzn(libsimple_default_failure_exit, clear__, alignment__, n__, ap__);
+}
 #ifndef evmemalignzn
 # define evmemalignzn libsimple_evmemalignzn
 #endif
@@ -285,14 +291,14 @@ static inline void *libsimple_evmemalignzn(int __clear, size_t __alignment, size
  * @return             A unique pointer with at least the specified size
  *                     and alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_ememalignzn(int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+libsimple_ememalignzn(int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evmemalignzn(__clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evmemalignzn(clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef ememalignzn
 # define ememalignzn libsimple_ememalignzn
diff --git a/libsimple/memalloc.h b/libsimple/memalloc.h
index 5b91a64..9f894e8 100644
--- a/libsimple/memalloc.h
+++ b/libsimple/memalloc.h
@@ -78,42 +78,45 @@ enum libsimple_memalloc_option {
 	                     LIBSIMPLE_MEMALLOC_ALIGNMENT, _Alignof(TYPE),\
 	                     __VA_ARGS__)
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 void *libsimple_vmemalloc(size_t, va_list);
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 void *libsimple_envmemalloc(int, size_t, va_list);
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *libsimple_evmemalloc(size_t __n, va_list __ap)
-{ return libsimple_envmemalloc(libsimple_default_failure_exit, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_evmemalloc(size_t n__, va_list ap__)
+{
+	return libsimple_envmemalloc(libsimple_default_failure_exit, n__, ap__);
+}
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_memalloc(size_t __n, ... /*, LIBSIMPLE_MEMALLOC_END */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_memalloc(size_t n__, ... /*, LIBSIMPLE_MEMALLOC_END */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vmemalloc(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vmemalloc(n__, ap__);
+	va_end(ap__);
 }
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_enmemalloc(int __status, size_t __n, ... /*, LIBSIMPLE_MEMALLOC_END */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_enmemalloc(int status__, size_t n__, ... /*, LIBSIMPLE_MEMALLOC_END */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envmemalloc(__status, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envmemalloc(status__, n__, ap__);
+	va_end(ap__);
 }
 
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_ememalloc(size_t __n, ... /*, LIBSIMPLE_MEMALLOC_END */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_ememalloc(size_t n__, ... /*, LIBSIMPLE_MEMALLOC_END */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evmemalloc(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evmemalloc(n__, ap__);
+	va_end(ap__);
 }
diff --git a/libsimple/memdup.h b/libsimple/memdup.h
index 383b338..f799eee 100644
--- a/libsimple/memdup.h
+++ b/libsimple/memdup.h
@@ -10,11 +10,12 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_memdupa(s, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__s = (s);\
-		size_t __n = (n);\
-		char *__r = alloca(__n + !__n);\
-		memcpy(__r, __s, __n);\
+		const char *s__ = (s);\
+		size_t n__ = (n);\
+		char *r__ = alloca(n__ + !n__);\
+		memcpy(r__, s__, n__);\
 	})
 # ifndef memdupa
 #  define memdupa(s, n) libsimple_memdupa(s, n)
@@ -29,7 +30,7 @@
  * @param   n  The number of bytes to copy
  * @return     Duplicate of `s`, `NULL` on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2), __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2), __nonnull__, __warn_unused_result__)))
 void *libsimple_memdup(const void *, size_t);
 #ifndef memdup
 # define memdup libsimple_memdup
@@ -44,7 +45,7 @@ void *libsimple_memdup(const void *, size_t);
  * @param   n       The number of bytes to copy
  * @return          Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enmemdup(int, const void *, size_t);
 #ifndef enmemdup
 # define enmemdup libsimple_enmemdup
@@ -58,11 +59,11 @@ void *libsimple_enmemdup(int, const void *, size_t);
  * @param   n  The number of bytes to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
 inline void *
-libsimple_ememdup(const void *__s, size_t __n)
+libsimple_ememdup(const void *s__, size_t n__)
 {
-	return libsimple_enmemdup(libsimple_default_failure_exit, __s, __n);
+	return libsimple_enmemdup(libsimple_default_failure_exit, s__, n__);
 }
 #ifndef ememdup
 # define ememdup libsimple_ememdup
diff --git a/libsimple/memelem.h b/libsimple/memelem.h
index ab4ffca..e78251a 100644
--- a/libsimple/memelem.h
+++ b/libsimple/memelem.h
@@ -13,7 +13,7 @@
  *                     pointer and such that `(r - haystack) % width == 0`,
  *                     `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memelem(const void *, const void *, size_t, size_t);
 #ifndef memelem
 # define memelem libsimple_memelem
@@ -35,7 +35,7 @@ void *libsimple_memelem(const void *, const void *, size_t, size_t);
  *                     `!memcmp(r, needle, width)` where `r` is the returned
  *                     pointer and such that `(r - haystack) % width == 0`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemelem(const void *, const void *, size_t);
 #ifndef rawmemelem
 # define rawmemelem libsimple_rawmemelem
@@ -55,7 +55,7 @@ void *libsimple_rawmemelem(const void *, const void *, size_t);
  *                     `(void *)&((char *)haystack)[n * width]` if no such
  *                     offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memelemscan(const void *, const void *, size_t, size_t);
 #ifndef memelemscan
 # define memelemscan libsimple_memelemscan
@@ -74,7 +74,7 @@ void *libsimple_memelemscan(const void *, const void *, size_t, size_t);
  *                     pointer and such that `(r - haystack) % width == 0`,
  *                     `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrelem(const void *, const void *, size_t, size_t);
 #ifndef memrelem
 # define memrelem libsimple_memrelem
@@ -97,7 +97,7 @@ void *libsimple_memrelem(const void *, const void *, size_t, size_t);
  *                     `!memcmp(r, needle, width)` where `r` is the returned
  *                     pointer and such that `(r - haystack) % width == 0`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemrelem(const void *, const void *, size_t, size_t);
 #ifndef rawmemrelem
 # define rawmemrelem libsimple_rawmemrelem
@@ -117,7 +117,7 @@ void *libsimple_rawmemrelem(const void *, const void *, size_t, size_t);
  *                     pointer and such that `(r - haystack) % width == 0`,
  *                     `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memelem_inv(const void *, const void *, size_t, size_t);
 #ifndef memelem_inv
 # define memelem_inv libsimple_memelem_inv
@@ -140,7 +140,7 @@ void *libsimple_memelem_inv(const void *, const void *, size_t, size_t);
  *                     `memcmp(r, needle, width)` where `r` is the returned
  *                     pointer and such that `(r - haystack) % width == 0`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemelem_inv(const void *, const void *, size_t);
 #ifndef rawmemelem_inv
 # define rawmemelem_inv libsimple_rawmemelem_inv
@@ -161,7 +161,7 @@ void *libsimple_rawmemelem_inv(const void *, const void *, size_t);
  *                     `(void *)&((char *)haystack)[n * width]` if no such
  *                     offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memelemscan_inv(const void *, const void *, size_t, size_t);
 #ifndef memelemscan_inv
 # define memelemscan_inv libsimple_memelemscan_inv
@@ -181,7 +181,7 @@ void *libsimple_memelemscan_inv(const void *, const void *, size_t, size_t);
  *                     pointer and such that `(r - haystack) % width == 0`,
  *                     `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
 void *libsimple_memrelem_inv(const void *, const void *, size_t, size_t);
 #ifndef memrelem_inv
 # define memrelem_inv libsimple_memrelem_inv
@@ -205,7 +205,7 @@ void *libsimple_memrelem_inv(const void *, const void *, size_t, size_t);
  *                     `memcmp(r, needle, width)` where `r` is the returned
  *                     pointer and such that `(r - haystack) % width == 0`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
 void *libsimple_rawmemrelem_inv(const void *, const void *, size_t, size_t);
 #ifndef rawmemrelem_inv
 # define rawmemrelem_inv libsimple_rawmemrelem_inv
@@ -221,7 +221,7 @@ void *libsimple_rawmemrelem_inv(const void *, const void *, size_t, size_t);
  * @param   n      The number of copies to fill `buf` with
  * @return         `&buf[n * width]`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__)))
 void *libsimple_mempsetelem(void *, const void *, size_t, size_t);
 #ifndef mempsetelem
 # define mempsetelem libsimple_mempsetelem
@@ -237,12 +237,12 @@ void *libsimple_mempsetelem(void *, const void *, size_t, size_t);
  * @param   n       The number of copies to fill `buf` with
  * @return          `buf`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__)))
 inline void *
-libsimple_memsetelem(void *__buf, const void *__item, size_t __width, size_t __n)
+libsimple_memsetelem(void *buf__, const void *item__, size_t width__, size_t n__)
 {
-	__item = libsimple_mempsetelem(__buf, __item, __width, __n);
-	return __buf;
+	item__ = libsimple_mempsetelem(buf__, item__, width__, n__);
+	return buf__;
 }
 #ifndef memsetelem
 # define memsetelem libsimple_memsetelem
diff --git a/libsimple/posix_memalign.h b/libsimple/posix_memalign.h
index f656ea8..78924de 100644
--- a/libsimple/posix_memalign.h
+++ b/libsimple/posix_memalign.h
@@ -25,9 +25,12 @@
  *                     `alignment` is not a multiple of `sizeof(void *)`
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline int libsimple_vposix_memalignn(void **__memptr, size_t __alignment, size_t __n, va_list __ap)
-{ return libsimple_vposix_memalignzn(__memptr, 0, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline int
+libsimple_vposix_memalignn(void **memptr__, size_t alignment__, size_t n__, va_list ap__)
+{
+	return libsimple_vposix_memalignzn(memptr__, 0, alignment__, n__, ap__);
+}
 #ifndef vposix_memalignn
 # define vposix_memalignn libsimple_vposix_memalignn
 #endif
@@ -57,14 +60,14 @@ static inline int libsimple_vposix_memalignn(void **__memptr, size_t __alignment
  *                     `alignment` is not a multiple of `sizeof(void *)`
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline int
-libsimple_posix_memalignn(void **__memptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline int
+libsimple_posix_memalignn(void **memptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vposix_memalignn(__memptr, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vposix_memalignn(memptr__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef posix_memalignn
 # define posix_memalignn libsimple_posix_memalignn
@@ -88,9 +91,12 @@ libsimple_posix_memalignn(void **__memptr, size_t __alignment, size_t __n, ... /
  * @param  n          The number of bytes to allocate, the behaviour of
  *                    this function is unspecified for the value 0
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
-static inline void libsimple_enposix_memalign(int __status, void **__memptr, size_t __alignment, size_t __n)
-{ libsimple_enposix_memalignz(__status, __memptr, 0, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
+inline void
+libsimple_enposix_memalign(int status__, void **memptr__, size_t alignment__, size_t n__)
+{
+	libsimple_enposix_memalignz(status__, memptr__, 0, alignment__, n__);
+}
 #ifndef enposix_memalign
 # define enposix_memalign libsimple_enposix_memalign
 #endif
@@ -119,9 +125,12 @@ static inline void libsimple_enposix_memalign(int __status, void **__memptr, siz
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
-static inline void libsimple_envposix_memalignn(int __status, void **__memptr, size_t __alignment, size_t __n, va_list __ap)
-{ libsimple_envposix_memalignzn(__status, __memptr, 0, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
+inline void
+libsimple_envposix_memalignn(int status__, void **memptr__, size_t alignment__, size_t n__, va_list ap__)
+{
+	libsimple_envposix_memalignzn(status__, memptr__, 0, alignment__, n__, ap__);
+}
 #ifndef envposix_memalignn
 # define envposix_memalignn libsimple_envposix_memalignn
 #endif
@@ -150,14 +159,14 @@ static inline void libsimple_envposix_memalignn(int __status, void **__memptr, s
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
-static inline void
-libsimple_enposix_memalignn(int __status, void **__memptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
+inline void
+libsimple_enposix_memalignn(int status__, void **memptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	libsimple_envposix_memalignzn(__status, __memptr, 0, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	libsimple_envposix_memalignzn(status__, memptr__, 0, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enposix_memalignn
 # define enposix_memalignn libsimple_enposix_memalignn
@@ -180,9 +189,12 @@ libsimple_enposix_memalignn(int __status, void **__memptr, size_t __alignment, s
  * @param  n          The number of bytes to allocate, the behaviour of
  *                    this function is unspecified for the value 0
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void libsimple_eposix_memalign(void **__memptr, size_t __alignment, size_t __n)
-{ libsimple_enposix_memalign(libsimple_default_failure_exit, __memptr, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_eposix_memalign(void **memptr__, size_t alignment__, size_t n__)
+{
+	libsimple_enposix_memalign(libsimple_default_failure_exit, memptr__, alignment__, n__);
+}
 #ifndef eposix_memalign
 # define eposix_memalign libsimple_eposix_memalign
 #endif
@@ -210,9 +222,12 @@ static inline void libsimple_eposix_memalign(void **__memptr, size_t __alignment
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void libsimple_evposix_memalignn(void **__memptr, size_t __alignment, size_t __n, va_list __ap)
-{ libsimple_envposix_memalignn(libsimple_default_failure_exit, __memptr, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_evposix_memalignn(void **memptr__, size_t alignment__, size_t n__, va_list ap__)
+{
+	libsimple_envposix_memalignn(libsimple_default_failure_exit, memptr__, alignment__, n__, ap__);
+}
 #ifndef evposix_memalignn
 # define evposix_memalignn libsimple_evposix_memalignn
 #endif
@@ -240,14 +255,14 @@ static inline void libsimple_evposix_memalignn(void **__memptr, size_t __alignme
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void
-libsimple_eposix_memalignn(void **__memptr, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_eposix_memalignn(void **memptr__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	libsimple_evposix_memalignn(__memptr, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	libsimple_evposix_memalignn(memptr__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef eposix_memalignn
 # define eposix_memalignn libsimple_eposix_memalignn
diff --git a/libsimple/posix_memalignz.h b/libsimple/posix_memalignz.h
index 323863d..eb3e138 100644
--- a/libsimple/posix_memalignz.h
+++ b/libsimple/posix_memalignz.h
@@ -26,7 +26,7 @@
  *                     `alignment` is not a multiple of `sizeof(void *)`
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
 int libsimple_vposix_memalignzn(void **, int, size_t, size_t, va_list);
 #ifndef vposix_memalignzn
 # define vposix_memalignzn libsimple_vposix_memalignzn
@@ -52,14 +52,14 @@ int libsimple_vposix_memalignzn(void **, int, size_t, size_t, va_list);
  *                     `alignment` is not a multiple of `sizeof(void *)`
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline int
-libsimple_posix_memalignz(void **__memptr, int __clear, size_t __alignment, size_t __n)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline int
+libsimple_posix_memalignz(void **memptr__, int clear__, size_t alignment__, size_t n__)
 {
-	int __ret = posix_memalign(__memptr, __alignment, __n);
-	if (!__ret && __clear)
-		memset(*__memptr, 0, __n);
-	return __ret;
+	int ret__ = posix_memalign(memptr__, alignment__, n__);
+	if (!ret__ && clear__)
+		memset(*memptr__, 0, n__);
+	return ret__;
 }
 #ifndef posix_memalignz
 # define posix_memalignz libsimple_posix_memalignz
@@ -91,14 +91,14 @@ libsimple_posix_memalignz(void **__memptr, int __clear, size_t __alignment, size
  *                     `alignment` is not a multiple of `sizeof(void *)`
  * @throws  ENOMEM     Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline int
-libsimple_posix_memalignzn(void **__memptr, int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline int
+libsimple_posix_memalignzn(void **memptr__, int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vposix_memalignzn(__memptr, __clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vposix_memalignzn(memptr__, clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef posix_memalignzn
 # define posix_memalignzn libsimple_posix_memalignzn
@@ -123,7 +123,7 @@ libsimple_posix_memalignzn(void **__memptr, int __clear, size_t __alignment, siz
  * @param  n          The number of bytes to allocate, the behaviour of
  *                    this function is unspecified for the value 0
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
 void libsimple_enposix_memalignz(int, void **, int, size_t, size_t);
 #ifndef enposix_memalignz
 # define enposix_memalignz libsimple_enposix_memalignz
@@ -154,7 +154,7 @@ void libsimple_enposix_memalignz(int, void **, int, size_t, size_t);
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
 void libsimple_envposix_memalignzn(int, void **, int, size_t, size_t, va_list);
 #ifndef envposix_memalignzn
 # define envposix_memalignzn libsimple_envposix_memalignzn
@@ -185,14 +185,14 @@ void libsimple_envposix_memalignzn(int, void **, int, size_t, size_t, va_list);
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
-static inline void
-libsimple_enposix_memalignzn(int __status, void **__memptr, int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
+inline void
+libsimple_enposix_memalignzn(int status__, void **memptr__, int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	libsimple_envposix_memalignzn(__status, __memptr, __clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	libsimple_envposix_memalignzn(status__, memptr__, clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enposix_memalignzn
 # define enposix_memalignzn libsimple_enposix_memalignzn
@@ -216,9 +216,12 @@ libsimple_enposix_memalignzn(int __status, void **__memptr, int __clear, size_t
  * @param  n          The number of bytes to allocate, the behaviour of
  *                    this function is unspecified for the value 0
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void libsimple_eposix_memalignz(void **__memptr, int __clear, size_t __alignment, size_t __n)
-{ libsimple_enposix_memalignz(libsimple_default_failure_exit, __memptr, __clear, __alignment, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_eposix_memalignz(void **memptr__, int clear__, size_t alignment__, size_t n__)
+{
+	libsimple_enposix_memalignz(libsimple_default_failure_exit, memptr__, clear__, alignment__, n__);
+}
 #ifndef eposix_memalignz
 # define eposix_memalignz libsimple_eposix_memalignz
 #endif
@@ -247,9 +250,12 @@ static inline void libsimple_eposix_memalignz(void **__memptr, int __clear, size
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void libsimple_evposix_memalignzn(void **__memptr, int __clear, size_t __alignment, size_t __n, va_list __ap)
-{ libsimple_envposix_memalignzn(libsimple_default_failure_exit, __memptr, __clear, __alignment, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_evposix_memalignzn(void **memptr__, int clear__, size_t alignment__, size_t n__, va_list ap__)
+{
+	libsimple_envposix_memalignzn(libsimple_default_failure_exit, memptr__, clear__, alignment__, n__, ap__);
+}
 #ifndef evposix_memalignzn
 # define evposix_memalignzn libsimple_evposix_memalignzn
 #endif
@@ -278,14 +284,14 @@ static inline void libsimple_evposix_memalignzn(void **__memptr, int __clear, si
  *                    all arguments should have the type `size_t`, and
  *                    list must end with 0 (which is not factor)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void
-libsimple_eposix_memalignzn(void **__memptr, int __clear, size_t __alignment, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_eposix_memalignzn(void **memptr__, int clear__, size_t alignment__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	libsimple_evposix_memalignzn(__memptr, __clear, __alignment, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	libsimple_evposix_memalignzn(memptr__, clear__, alignment__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef eposix_memalignzn
 # define eposix_memalignzn libsimple_eposix_memalignzn
diff --git a/libsimple/printf.h b/libsimple/printf.h
index cf7192e..95f6935 100644
--- a/libsimple/printf.h
+++ b/libsimple/printf.h
@@ -51,7 +51,7 @@ extern void (*libsimple_eprintf_postprint)(void);
  * @throws  ENOMEM  Could not allocate enough memory
  * @throws          Any error specified for `fprintf`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1, 2), __format__(__printf__, 2, 3))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1, 2), __format__(__printf__, 2, 3))))
 int libsimple_asprintf(char **, const char *, ...);
 #ifndef asprintf
 # define asprintf libsimple_asprintf
@@ -74,7 +74,7 @@ int libsimple_asprintf(char **, const char *, ...);
  * @throws  ENOMEM  Could not allocate enough memory
  * @throws          Any error specified for `fprintf`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1, 2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1, 2))))
 int libsimple_vasprintf(char **, const char *, va_list);
 #ifndef vasprintf
 # define vasprintf libsimple_vasprintf
@@ -95,16 +95,17 @@ int libsimple_vasprintf(char **, const char *, va_list);
  * @throws       Any error specified for `snprintf`
  */
 #if defined(__GNUC__) || defined(__clang__)
-# define libsimple_asprintfa(__fmt, ...)\
+# define libsimple_asprintfa(fmt__, ...)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__f = (__fmt);\
-		char *__ret = NULL;\
-		int __r = snprintf(NULL, 0, __f, __VA_ARGS__);\
-		if (__r >= 0) {\
-			__ret = alloca((size_t)__r + 1);\
-			sprintf(__ret, __f, __VA_ARGS__);\
+		const char *f__ = (fmt__);\
+		char *ret__ = NULL;\
+		int r__ = snprintf(NULL, 0, f__, __VA_ARGS__);\
+		if (r__ >= 0) {\
+			ret__ = alloca((size_t)r__ + 1);\
+			sprintf(ret__, f__, __VA_ARGS__);\
 		}\
-		__ret;\
+		ret__;\
 	})
 # ifndef asprintfa
 #  define asprintfa(...) libsimple_asprintfa(__VA_ARGS__)
@@ -126,23 +127,24 @@ int libsimple_vasprintf(char **, const char *, va_list);
  * @throws       Any error specified for `snprintf`
  */
 #if defined(__GNUC__) || defined(__clang__)
-# define libsimple_vasprintfa(__fmt, __ap)\
+# define libsimple_vasprintfa(fmt__, ap__)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__f = (__fmt);\
-		va_list __a1;\
-		va_list __a2;\
-		char *__ret = NULL;\
-		int __r;\
-		va_copy(__a1, __ap);\
-		va_copy(__a2, __a1);\
-		__r = vsnprintf(NULL, 0, __f, __a1);\
-		if (__r >= 0) {\
-			__ret = alloca((size_t)__r + 1);\
-			vsprintf(__ret, __f, __a2);\
+		const char *f__ = (fmt__);\
+		va_list a1__;\
+		va_list a2__;\
+		char *ret__ = NULL;\
+		int r__;\
+		va_copy(a1__, ap__);\
+		va_copy(a2__, a1__);\
+		r__ = vsnprintf(NULL, 0, f__, a1__);\
+		if (r__ >= 0) {\
+			ret__ = alloca((size_t)r__ + 1);\
+			vsprintf(ret__, f__, a2__);\
 		}\
-		va_end(__a2);\
-		va_end(__a1);\
-		__ret;\
+		va_end(a2__);\
+		va_end(a1__);\
+		ret__;\
 	})
 # ifndef vasprintfa
 #  define vasprintfa(fmt, ap) libsimple_vasprintfa(fmt, ap)
@@ -167,7 +169,7 @@ int libsimple_vasprintf(char **, const char *, va_list);
  * @param  fmt  The format string
  * @param  ap   The format argument
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
 void libsimple_vweprintf(const char *, va_list);
 #ifndef vweprintf
 # define vweprintf libsimple_vweprintf
@@ -191,14 +193,14 @@ void libsimple_vweprintf(const char *, va_list);
  * @param  fmt  The format string
  * @param  ...  The format argument
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2))))
-static inline void
-libsimple_weprintf(const char *__fmt, ...)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2))))
+inline void
+libsimple_weprintf(const char *fmt__, ...)
 {
-	va_list __ap;
-	va_start(__ap, __fmt);
-	libsimple_vweprintf(__fmt, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, fmt__);
+	libsimple_vweprintf(fmt__, ap__);
+	va_end(ap__);
 }
 #ifndef weprintf
 # define weprintf libsimple_weprintf
@@ -225,12 +227,12 @@ libsimple_weprintf(const char *__fmt, ...)
  * @param  fmt     The format string
  * @param  ap      The format argument
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __noreturn__)))
-static inline void
-libsimple_venprintf(int __status, const char *__fmt, va_list __ap)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __noreturn__)))
+inline void
+libsimple_venprintf(int status__, const char *fmt__, va_list ap__)
 {
-	libsimple_vweprintf(__fmt, __ap);
-	exit(__status);
+	libsimple_vweprintf(fmt__, ap__);
+	exit(status__);
 }
 #ifndef venprintf
 # define venprintf libsimple_venprintf
@@ -257,14 +259,14 @@ libsimple_venprintf(int __status, const char *__fmt, va_list __ap)
  * @param  fmt     The format string
  * @param  ...     The format argument
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __format__(__printf__, 2, 3), __noreturn__)))
-static inline void
-libsimple_enprintf(int __status, const char *__fmt, ...)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __format__(__printf__, 2, 3), __noreturn__)))
+inline void
+libsimple_enprintf(int status__, const char *fmt__, ...)
 {
-	va_list __ap;
-	va_start(__ap, __fmt);
-	libsimple_venprintf(__status, __fmt, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, fmt__);
+	libsimple_venprintf(status__, fmt__, ap__);
+	va_end(ap__);
 }
 #ifndef enprintf
 # define enprintf libsimple_enprintf
@@ -291,11 +293,11 @@ libsimple_enprintf(int __status, const char *__fmt, ...)
  * @param  fmt  The format string
  * @param  ap   The format argument
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1), __noreturn__)))
-static inline void
-libsimple_veprintf(const char *__fmt, va_list __ap)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1), __noreturn__)))
+inline void
+libsimple_veprintf(const char *fmt__, va_list ap__)
 {
-	libsimple_vweprintf(__fmt, __ap);
+	libsimple_vweprintf(fmt__, ap__);
 	exit(libsimple_default_failure_exit);
 }
 #ifndef veprintf
@@ -323,14 +325,14 @@ libsimple_veprintf(const char *__fmt, va_list __ap)
  * @param  fmt  The format string
  * @param  ...  The format argument
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2), __noreturn__)))
-static inline void
-libsimple_eprintf(const char *__fmt, ...)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2), __noreturn__)))
+inline void
+libsimple_eprintf(const char *fmt__, ...)
 {
-	va_list __ap;
-	va_start(__ap, __fmt);
-	libsimple_veprintf(__fmt, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, fmt__);
+	libsimple_veprintf(fmt__, ap__);
+	va_end(ap__);
 }
 #ifndef eprintf
 # define eprintf libsimple_eprintf
diff --git a/libsimple/pvalloc.h b/libsimple/pvalloc.h
index 78deb1a..bc23e85 100644
--- a/libsimple/pvalloc.h
+++ b/libsimple/pvalloc.h
@@ -21,9 +21,12 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *libsimple_vpvallocn(size_t __n, va_list __ap)
-{ return libsimple_vpvalloczn(0, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_vpvallocn(size_t n__, va_list ap__)
+{
+	return libsimple_vpvalloczn(0, n__, ap__);
+}
 #ifndef vpvallocn
 # define vpvallocn libsimple_vpvallocn
 #endif
@@ -43,9 +46,12 @@ static inline void *libsimple_vpvallocn(size_t __n, va_list __ap)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *libsimple_pvalloc(size_t __n)
-{ return libsimple_pvallocz(0, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_pvalloc(size_t n__)
+{
+	return libsimple_pvallocz(0, n__);
+}
 #ifndef pvalloc
 # define pvalloc libsimple_pvalloc
 #endif
@@ -71,14 +77,14 @@ static inline void *libsimple_pvalloc(size_t __n)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_pvallocn(size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_pvallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vpvallocn(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vpvallocn(n__, ap__);
+	va_end(ap__);
 }
 #ifndef pvallocn
 # define pvallocn libsimple_pvallocn
@@ -103,9 +109,12 @@ libsimple_pvallocn(size_t __n, ... /*, (size_t)0 */)
  *                  rounded up to the next multiple of the page size,
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_enpvalloc(int __status, size_t __n)
-{ return libsimple_enpvallocz(__status, 0, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_enpvalloc(int status__, size_t n__)
+{
+	return libsimple_enpvallocz(status__, 0, n__);
+}
 #ifndef enpvalloc
 # define enpvalloc libsimple_enpvalloc
 #endif
@@ -134,9 +143,12 @@ static inline void *libsimple_enpvalloc(int __status, size_t __n)
  *                  rounded up to the next multiple of the page size,
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envpvallocn(int __status, size_t __n, va_list __ap)
-{ return libsimple_envpvalloczn(__status, 0, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_envpvallocn(int status__, size_t n__, va_list ap__)
+{
+	return libsimple_envpvalloczn(status__, 0, n__, ap__);
+}
 #ifndef envpvallocn
 # define envpvallocn libsimple_envpvallocn
 #endif
@@ -165,14 +177,14 @@ static inline void *libsimple_envpvallocn(int __status, size_t __n, va_list __ap
  *                  rounded up to the next multiple of the page size,
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_enpvallocn(int __status, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_enpvallocn(int status__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envpvalloczn(__status, 0, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envpvalloczn(status__, 0, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enpvallocn
 # define enpvallocn libsimple_enpvallocn
@@ -196,9 +208,12 @@ libsimple_enpvallocn(int __status, size_t __n, ... /*, (size_t)0 */)
  *             rounded up to the next multiple of the page size,
  *             and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_epvalloc(size_t __n)
-{ return libsimple_enpvalloc(libsimple_default_failure_exit, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_epvalloc(size_t n__)
+{
+	return libsimple_enpvalloc(libsimple_default_failure_exit, n__);
+}
 #ifndef epvalloc
 # define epvalloc libsimple_epvalloc
 #endif
@@ -226,9 +241,12 @@ static inline void *libsimple_epvalloc(size_t __n)
  *              rounded up to the next multiple of the page size,
  *              and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evpvallocn(size_t __n, va_list __ap)
-{ return libsimple_envpvallocn(libsimple_default_failure_exit, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_evpvallocn(size_t n__, va_list ap__)
+{
+	return libsimple_envpvallocn(libsimple_default_failure_exit, n__, ap__);
+}
 #ifndef evpvallocn
 # define evpvallocn libsimple_evpvallocn
 #endif
@@ -256,14 +274,14 @@ static inline void *libsimple_evpvallocn(size_t __n, va_list __ap)
  *               rounded up to the next multiple of the page size,
  *               and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_epvallocn(size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_epvallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evpvallocn(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evpvallocn(n__, ap__);
+	va_end(ap__);
 }
 #ifndef epvallocn
 # define epvallocn libsimple_epvallocn
diff --git a/libsimple/pvallocz.h b/libsimple/pvallocz.h
index a61f80b..6b4eaf6 100644
--- a/libsimple/pvallocz.h
+++ b/libsimple/pvallocz.h
@@ -22,12 +22,12 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_vpvalloczn(int __clear, size_t __n, va_list __ap)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_vpvalloczn(int clear__, size_t n__, va_list ap__)
 {
-	return libsimple_memalloc(0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, __n, __ap,
-	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_memalloc(0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, n__, ap__,
+	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                          LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                          LIBSIMPLE_MEMALLOC_ROUND_UP_SIZE_TO_ALIGNMENT,
 	                          LIBSIMPLE_MEMALLOC_END);
@@ -52,12 +52,12 @@ libsimple_vpvalloczn(int __clear, size_t __n, va_list __ap)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__)))
-static inline void *
-libsimple_pvallocz(int __clear, size_t __n)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__)))
+inline void *
+libsimple_pvallocz(int clear__, size_t n__)
 {
-	return libsimple_memalloc(__n,
-	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_memalloc(n__,
+	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                          LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                          LIBSIMPLE_MEMALLOC_ROUND_UP_SIZE_TO_ALIGNMENT,
 	                          LIBSIMPLE_MEMALLOC_END);
@@ -88,14 +88,14 @@ libsimple_pvallocz(int __clear, size_t __n)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_pvalloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_pvalloczn(int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vpvalloczn(__clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vpvalloczn(clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef pvalloczn
 # define pvalloczn libsimple_pvalloczn
@@ -121,12 +121,12 @@ libsimple_pvalloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
  *                  rounded up to the next multiple of the page size,
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_enpvallocz(int __status, int __clear, size_t __n)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_enpvallocz(int status__, int clear__, size_t n__)
 {
-	return libsimple_enmemalloc(__status, __n,
-	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_enmemalloc(status__, n__,
+	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                            LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                            LIBSIMPLE_MEMALLOC_ROUND_UP_SIZE_TO_ALIGNMENT,
 	                            LIBSIMPLE_MEMALLOC_END);
@@ -161,13 +161,13 @@ libsimple_enpvallocz(int __status, int __clear, size_t __n)
  *                  rounded up to the next multiple of the page size,
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_envpvalloczn(int __status, int __clear, size_t __n, va_list __ap)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_envpvalloczn(int status__, int clear__, size_t n__, va_list ap__)
 {
-	return libsimple_enmemalloc(__status,
-	                            0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, __n, __ap,
-	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_enmemalloc(status__,
+	                            0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, n__, ap__,
+	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                            LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                            LIBSIMPLE_MEMALLOC_ROUND_UP_SIZE_TO_ALIGNMENT,
 	                            LIBSIMPLE_MEMALLOC_END);
@@ -202,14 +202,14 @@ libsimple_envpvalloczn(int __status, int __clear, size_t __n, va_list __ap)
  *                  rounded up to the next multiple of the page size,
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_enpvalloczn(int __status, int __clear, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_enpvalloczn(int status__, int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envpvalloczn(__status, __clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envpvalloczn(status__, clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enpvalloczn
 # define enpvalloczn libsimple_enpvalloczn
@@ -234,9 +234,12 @@ libsimple_enpvalloczn(int __status, int __clear, size_t __n, ... /*, (size_t)0 *
  *                 rounded up to the next multiple of the page size,
  *                 and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_epvallocz(int __clear, size_t __n)
-{ return libsimple_enpvallocz(libsimple_default_failure_exit, __clear, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_epvallocz(int clear__, size_t n__)
+{
+	return libsimple_enpvallocz(libsimple_default_failure_exit, clear__, n__);
+}
 #ifndef epvallocz
 # define epvallocz libsimple_epvallocz
 #endif
@@ -265,9 +268,12 @@ static inline void *libsimple_epvallocz(int __clear, size_t __n)
  *                 rounded up to the next multiple of the page size,
  *                 and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evpvalloczn(int __clear, size_t __n, va_list __ap)
-{ return libsimple_envpvalloczn(libsimple_default_failure_exit, __clear, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_evpvalloczn(int clear__, size_t n__, va_list ap__)
+{
+	return libsimple_envpvalloczn(libsimple_default_failure_exit, clear__, n__, ap__);
+}
 #ifndef evpvalloczn
 # define evpvalloczn libsimple_evpvalloczn
 #endif
@@ -296,14 +302,14 @@ static inline void *libsimple_evpvalloczn(int __clear, size_t __n, va_list __ap)
  *                 rounded up to the next multiple of the page size,
  *                 and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_epvalloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_epvalloczn(int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evpvalloczn(__clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evpvalloczn(clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef epvalloczn
 # define epvalloczn libsimple_epvalloczn
diff --git a/libsimple/realloc.h b/libsimple/realloc.h
index b02c08a..4f780d5 100644
--- a/libsimple/realloc.h
+++ b/libsimple/realloc.h
@@ -26,7 +26,7 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__)))
 void *libsimple_vreallocn(void *, size_t, va_list);
 #ifndef vreallocn
 # define vreallocn libsimple_vreallocn
@@ -58,14 +58,14 @@ void *libsimple_vreallocn(void *, size_t, va_list);
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__)))
-static inline void *
-libsimple_reallocn(void *__ptr, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__)))
+inline void *
+libsimple_reallocn(void *ptr__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vreallocn(__ptr, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vreallocn(ptr__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef reallocn
 # define reallocn libsimple_reallocn
@@ -95,7 +95,7 @@ libsimple_reallocn(void *__ptr, size_t __n, ... /*, (size_t)0 */)
  *                  the specified size and with the alignment
  *                  `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enrealloc(int, void *, size_t);
 #ifndef enrealloc
 # define enrealloc libsimple_enrealloc
@@ -130,7 +130,7 @@ void *libsimple_enrealloc(int, void *, size_t);
  *                  the specified size and with the alignment
  *                  `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__, __returns_nonnull__)))
 void *libsimple_envreallocn(int, void *, size_t, va_list);
 #ifndef envreallocn
 # define envreallocn libsimple_envreallocn
@@ -165,14 +165,14 @@ void *libsimple_envreallocn(int, void *, size_t, va_list);
  *                  the specified size and with the alignment
  *                  `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_enreallocn(int __status, void *__ptr, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_enreallocn(int status__, void *ptr__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envreallocn(__status, __ptr, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envreallocn(status__, ptr__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef enreallocn
 # define enreallocn libsimple_enreallocn
@@ -201,9 +201,12 @@ libsimple_enreallocn(int __status, void *__ptr, size_t __n, ... /*, (size_t)0 */
  *               the specified size and with the alignment
  *               `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_erealloc(void *__ptr, size_t __n)
-{ return libsimple_enrealloc(libsimple_default_failure_exit, __ptr, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_erealloc(void *ptr__, size_t n__)
+{
+	return libsimple_enrealloc(libsimple_default_failure_exit, ptr__, n__);
+}
 #ifndef erealloc
 # define erealloc libsimple_erealloc
 #endif
@@ -236,9 +239,12 @@ static inline void *libsimple_erealloc(void *__ptr, size_t __n)
  *               the specified size and with the alignment
  *               `alignof(max_align_t)`
  */
-_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__)))
+inline void *
+libsimple_evreallocn(void *ptr__, size_t n__, va_list ap__)
+{
+	return libsimple_envreallocn(libsimple_default_failure_exit, ptr__, n__, ap__);
+}
 #ifndef evreallocn
 # define evreallocn libsimple_evreallocn
 #endif
@@ -271,14 +277,14 @@ static inline void *libsimple_evreallocn(void *__ptr, size_t __n, va_list __ap)
  *               the specified size and with the alignment
  *               `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_ereallocn(void *__ptr, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_ereallocn(void *ptr__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evreallocn(__ptr, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evreallocn(ptr__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef ereallocn
 # define ereallocn libsimple_ereallocn
@@ -307,14 +313,14 @@ libsimple_ereallocn(void *__ptr, size_t __n, ... /*, (size_t)0 */)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2), __warn_unused_result__)))
-static inline void *
-libsimple_reallocf(void *__ptr, size_t __n) /* TODO test */
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2), __warn_unused_result__)))
+inline void *
+libsimple_reallocf(void *ptr__, size_t n__)
 {
-	void *__new = __n ? realloc(__ptr, __n) : NULL;
-	if (!__new)
-		free(__ptr);
-	return __new;
+	void *new__ = n__ ? realloc(ptr__, n__) : NULL;
+	if (!new__)
+		free(ptr__);
+	return new__;
 }
 #ifndef reallocf
 # define reallocf libsimple_reallocf
@@ -345,15 +351,15 @@ libsimple_reallocf(void *__ptr, size_t __n) /* TODO test */
  * @throws  EINVAL  `n` or `m` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2, 3), __warn_unused_result__)))
-static inline void *
-libsimple_reallocarray(void *__ptr, size_t __n, size_t __m)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2, 3), __warn_unused_result__)))
+inline void *
+libsimple_reallocarray(void *ptr__, size_t n__, size_t m__)
 {
-	if (LIBSIMPLE_UMUL_OVERFLOW(__n, __m, &__n, SIZE_MAX)) {
+	if (LIBSIMPLE_UMUL_OVERFLOW(n__, m__, &n__, SIZE_MAX)) {
 		errno = ENOMEM;
 		return NULL;
 	}
-	return realloc(__ptr, __n);
+	return realloc(ptr__, n__);
 }
 #ifndef reallocarray
 # define reallocarray libsimple_reallocarray
@@ -386,7 +392,7 @@ libsimple_reallocarray(void *__ptr, size_t __n, size_t __m)
  *               the specified size and with the alignment
  *               `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(3, 4), __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(3, 4), __warn_unused_result__, __returns_nonnull__)))
 void *libsimple_enreallocarray(int, void *, size_t, size_t);
 #ifndef enreallocarray
 # define enreallocarray libsimple_enreallocarray
@@ -419,9 +425,12 @@ void *libsimple_enreallocarray(int, void *, size_t, size_t);
  *               the specified size and with the alignment
  *               `alignof(max_align_t)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_ereallocarray(void *__ptr, size_t __n, size_t __m)
-{ return libsimple_enreallocarray(libsimple_default_failure_exit, __ptr, __n, __m); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_ereallocarray(void *ptr__, size_t n__, size_t m__)
+{
+	return libsimple_enreallocarray(libsimple_default_failure_exit, ptr__, n__, m__);
+}
 #ifndef ereallocarray
 # define ereallocarray libsimple_ereallocarray
 #endif
@@ -451,14 +460,14 @@ static inline void *libsimple_ereallocarray(void *__ptr, size_t __n, size_t __m)
  * @throws  EINVAL  `n` or `m` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__alloc_size__(2, 3), __warn_unused_result__)))
-static inline void *
-libsimple_reallocarrayf(void *__ptr, size_t __n, size_t __m) /* TODO test */
+LIBSIMPLE_GCC_ONLY__(__attribute__((__alloc_size__(2, 3), __warn_unused_result__)))
+inline void *
+libsimple_reallocarrayf(void *ptr__, size_t n__, size_t m__)
 {
-	void *__new = __n ? libsimple_reallocarray(__ptr, __n, __m) : NULL;
-	if (!__new)
-		free(__ptr);
-	return __new;
+	void *new__ = n__ ? libsimple_reallocarray(ptr__, n__, m__) : NULL;
+	if (!new__)
+		free(ptr__);
+	return new__;
 }
 #ifndef reallocarrayf
 # define reallocarrayf libsimple_reallocarrayf
@@ -490,14 +499,14 @@ libsimple_reallocarrayf(void *__ptr, size_t __n, size_t __m) /* TODO test */
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__)))
-static inline void *
-libsimple_vreallocfn(void *__ptr, size_t __n, va_list __ap) /* TODO test (reallocfn) */
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__)))
+inline void *
+libsimple_vreallocfn(void *ptr__, size_t n__, va_list ap__)
 {
-	void *__new = libsimple_vreallocn(__ptr, __n, __ap);
-	if (!__new)
-		free(__ptr);
-	return __new;
+	void *new__ = libsimple_vreallocn(ptr__, n__, ap__);
+	if (!new__)
+		free(ptr__);
+	return new__;
 }
 #ifndef vreallocfn
 # define vreallocfn libsimple_vreallocfn
@@ -529,14 +538,14 @@ libsimple_vreallocfn(void *__ptr, size_t __n, va_list __ap) /* TODO test (reallo
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__warn_unused_result__)))
-static inline void *
-libsimple_reallocfn(void *__ptr, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__)))
+inline void *
+libsimple_reallocfn(void *ptr__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vreallocfn(__ptr, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vreallocfn(ptr__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef reallocfn
 # define reallocfn libsimple_reallocfn
diff --git a/libsimple/str.h b/libsimple/str.h
index 4bf5793..d01086e 100644
--- a/libsimple/str.h
+++ b/libsimple/str.h
@@ -9,7 +9,7 @@
  * @return     `s` with a minimal offset such that `*r == c || !*r`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strchrnul(const char *, int);
 #ifndef strchrnul
 # define strchrnul libsimple_strchrnul
@@ -24,7 +24,7 @@ char *libsimple_strchrnul(const char *, int);
  * @return     `s` with a minimal offset such that `tolower(*r) == tolower(c)`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strcasechr(const char *, int);
 #ifndef strcasechr
 # define strcasechr libsimple_strcasechr
@@ -39,7 +39,7 @@ char *libsimple_strcasechr(const char *, int);
  * @return     `s` with a minimal offset such that `tolower(*r) == tolower(c) || !*r`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strcasechrnul(const char *, int);
 #ifndef strcasechrnul
 # define strcasechrnul libsimple_strcasechrnul
@@ -54,7 +54,7 @@ char *libsimple_strcasechrnul(const char *, int);
  * @return     `s` with a maximal offset such that `tolower(*r) == tolower(c)`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrcasechr(const char *, int);
 #ifndef strrcasechr
 # define strrcasechr libsimple_strrcasechr
@@ -70,7 +70,7 @@ char *libsimple_strrcasechr(const char *, int);
  * @return     `s` with a minimal offset such that `*r != c`, where `r`
  *             is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strchr_inv(const char *, int);
 #ifndef strchr_inv
 # define strchr_inv libsimple_strchr_inv
@@ -86,7 +86,7 @@ char *libsimple_strchr_inv(const char *, int);
  * @return     `s` with a minimal offset such that `*r != c || !*r`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strchrnul_inv(const char *, int);
 #ifndef strchrnul_inv
 # define strchrnul_inv libsimple_strchrnul_inv
@@ -102,7 +102,7 @@ char *libsimple_strchrnul_inv(const char *, int);
  * @return     `s` with a minimal offset such that `tolower(*r) != tolower(c)`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strcasechr_inv(const char *, int);
 #ifndef strcasechr_inv
 # define strcasechr_inv libsimple_strcasechr_inv
@@ -118,7 +118,7 @@ char *libsimple_strcasechr_inv(const char *, int);
  * @return     `s` with a minimal offset such that `tolower(*r) != tolower(c) || !*r`,
  *             where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strcasechrnul_inv(const char *, int);
 #ifndef strcasechrnul_inv
 # define strcasechrnul_inv libsimple_strcasechrnul_inv
@@ -134,7 +134,7 @@ char *libsimple_strcasechrnul_inv(const char *, int);
  * @return     `s` with a maximal offset such that `*r != c`, where `r`
  *             is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrchr_inv(const char *, int);
 #ifndef strrchr_inv
 # define strrchr_inv libsimple_strrchr_inv
@@ -150,7 +150,7 @@ char *libsimple_strrchr_inv(const char *, int);
  * @return     `s` with a maximal offset such that `tolower(*r) != tolower(c)`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrcasechr_inv(const char *, int);
 #ifndef strrcasechr_inv
 # define strrcasechr_inv libsimple_strrcasechr_inv
@@ -163,9 +163,12 @@ char *libsimple_strrcasechr_inv(const char *, int);
  * @param   s  The string
  * @return     `s` with an offset such `!*r`, where `r` is the returned pointer
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline char *libsimple_strend(const char *__s)
-{ return strchr(__s, '\0'); }
+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
@@ -178,7 +181,7 @@ static inline char *libsimple_strend(const char *__s)
  * @param   t  The string `s` should begin with
  * @return     1 if `s` starts with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strstarts(const char *, const char *);
 #ifndef strstarts
 # define strstarts libsimple_strstarts
@@ -192,9 +195,12 @@ int libsimple_strstarts(const char *, const char *);
  * @param   t  The string `s` should begin with
  * @return     1 if `s` starts with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_strcasestarts(const char *__s, const char *__t)
-{ return !strncasecmp(__s, __t, strlen(__t)); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_strcasestarts(const char *s__, const char *t__)
+{
+	return !strncasecmp(s__, t__, strlen(t__));
+}
 #ifndef strcasestarts
 # define strcasestarts libsimple_strcasestarts
 #endif
@@ -207,7 +213,7 @@ static inline int libsimple_strcasestarts(const char *__s, const char *__t)
  * @param   t  The string `s` should begin with
  * @return     1 if `s` ends with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strends(const char *, const char *);
 #ifndef strends
 # define strends libsimple_strends
@@ -221,7 +227,7 @@ int libsimple_strends(const char *, const char *);
  * @param   t  The string `s` should begin with
  * @return     1 if `s` end with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strcaseends(const char *, const char *);
 #ifndef strcaseends
 # define strcaseends libsimple_strcaseends
@@ -237,7 +243,7 @@ int libsimple_strcaseends(const char *, const char *);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrstr(const char *, const char *);
 #ifndef strrstr
 # define strrstr libsimple_strrstr
@@ -253,7 +259,7 @@ char *libsimple_strrstr(const char *, const char *);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strcasestr(const char *, const char *);
 #ifndef strcasestr
 # define strcasestr libsimple_strcasestr
@@ -269,7 +275,7 @@ char *libsimple_strcasestr(const char *, const char *);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrcasestr(const char *, const char *);
 #ifndef strrcasestr
 # define strrcasestr libsimple_strrcasestr
@@ -286,9 +292,12 @@ char *libsimple_strrcasestr(const char *, const char *);
  *             a positive value if `a` is greater than `b`,
  *             0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strcmpnul(const char *__a, const char *__b)
-{ return (!__a || !__b) ? !__b - !__a : strcmp(__a, __b); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strcmpnul(const char *a__, const char *b__)
+{
+	return (!a__ || !b__) ? !b__ - !a__ : strcmp(a__, b__);
+}
 #ifndef strcmpnul
 # define strcmpnul libsimple_strcmpnul
 #endif
@@ -304,9 +313,12 @@ static inline int libsimple_strcmpnul(const char *__a, const char *__b)
  *             a positive value if `a` is greater than `b`,
  *             0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strcasecmpnul(const char *__a, const char *__b)
-{ return (!__a || !__b) ? !__b - !__a : strcasecmp(__a, __b); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strcasecmpnul(const char *a__, const char *b__)
+{
+	return (!a__ || !b__) ? !b__ - !a__ : strcasecmp(a__, b__);
+}
 #ifndef strcasecmpnul
 # define strcasecmpnul libsimple_strcasecmpnul
 #endif
@@ -320,9 +332,12 @@ static inline int libsimple_strcasecmpnul(const char *__a, const char *__b)
  * @param   b  The other string, may not be `NULL`
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_streq(const char *__a, const char *__b)
-{ return !strcmp(__a, __b); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_streq(const char *a__, const char *b__)
+{
+	return !strcmp(a__, b__);
+}
 #ifndef streq
 # define streq libsimple_streq
 #endif
@@ -336,9 +351,12 @@ static inline int libsimple_streq(const char *__a, const char *__b)
  * @param   b  The other string, may be `NULL`
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_streqnul(const char *__a, const char *__b)
-{ return !libsimple_strcmpnul(__a, __b); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_streqnul(const char *a__, const char *b__)
+{
+	return !libsimple_strcmpnul(a__, b__);
+}
 #ifndef streqnul
 # define streqnul libsimple_streqnul
 #endif
@@ -352,9 +370,12 @@ static inline int libsimple_streqnul(const char *__a, const char *__b)
  * @param   b  The other string, may not be `NULL`
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_strcaseeq(const char *__a, const char *__b)
-{ return !strcasecmp(__a, __b); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_strcaseeq(const char *a__, const char *b__)
+{
+	return !strcasecmp(a__, b__);
+}
 #ifndef strcaseeq
 # define strcaseeq libsimple_strcaseeq
 #endif
@@ -368,9 +389,12 @@ static inline int libsimple_strcaseeq(const char *__a, const char *__b)
  * @param   b  The other string, may be `NULL`
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strcaseeqnul(const char *__a, const char *__b)
-{ return !libsimple_strcasecmpnul(__a, __b); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strcaseeqnul(const char *a__, const char *b__)
+{
+	return !libsimple_strcasecmpnul(a__, b__);
+}
 #ifndef strcaseeqnul
 # define strcaseeqnul libsimple_strcaseeqnul
 #endif
@@ -384,7 +408,7 @@ static inline int libsimple_strcaseeqnul(const char *__a, const char *__b)
  * @return     The number of bytes `a` and `b` have
  *             in common in their beginnings
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 size_t libsimple_streqlen(const char *, const char *);
 #ifndef streqlen
 # define streqlen libsimple_streqlen
@@ -399,7 +423,7 @@ size_t libsimple_streqlen(const char *, const char *);
  * @return     The number of bytes `a` and `b` have
  *             in common in their beginnings
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 size_t libsimple_strcaseeqlen(const char *, const char *);
 #ifndef strcaseeqlen
 # define strcaseeqlen libsimple_strcaseeqlen
@@ -414,9 +438,12 @@ size_t libsimple_strcaseeqlen(const char *, const char *);
  * @return     The number of bytes `a` and `b` have
  *             in common in their ends
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline size_t libsimple_strreqlen(const char *__a, const char *__b)
-{ return libsimple_memreqlen(__a, strlen(__a), __b, strlen(__b)); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline size_t
+libsimple_strreqlen(const char *a__, const char *b__)
+{
+	return libsimple_memreqlen(a__, strlen(a__), b__, strlen(b__));
+}
 #ifndef strreqlen
 # define strreqlen libsimple_strreqlen
 #endif
@@ -430,9 +457,12 @@ static inline size_t libsimple_strreqlen(const char *__a, const char *__b)
  * @return     The number of bytes `a` and `b` have
  *             in common in their ends
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline size_t libsimple_strrcaseeqlen(const char *__a, const char *__b)
-{ return libsimple_memrcaseeqlen(__a, strlen(__a), __b, strlen(__b)); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline size_t
+libsimple_strrcaseeqlen(const char *a__, const char *b__)
+{
+	return libsimple_memrcaseeqlen(a__, strlen(a__), b__, strlen(b__));
+}
 #ifndef strrcaseeqlen
 # define strrcaseeqlen libsimple_strrcaseeqlen
 #endif
@@ -446,9 +476,12 @@ static inline size_t libsimple_strrcaseeqlen(const char *__a, const char *__b)
  * @return     1 if the byte `c` is not the NUL byte and can be found in `s`,
  *             0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_inchrset(int __c, const char *__s)
-{ return __c && strchr(__s, __c); }
+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
@@ -462,9 +495,12 @@ static inline int libsimple_inchrset(int __c, const char *__s)
  * @return     1 if the byte `c` is not the NUL byte and can be found in `s`,
  *             0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_inchrcaseset(int __c, const char *__s)
-{ return __c && strcasechr(__s, __c); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_inchrcaseset(int c__, const char *s__)
+{
+	return c__ && strcasechr(s__, c__);
+}
 #ifndef inchrcaseset
 # define inchrcaseset libsimple_inchrcaseset
 #endif
@@ -478,9 +514,12 @@ static inline int libsimple_inchrcaseset(int __c, const char *__s)
  * @param   s  The string to move
  * @return     `d`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
-static inline char *libsimple_strmove(char *__d, const char *__s)
-{ return memmove(__d, __s, strlen(__s) + 1); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
+static inline char *
+libsimple_strmove(char *d__, const char *s__)
+{
+	return memmove(d__, s__, strlen(s__) + 1);
+}
 #ifndef strmove
 # define strmove libsimple_strmove
 #endif
@@ -494,9 +533,14 @@ static inline char *libsimple_strmove(char *__d, const char *__s)
  * @param   s  The string to move
  * @return     `&d[strlen(s)]` (this byte will be a NUL byte)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
-static inline char *libsimple_stpmove(char *__d, const char *__s)
-{ size_t __n = strlen(__s); memmove(__d, __s, __n + 1); return &__d[__n]; }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
+static inline char *
+libsimple_stpmove(char *d__, const char *s__)
+{
+	size_t n__ = strlen(s__);
+	memmove(d__, s__, n__ + 1);
+	return &d__[n__];
+}
 #ifndef stpmove
 # define stpmove libsimple_stpmove
 #endif
@@ -509,13 +553,13 @@ static inline char *libsimple_stpmove(char *__d, const char *__s)
  * @param   c  The byte to replace all bytes in `s` with
  * @return     `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_strset(char *__s, int __c_)
+libsimple_strset(char *s__, int c___)
 {
-	char __c = (char)__c_, *__r = __s;
-	while (*__s) *__s++ = __c;
-	return __r;
+	char c__ = (char)c___, *r__ = s__;
+	while (*s__) *s__++ = c__;
+	return r__;
 }
 #ifndef strset
 # define strset libsimple_strset
@@ -529,13 +573,13 @@ libsimple_strset(char *__s, int __c_)
  * @param   c  The byte to replace all bytes in `s` with
  * @return     `&s[strlen(s)]`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_stpset(char *__s, int __c_)
+libsimple_stpset(char *s__, int c___)
 {
-	char __c = (char)__c_;
-	while (*__s) *__s++ = __c;
-	return __s;
+	char c__ = (char)c___;
+	while (*s__) *s__++ = c__;
+	return s__;
 }
 #ifndef stpset
 # define stpset libsimple_stpset
@@ -552,15 +596,17 @@ libsimple_stpset(char *__s, int __c_)
  * @return     `&strchr(d, c)[1]` (after copying) if `c` can be
  *             found in `s`, `NULL` otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_strccpy(char *restrict __d, const char *restrict __s, int __c_)
+libsimple_strccpy(char *restrict d__, const char *restrict s__, int c___)
 {
-	char __c = (char)__c_;
+	char c__ = (char)c___;
 	do {
-		if ((*__d++ = *__s) == __c)
-			return *__d = '\0', __d;
-	} while (*__s++);
+		if ((*d__++ = *s__) == c__) {
+			*d__ = '\0';
+			return d__;
+		}
+	} while (*s__++);
 	return NULL;
 }
 #ifndef strccpy
@@ -577,7 +623,7 @@ libsimple_strccpy(char *restrict __d, const char *restrict __s, int __c_)
  * @return     `&strchr(d, c)[1]` (after copying) if `c` can be
  *             found in `s` (before copying), `NULL` otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 char *libsimple_strcmove(char *, const char *, int);
 #ifndef strcmove
 # define strcmove libsimple_strcmove
@@ -593,15 +639,15 @@ char *libsimple_strcmove(char *, const char *, int);
  * @param   new  The value to replace the characters with
  * @return       `strchr(s, '\0')`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
 static inline char *
-libsimple_strreplace(char *__s, int __old_, int __new_)
+libsimple_strreplace(char *s__, int old___, int new___)
 {
-	char __old = (char)__old_, __new = (char)__new_;
-	for (; *__s; __s++)
-		if (*__s == __old)
-			*__s = __new;
-	return __s;
+	char old__ = (char)old___, new__ = (char)new___;
+	for (; *s__; s__++)
+		if (*s__ == old__)
+			*s__ = new__;
+	return s__;
 }
 #ifndef strreplace
 # define strreplace libsimple_strreplace
@@ -620,7 +666,7 @@ libsimple_strreplace(char *__s, int __old_, int __new_)
  * @param   s  The string to copy
  * @return     `strchr(d, '\0')` (after copying)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
 char *libsimple_stptolower(char *, const char *);
 #ifndef stptolower
 # define stptolower libsimple_stptolower
@@ -639,7 +685,7 @@ char *libsimple_stptolower(char *, const char *);
  * @param   s  The string to copy
  * @return     `strchr(d, '\0')` (after copying)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
 char *libsimple_stptoupper(char *, const char *);
 #ifndef stptoupper
 # define stptoupper libsimple_stptoupper
@@ -658,9 +704,13 @@ char *libsimple_stptoupper(char *, const char *);
  * @param   s  The string to copy
  * @return     `d`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
-static inline char *libsimple_strtolower(char *__d, const char *__s)
-{ libsimple_stptolower(__d, __s); return __d; }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
+static inline char *
+libsimple_strtolower(char *d__, const char *s__)
+{
+	libsimple_stptolower(d__, s__);
+	return d__;
+}
 #ifndef strtolower
 # define strtolower libsimple_strtolower
 #endif
@@ -678,9 +728,13 @@ static inline char *libsimple_strtolower(char *__d, const char *__s)
  * @param   s  The string to copy
  * @return     `d`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
-static inline char *libsimple_strtoupper(char *__d, const char *__s)
-{ libsimple_stptoupper(__d, __s); return __d; }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
+static inline char *
+libsimple_strtoupper(char *d__, const char *s__)
+{
+	libsimple_stptoupper(d__, s__);
+	return d__;
+}
 #ifndef strtoupper
 # define strtoupper libsimple_strtoupper
 #endif
@@ -694,9 +748,12 @@ static inline char *libsimple_strtoupper(char *__d, const char *__s)
  *                              allows a two-byte encoding for NUL
  * @return                      1 if good, 0 on encoding error
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_strisutf8(const char *__string, int __allow_modified_nul)
-{ return libsimple_memisutf8(__string, strlen(__string) ,__allow_modified_nul); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_strisutf8(const char *string__, int allow_modified_nul__)
+{
+	return libsimple_memisutf8(string__, strlen(string__), allow_modified_nul__);
+}
 #ifndef strisutf8
 # define strisutf8 libsimple_strisutf8
 #endif
diff --git a/libsimple/strdup.h b/libsimple/strdup.h
index a826414..cc3b67a 100644
--- a/libsimple/strdup.h
+++ b/libsimple/strdup.h
@@ -9,11 +9,12 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_strdupa(s)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__s = (s);\
-		size_t __n = strlen(__s) + 1;\
-		char *__r = alloca(__n);\
-		memcpy(__r, __s, __n);\
+		const char *s__ = (s);\
+		size_t n__ = strlen(s__) + 1;\
+		char *r__ = alloca(n__);\
+		memcpy(r__, s__, n__);\
 	})
 # ifndef strdupa
 #  define strdupa(s) libsimple_strdupa(s)
@@ -28,7 +29,7 @@
  * @param   s       The string to copy
  * @return          Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 char *libsimple_enstrdup(int, const char *);
 #ifndef enstrdup
 # define enstrdup libsimple_enstrdup
@@ -41,11 +42,11 @@ char *libsimple_enstrdup(int, const char *);
  * @param   s  The string to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline char *
-libsimple_estrdup(const char *__s)
+libsimple_estrdup(const char *s__)
 {
-	return libsimple_enstrdup(libsimple_default_failure_exit, __s);
+	return libsimple_enstrdup(libsimple_default_failure_exit, s__);
 }
 #ifndef estrdup
 # define estrdup libsimple_estrdup
diff --git a/libsimple/strn.h b/libsimple/strn.h
index aa8a889..8d10fff 100644
--- a/libsimple/strn.h
+++ b/libsimple/strn.h
@@ -11,7 +11,7 @@
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  *             within the first `n` bytes
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strnchr(const char *, int, size_t);
 #ifndef strnchr
 # define strnchr libsimple_strnchr
@@ -28,7 +28,7 @@ char *libsimple_strnchr(const char *, int, size_t);
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  *             within the first `n` bytes
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strncasechr(const char *, int, size_t);
 #ifndef strncasechr
 # define strncasechr libsimple_strncasechr
@@ -45,7 +45,7 @@ char *libsimple_strncasechr(const char *, int, size_t);
  *             where `r` is the returned pointer, however if no such
  *             offset exists within the first `n` bytes, `&s[n]` is returned
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strnchrnul(const char *, int, size_t);
 #ifndef strnchrnul
 # define strnchrnul libsimple_strnchrnul
@@ -62,7 +62,7 @@ char *libsimple_strnchrnul(const char *, int, size_t);
  *             where `r` is the returned pointer, however if no such offset
  *             exists within the first `n` bytes, `&s[n]` is returned
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strncasechrnul(const char *, int, size_t);
 #ifndef strncasechrnul
 # define strncasechrnul libsimple_strncasechrnul
@@ -78,7 +78,7 @@ char *libsimple_strncasechrnul(const char *, int, size_t);
  * @return     `s` with a maximal offset such that `*r == c`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrnchr(const char *, int, size_t);
 #ifndef strrnchr
 # define strrnchr libsimple_strrnchr
@@ -95,7 +95,7 @@ char *libsimple_strrnchr(const char *, int, size_t);
  * @return     `s` with a maximal offset such that `tolower(*r) == tolower(c)`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrncasechr(const char *, int, size_t);
 #ifndef strrncasechr
 # define strrncasechr libsimple_strrncasechr
@@ -113,7 +113,7 @@ char *libsimple_strrncasechr(const char *, int, size_t);
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  *             within the first `n` bytes
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strnchr_inv(const char *, int, size_t);
 #ifndef strnchr_inv
 # define strnchr_inv libsimple_strnchr_inv
@@ -131,7 +131,7 @@ char *libsimple_strnchr_inv(const char *, int, size_t);
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  *             within the first `n` bytes
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strncasechr_inv(const char *, int, size_t);
 #ifndef strncasechr_inv
 # define strncasechr_inv libsimple_strncasechr_inv
@@ -149,7 +149,7 @@ char *libsimple_strncasechr_inv(const char *, int, size_t);
  *             where `r` is the returned pointer, however if no such
  *             offset exists within the first `n` bytes, `&s[n]` is returned
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strnchrnul_inv(const char *, int, size_t);
 #ifndef strnchrnul_inv
 # define strnchrnul_inv libsimple_strnchrnul_inv
@@ -167,7 +167,7 @@ char *libsimple_strnchrnul_inv(const char *, int, size_t);
  *             where `r` is the returned pointer, however if no such offset
  *             exists within the first `n` bytes, `&s[n]` is returned
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strncasechrnul_inv(const char *, int, size_t);
 #ifndef strncasechrnul_inv
 # define strncasechrnul_inv libsimple_strncasechrnul_inv
@@ -184,7 +184,7 @@ char *libsimple_strncasechrnul_inv(const char *, int, size_t);
  * @return     `s` with a maximal offset such that `*r != c`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrnchr_inv(const char *, int, size_t);
 #ifndef strrnchr_inv
 # define strrnchr_inv libsimple_strrnchr_inv
@@ -201,7 +201,7 @@ char *libsimple_strrnchr_inv(const char *, int, size_t);
  * @return     `s` with a maximal offset such that `tolower(*r) != tolower(c)`,
  *             where `r` is the returned pointer, `NULL` if no such offset exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrncasechr_inv(const char *, int, size_t);
 #ifndef strrncasechr_inv
 # define strrncasechr_inv libsimple_strrncasechr_inv
@@ -218,7 +218,7 @@ char *libsimple_strrncasechr_inv(const char *, int, size_t);
  *             is not NUL byte within the first `n` bytes
  *             if `s`, `&s[n]` is returned
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __returns_nonnull__, __warn_unused_result__)))
 char *libsimple_strnend(const char *, size_t);
 #ifndef strnend
 # define strnend libsimple_strnend
@@ -233,7 +233,7 @@ char *libsimple_strnend(const char *, size_t);
  * @param   n  Truncate `s` to this length if it is longer
  * @return     1 if `s` starts with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strnstarts(const char *, const char *, size_t);
 #ifndef strnstarts
 # define strnstarts libsimple_strnstarts
@@ -248,7 +248,7 @@ int libsimple_strnstarts(const char *, const char *, size_t);
  * @param   n  Truncate `s` to this length if it is longer
  * @return     1 if `s` starts with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strncasestarts(const char *, const char *, size_t);
 #ifndef strncasestarts
 # define strncasestarts libsimple_strncasestarts
@@ -263,7 +263,7 @@ int libsimple_strncasestarts(const char *, const char *, size_t);
  * @param   n  Truncate `s` to this length if it is longer
  * @return     1 if `s` ends with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strnends(const char *, const char *, size_t);
 #ifndef strnends
 # define strnends libsimple_strnends
@@ -278,7 +278,7 @@ int libsimple_strnends(const char *, const char *, size_t);
  * @param   n  Truncate `s` to this length if it is longer
  * @return     1 if `s` end with `t`, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 int libsimple_strncaseends(const char *, const char *, size_t);
 #ifndef strncaseends
 # define strncaseends libsimple_strncaseends
@@ -295,7 +295,7 @@ int libsimple_strncaseends(const char *, const char *, size_t);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strnstr(const char *, const char *, size_t);
 #ifndef strnstr
 # define strnstr libsimple_strnstr
@@ -312,7 +312,7 @@ char *libsimple_strnstr(const char *, const char *, size_t);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strncasestr(const char *, const char *, size_t);
 #ifndef strncasestr
 # define strncasestr libsimple_strncasestr
@@ -329,7 +329,7 @@ char *libsimple_strncasestr(const char *, const char *, size_t);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrnstr(const char *, const char *, size_t);
 #ifndef strrnstr
 # define strrnstr libsimple_strrnstr
@@ -346,7 +346,7 @@ char *libsimple_strrnstr(const char *, const char *, size_t);
  *                    pointer begins with `needle`, `NULL` if no such offset
  *                    exists
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 char *libsimple_strrncasestr(const char *, const char *, size_t);
 #ifndef strrncasestr
 # define strrncasestr libsimple_strrncasestr
@@ -365,9 +365,12 @@ char *libsimple_strrncasestr(const char *, const char *, size_t);
  *             a positive value if `a` is greater than `b`,
  *             0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strncmpnul(const char *__a, const char *__b, size_t __n)
-{ return (!__a || !__b) ? !__b - !__a : strncmp(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strncmpnul(const char *a__, const char *b__, size_t n__)
+{
+	return (!a__ || !b__) ? !b__ - !a__ : strncmp(a__, b__, n__);
+}
 #ifndef strncmpnul
 # define strncmpnul libsimple_strncmpnul
 #endif
@@ -385,9 +388,12 @@ static inline int libsimple_strncmpnul(const char *__a, const char *__b, size_t
  *             a positive value if `a` is greater than `b`,
  *             0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strncasecmpnul(const char *__a, const char *__b, size_t __n)
-{ return (!__a || !__b) ? !__b - !__a : strncasecmp(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strncasecmpnul(const char *a__, const char *b__, size_t n__)
+{
+	return (!a__ || !b__) ? !b__ - !a__ : strncasecmp(a__, b__, n__);
+}
 #ifndef strncasecmpnul
 # define strncasecmpnul libsimple_strncasecmpnul
 #endif
@@ -403,9 +409,12 @@ static inline int libsimple_strncasecmpnul(const char *__a, const char *__b, siz
  *             longer than this to this length
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_strneq(const char *__a, const char *__b, size_t __n)
-{ return !strncmp(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_strneq(const char *a__, const char *b__, size_t n__)
+{
+	return !strncmp(a__, b__, n__);
+}
 #ifndef strneq
 # define strneq libsimple_strneq
 #endif
@@ -421,9 +430,12 @@ static inline int libsimple_strneq(const char *__a, const char *__b, size_t __n)
  *             longer than this to this length
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strneqnul(const char *__a, const char *__b, size_t __n)
-{ return !strncmpnul(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strneqnul(const char *a__, const char *b__, size_t n__)
+{
+	return !strncmpnul(a__, b__, n__);
+}
 #ifndef strneqnul
 # define strneqnul libsimple_strneqnul
 #endif
@@ -439,9 +451,12 @@ static inline int libsimple_strneqnul(const char *__a, const char *__b, size_t _
  *             longer than this to this length
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_strncaseeq(const char *__a, const char *__b, size_t __n)
-{ return !strncasecmp(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_strncaseeq(const char *a__, const char *b__, size_t n__)
+{
+	return !strncasecmp(a__, b__, n__);
+}
 #ifndef strncaseeq
 # define strncaseeq libsimple_strncaseeq
 #endif
@@ -457,9 +472,12 @@ static inline int libsimple_strncaseeq(const char *__a, const char *__b, size_t
  *             longer than this to this length
  * @return     1 if the strings are equal, 0 otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __warn_unused_result__)))
-static inline int libsimple_strncaseeqnul(const char *__a, const char *__b, size_t __n)
-{ return !libsimple_strncasecmpnul(__a, __b, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __warn_unused_result__)))
+static inline int
+libsimple_strncaseeqnul(const char *a__, const char *b__, size_t n__)
+{
+	return !libsimple_strncasecmpnul(a__, b__, n__);
+}
 #ifndef strncaseeqnul
 # define strncaseeqnul libsimple_strncaseeqnul
 #endif
@@ -475,7 +493,7 @@ static inline int libsimple_strncaseeqnul(const char *__a, const char *__b, size
  * @return     The number of bytes `a` and `b` have
  *             in common in their beginnings
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 size_t libsimple_strneqlen(const char *, const char *, size_t);
 #ifndef strneqlen
 # define strneqlen libsimple_strneqlen
@@ -492,7 +510,7 @@ size_t libsimple_strneqlen(const char *, const char *, size_t);
  * @return     The number of bytes `a` and `b` have
  *             in common in their beginnings
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
 size_t libsimple_strncaseeqlen(const char *, const char *, size_t);
 #ifndef strncaseeqlen
 # define strncaseeqlen libsimple_strncaseeqlen
@@ -509,9 +527,12 @@ size_t libsimple_strncaseeqlen(const char *, const char *, size_t);
  * @return     The number of bytes `a` and `b` have
  *             in common in their ends
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline size_t libsimple_strrneqlen(const char *__a, const char *__b, size_t __n)
-{ return libsimple_memreqlen(__a, strnlen(__a, __n), __b, strnlen(__b, __n)); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline size_t
+libsimple_strrneqlen(const char *a__, const char *b__, size_t n__)
+{
+	return libsimple_memreqlen(a__, strnlen(a__, n__), b__, strnlen(b__, n__));
+}
 #ifndef strrneqlen
 # define strrneqlen libsimple_strrneqlen
 #endif
@@ -527,9 +548,12 @@ static inline size_t libsimple_strrneqlen(const char *__a, const char *__b, size
  * @return     The number of bytes `a` and `b` have
  *             in common in their ends
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline size_t libsimple_strrncaseeqlen(const char *__a, const char *__b, size_t __n)
-{ return libsimple_memrcaseeqlen(__a, strnlen(__a, __n), __b, strnlen(__b, __n)); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline size_t
+libsimple_strrncaseeqlen(const char *a__, const char *b__, size_t n__)
+{
+	return libsimple_memrcaseeqlen(a__, strnlen(a__, n__), b__, strnlen(b__, n__));
+}
 #ifndef strrncaseeqlen
 # define strrncaseeqlen libsimple_strrncaseeqlen
 #endif
@@ -544,9 +568,13 @@ static inline size_t libsimple_strrncaseeqlen(const char *__a, const char *__b,
  * @param   n  The maximum number of bytes to move
  * @return     `d`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
-static inline char *libsimple_strnmove(char *__d, const char *__s, size_t __n)
-{ size_t __len = strnlen(__s, __n); return memmove(__d, __s, __len + (__len < __n)); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
+static inline char *
+libsimple_strnmove(char *d__, const char *s__, size_t n__)
+{
+	size_t len__ = strnlen(s__, n__);
+	return memmove(d__, s__, len__ + (len__ < n__));
+}
 #ifndef strnmove
 # define strnmove libsimple_strnmove
 #endif
@@ -561,13 +589,13 @@ static inline char *libsimple_strnmove(char *__d, const char *__s, size_t __n)
  * @param   n  The maximum number of bytes to move
  * @return     `&d[strnlen(s, n)]`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_stpnmove(char *__d, const char *__s, size_t __n)
+libsimple_stpnmove(char *d__, const char *s__, size_t n__)
 {
-	size_t __len = strnlen(__s, __n);
-	memmove(__d, __s, __len + (__len < __n));
-	return &__d[__len];
+	size_t len__ = strnlen(s__, n__);
+	memmove(d__, s__, len__ + (len__ < n__));
+	return &d__[len__];
 }
 #ifndef stpnmove
 # define stpnmove libsimple_stpnmove
@@ -582,13 +610,13 @@ libsimple_stpnmove(char *__d, const char *__s, size_t __n)
  * @param   n  The maximum number of bytes to write
  * @return     `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_strnset(char *__s, int __c_, size_t __n)
+libsimple_strnset(char *s__, int c___, size_t n__)
 {
-	char __c = (char)__c_, *__r = __s;
-	for (; __n && *__s; __n--) *__s++ = __c;
-	return __r;
+	char c__ = (char)c___, *r__ = s__;
+	for (; n__ && *s__; n__--) *s__++ = c__;
+	return r__;
 }
 #ifndef strnset
 # define strnset libsimple_strnset
@@ -603,13 +631,13 @@ libsimple_strnset(char *__s, int __c_, size_t __n)
  * @param   n  The maximum number of bytes to write
  * @return     `&s[strnlen(s, n)]`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_stpnset(char *__s, int __c_, size_t __n)
+libsimple_stpnset(char *s__, int c___, size_t n__)
 {
-	char __c = (char)__c_;
-	for (; __n && *__s; __n--) *__s++ = __c;
-	return __s;
+	char c__ = (char)c___;
+	for (; n__ && *s__; n__--) *s__++ = c__;
+	return s__;
 }
 #ifndef stpnset
 # define stpnset libsimple_stpnset
@@ -628,21 +656,21 @@ libsimple_stpnset(char *__s, int __c_, size_t __n)
  * @return     `&strchr(d, c)[1]` (after copying) if `c` can be
  *             found in `s`, `NULL` otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 static inline char *
-libsimple_strnccpy(char *restrict __d, const char *restrict __s, int __c_, size_t __n)
+libsimple_strnccpy(char *restrict d__, const char *restrict s__, int c___, size_t n__)
 {
-	char __c = (char)__c_, *__end = &__d[__n];
+	char c__ = (char)c___, *end__ = &d__[n__];
 	do {
-		if (!__n)
+		if (!n__)
 			break;
-		if ((*__d++ = *__s) == __c) {
-			if (__d != __end)
-				*__d = '\0';
-			return __d;
+		if ((*d__++ = *s__) == c__) {
+			if (d__ != end__)
+				*d__ = '\0';
+			return d__;
 		}
-		__n--;
-	} while (*__s++);
+		n__--;
+	} while (*s__++);
 	return NULL;
 }
 #ifndef strnccpy
@@ -661,7 +689,7 @@ libsimple_strnccpy(char *restrict __d, const char *restrict __s, int __c_, size_
  *             found within the first `n` bytes of `s` (before
  *             copying), `NULL` otherwise
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 char *libsimple_strncmove(char *, const char *, int, size_t);
 #ifndef strncmove
 # define strncmove libsimple_strncmove
@@ -678,15 +706,15 @@ char *libsimple_strncmove(char *, const char *, int, size_t);
  * @param   n    The maximum length of `s`
  * @return       `strnchr(s, '\0', n)`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
 static inline char *
-libsimple_strnreplace(char *__s, int __old_, int __new_, size_t __n)
+libsimple_strnreplace(char *s__, int old___, int new___, size_t n__)
 {
-	char __old = (char)__old_, __new = (char)__new_;
-	for (; __n && *__s; __s++, __n--)
-		if (*__s == __old)
-			*__s = __new;
-	return __s;
+	char old__ = (char)old___, new__ = (char)new___;
+	for (; n__ && *s__; s__++, n__--)
+		if (*s__ == old__)
+			*s__ = new__;
+	return s__;
 }
 #ifndef strnreplace
 # define strnreplace libsimple_strnreplace
@@ -706,7 +734,7 @@ libsimple_strnreplace(char *__s, int __old_, int __new_, size_t __n)
  * @param   n  The maximum number of bytes to copy or convert
  * @return     `strnchrnul(d, '\0', n)` (after copying)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
 char *libsimple_stpntolower(char *, const char *, size_t);
 #ifndef stpntolower
 # define stpntolower libsimple_stpntolower
@@ -726,7 +754,7 @@ char *libsimple_stpntolower(char *, const char *, size_t);
  * @param   n  The maximum number of bytes to copy or convert
  * @return     `strnchrnul(d, '\0', n)` (after copying)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
 char *libsimple_stpntoupper(char *, const char *, size_t);
 #ifndef stpntoupper
 # define stpntoupper libsimple_stpntoupper
@@ -746,9 +774,13 @@ char *libsimple_stpntoupper(char *, const char *, size_t);
  * @param   n  The maximum number of bytes to copy or convert
  * @return     `d`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
-static inline char *libsimple_strntolower(char *__d, const char *__s, size_t __n)
-{ libsimple_stpntolower(__d, __s, __n); return __d; }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
+static inline char *
+libsimple_strntolower(char *d__, const char *s__, size_t n__)
+{
+	libsimple_stpntolower(d__, s__, n__);
+	return d__;
+}
 #ifndef strntolower
 # define strntolower libsimple_strntolower
 #endif
@@ -767,9 +799,13 @@ static inline char *libsimple_strntolower(char *__d, const char *__s, size_t __n
  * @param   n  The maximum number of bytes to copy or convert
  * @return     `d`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __returns_nonnull__)))
-static inline char *libsimple_strntoupper(char *__d, const char *__s, size_t __n)
-{ libsimple_stpntoupper(__d, __s, __n); return __d; }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __returns_nonnull__)))
+static inline char *
+libsimple_strntoupper(char *d__, const char *s__, size_t n__)
+{
+	libsimple_stpntoupper(d__, s__, n__);
+	return d__;
+}
 #ifndef strntoupper
 # define strntoupper libsimple_strntoupper
 #endif
@@ -787,9 +823,12 @@ static inline char *libsimple_strntoupper(char *__d, const char *__s, size_t __n
  *                              allows a two-byte encoding for NUL
  * @return                      1 if good, 0 on encoding error
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
-static inline int libsimple_strnisutf8(const char *__string, size_t __n, int __allow_modified_nul)
-{ return libsimple_memisutf8(__string, strnlen(__string, __n) ,__allow_modified_nul); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__pure__, __nonnull__, __warn_unused_result__)))
+static inline int
+libsimple_strnisutf8(const char *string__, size_t n__, int allow_modified_nul__)
+{
+	return libsimple_memisutf8(string__, strnlen(string__, n__), allow_modified_nul__);
+}
 #ifndef strnisutf8
 # define strnisutf8 libsimple_strnisutf8
 #endif
diff --git a/libsimple/strndup.h b/libsimple/strndup.h
index 6259a1e..ccf3842 100644
--- a/libsimple/strndup.h
+++ b/libsimple/strndup.h
@@ -10,14 +10,15 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_strndupa(s, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const char *__s = (s);\
-		size_t __n = strnlen(__s, n);\
-		char *__r;\
-		__r = alloca(__n + 1);\
-		memcpy(__r, __s, __n);\
-		__r[__n] = '\0';\
-		__r;\
+		const char *s__ = (s);\
+		size_t n__ = strnlen(s__, n);\
+		char *r__;\
+		r__ = alloca(n__ + 1);\
+		memcpy(r__, s__, n__);\
+		r__[n__] = '\0';\
+		r__;\
 	})
 # ifndef strndupa
 #  define strndupa(s, n) libsimple_strndupa(s, n)
@@ -33,7 +34,7 @@
  * @param   n       The maximum number of bytes to copy
  * @return          Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 char *libsimple_enstrndup(int, const char *, size_t);
 #ifndef enstrndup
 # define enstrndup libsimple_enstrndup
@@ -47,11 +48,11 @@ char *libsimple_enstrndup(int, const char *, size_t);
  * @param   n  The maximum number of bytes to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline char *
-libsimple_estrndup(const char *__s, size_t __n)
+libsimple_estrndup(const char *s__, size_t n__)
 {
-	return libsimple_enstrndup(libsimple_default_failure_exit, __s, __n);
+	return libsimple_enstrndup(libsimple_default_failure_exit, s__, n__);
 }
 #ifndef estrndup
 # define estrndup libsimple_estrndup
diff --git a/libsimple/strtoint.h b/libsimple/strtoint.h
index ba2c92e..a342045 100644
--- a/libsimple/strtoint.h
+++ b/libsimple/strtoint.h
@@ -17,7 +17,7 @@
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 signed char libsimple_strtohh(const char *restrict, char **restrict, int);
 #ifndef strtohh
 # define strtohh libsimple_strtohh
@@ -40,7 +40,7 @@ signed char libsimple_strtohh(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 unsigned char libsimple_strtouhh(const char *restrict, char **restrict, int);
 #ifndef strtouhh
 # define strtouhh libsimple_strtouhh
@@ -63,7 +63,7 @@ unsigned char libsimple_strtouhh(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 signed short int libsimple_strtoh(const char *restrict, char **restrict, int);
 #ifndef strtoh
 # define strtoh libsimple_strtoh
@@ -86,7 +86,7 @@ signed short int libsimple_strtoh(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 unsigned short int libsimple_strtouh(const char *restrict, char **restrict, int);
 #ifndef strtouh
 # define strtouh libsimple_strtouh
@@ -109,7 +109,7 @@ unsigned short int libsimple_strtouh(const char *restrict, char **restrict, int)
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 signed int libsimple_strtoi(const char *restrict, char **restrict, int);
 #ifndef strtoi
 # define strtoi libsimple_strtoi
@@ -132,7 +132,7 @@ signed int libsimple_strtoi(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 unsigned int libsimple_strtou(const char *restrict, char **restrict, int);
 #ifndef strtou
 # define strtou libsimple_strtou
@@ -155,11 +155,11 @@ unsigned int libsimple_strtou(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 inline ssize_t
-libsimple_strtoz(const char *restrict __nptr, char **restrict __endptr, int __base)
+libsimple_strtoz(const char *restrict nptr__, char **restrict endptr__, int base__)
 {
-	return (ssize_t)strtol(__nptr, __endptr, __base);
+	return (ssize_t)strtol(nptr__, endptr__, base__);
 }
 #ifndef strtoz
 # define strtoz libsimple_strtoz
@@ -182,11 +182,11 @@ libsimple_strtoz(const char *restrict __nptr, char **restrict __endptr, int __ba
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 inline size_t
-libsimple_strtouz(const char *restrict __nptr, char **restrict __endptr, int __base)
+libsimple_strtouz(const char *restrict nptr__, char **restrict endptr__, int base__)
 {
-	return (size_t)strtoul(__nptr, __endptr, __base);
+	return (size_t)strtoul(nptr__, endptr__, base__);
 }
 #ifndef strtouz
 # define strtouz libsimple_strtouz
@@ -209,7 +209,7 @@ libsimple_strtouz(const char *restrict __nptr, char **restrict __endptr, int __b
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 int_least8_t libsimple_strtoi8(const char *restrict, char **restrict, int);
 #ifndef strtoi8
 # define strtoi8 libsimple_strtoi8
@@ -232,7 +232,7 @@ int_least8_t libsimple_strtoi8(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 uint_least8_t libsimple_strtou8(const char *restrict, char **restrict, int);
 #ifndef strtou8
 # define strtou8 libsimple_strtou8
@@ -255,7 +255,7 @@ uint_least8_t libsimple_strtou8(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 int_least16_t libsimple_strtoi16(const char *restrict, char **restrict, int);
 #ifndef strtoi16
 # define strtoi16 libsimple_strtoi16
@@ -278,7 +278,7 @@ int_least16_t libsimple_strtoi16(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 uint_least16_t libsimple_strtou16(const char *restrict, char **restrict, int);
 #ifndef strtou16
 # define strtou16 libsimple_strtou16
@@ -301,7 +301,7 @@ uint_least16_t libsimple_strtou16(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 int_least32_t libsimple_strtoi32(const char *restrict, char **restrict, int);
 #ifndef strtoi32
 # define strtoi32 libsimple_strtoi32
@@ -324,7 +324,7 @@ int_least32_t libsimple_strtoi32(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 uint_least32_t libsimple_strtou32(const char *restrict, char **restrict, int);
 #ifndef strtou32
 # define strtou32 libsimple_strtou32
@@ -347,7 +347,7 @@ uint_least32_t libsimple_strtou32(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 int_least64_t libsimple_strtoi64(const char *restrict, char **restrict, int);
 #ifndef strtoi64
 # define strtoi64 libsimple_strtoi64
@@ -370,7 +370,7 @@ int_least64_t libsimple_strtoi64(const char *restrict, char **restrict, int);
  *                  closed value that can be represented; 0 on
  *                  failure (unless `errno` not set to `ERANGE`)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __warn_unused_result__)))
 uint_least64_t libsimple_strtou64(const char *restrict, char **restrict, int);
 #ifndef strtou64
 # define strtou64 libsimple_strtou64
diff --git a/libsimple/time.h b/libsimple/time.h
index 71c19fe..6618d9d 100644
--- a/libsimple/time.h
+++ b/libsimple/time.h
@@ -13,7 +13,7 @@
  *                  result too large and `{.tv_sec = TIME_MIN, .tv_nsec = 0L}`
  *                  if the result too small
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_sumtimespec(struct timespec *, const struct timespec *, const struct timespec *);
 #ifndef sumtimespec
 # define sumtimespec libsimple_sumtimespec
@@ -32,7 +32,7 @@ int libsimple_sumtimespec(struct timespec *, const struct timespec *, const stru
  *                      result too large and `{.tv_sec = TIME_MIN, .tv_nsec = 0L}`
  *                      if the result too small
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_difftimespec(struct timespec *, const struct timespec *, const struct timespec *);
 #ifndef difftimespec
 # define difftimespec libsimple_difftimespec
@@ -51,7 +51,7 @@ int libsimple_difftimespec(struct timespec *, const struct timespec *, const str
  *                        result too large and `{.tv_sec = TIME_MIN, .tv_nsec = 0L}`
  *                        if the result too small
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_multimespec(struct timespec *, const struct timespec *, int);
 #ifndef multimespec
 # define multimespec libsimple_multimespec
@@ -65,13 +65,13 @@ int libsimple_multimespec(struct timespec *, const struct timespec *, int);
  * @param   b  The other `struct timespec`
  * @return     -1 if `a` < `b`, 0 if `a` = `b`, and +1 if `a` > `b`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __warn_unused_result__)))
-static inline int
-libsimple_cmptimespec(const struct timespec *__a, const struct timespec *__b)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __warn_unused_result__)))
+inline int
+libsimple_cmptimespec(const struct timespec *a__, const struct timespec *b__)
 {
-        if (__a->tv_sec != __b->tv_sec)
-                return __a->tv_sec < __b->tv_sec ? -1 : +1;
-        return __a->tv_nsec < __b->tv_nsec ? -1 : __a->tv_nsec > __b->tv_nsec;
+        if (a__->tv_sec != b__->tv_sec)
+                return a__->tv_sec < b__->tv_sec ? -1 : +1;
+        return a__->tv_nsec < b__->tv_nsec ? -1 : a__->tv_nsec > b__->tv_nsec;
 }
 #ifndef cmptimespec
 # define cmptimespec libsimple_cmptimespec
@@ -90,7 +90,7 @@ libsimple_cmptimespec(const struct timespec *__a, const struct timespec *__b)
  *                  result too large and `{.tv_sec = TIME_MIN, .tv_usec = 0L}`
  *                  if the result too small
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_sumtimeval(struct timeval *, const struct timeval *, const struct timeval *);
 #ifndef sumtimeval
 # define sumtimeval libsimple_sumtimeval
@@ -109,7 +109,7 @@ int libsimple_sumtimeval(struct timeval *, const struct timeval *, const struct
  *                      result too large and `{.tv_sec = TIME_MIN, .tv_usec = 0L}`
  *                      if the result too small
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_difftimeval(struct timeval *, const struct timeval *, const struct timeval *);
 #ifndef difftimeval
 # define difftimeval libsimple_difftimeval
@@ -128,7 +128,7 @@ int libsimple_difftimeval(struct timeval *, const struct timeval *, const struct
  *                        result too large and `{.tv_sec = TIME_MIN, .tv_usec = 0L}`
  *                        if the result too small
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_multimeval(struct timeval *, const struct timeval *, int);
 #ifndef multimeval
 # define multimeval libsimple_multimeval
@@ -142,13 +142,13 @@ int libsimple_multimeval(struct timeval *, const struct timeval *, int);
  * @param   b  The other `struct timeval`
  * @return     -1 if `a` < `b`, 0 if `a` = `b`, and +1 if `a` > `b`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__, __warn_unused_result__)))
-static inline int
-libsimple_cmptimeval(const struct timeval *__a, const struct timeval *__b)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__, __warn_unused_result__)))
+inline int
+libsimple_cmptimeval(const struct timeval *a__, const struct timeval *b__)
 {
-        if (__a->tv_sec != __b->tv_sec)
-                return __a->tv_sec < __b->tv_sec ? -1 : +1;
-        return __a->tv_usec < __b->tv_usec ? -1 : __a->tv_usec > __b->tv_usec;
+        if (a__->tv_sec != b__->tv_sec)
+                return a__->tv_sec < b__->tv_sec ? -1 : +1;
+        return a__->tv_usec < b__->tv_usec ? -1 : a__->tv_usec > b__->tv_usec;
 }
 #ifndef cmptimeval
 # define cmptimeval libsimple_cmptimeval
@@ -161,13 +161,13 @@ libsimple_cmptimeval(const struct timeval *__a, const struct timeval *__b)
  * @param  ts  Output parameter for the result
  * @param  tv  The value to convert
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
-static inline void
-libsimple_timeval2timespec(struct timespec *restrict __ts, const struct timeval *restrict __tv)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
+inline void
+libsimple_timeval2timespec(struct timespec *restrict ts__, const struct timeval *restrict tv__)
 {
-        __ts->tv_sec = __tv->tv_sec;
-        __ts->tv_nsec = __tv->tv_usec;
-        __ts->tv_nsec *= 1000L;
+        ts__->tv_sec = tv__->tv_sec;
+        ts__->tv_nsec = tv__->tv_usec;
+        ts__->tv_nsec *= 1000L;
 }
 #ifndef timeval2timespec
 # define timeval2timespec libsimple_timeval2timespec
@@ -183,7 +183,7 @@ libsimple_timeval2timespec(struct timespec *restrict __ts, const struct timeval
  * @throws  EOVERFLOW  The value is too large to be convert, the value will be
  *                     truncated to `{.tv_sec = TIME_MAX, .tv_usec = 999999L}`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 int libsimple_timespec2timeval(struct timeval *restrict, const struct timespec *restrict);
 #ifndef timespec2timeval
 # define timespec2timeval libsimple_timespec2timeval
@@ -208,7 +208,7 @@ int libsimple_timespec2timeval(struct timeval *restrict, const struct timespec *
  *                  result too large and `{.tv_sec = TIME_MIN, .tv_nsec = 0L}`
  *                  if the result too small (`*end` is set)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1, 2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1, 2))))
 int libsimple_strtotimespec(struct timespec *restrict, const char *restrict, char **restrict);
 #ifndef strtotimespec
 # define strtotimespec libsimple_strtotimespec
@@ -233,7 +233,7 @@ int libsimple_strtotimespec(struct timespec *restrict, const char *restrict, cha
  *                  result too large and `{.tv_sec = TIME_MIN, .tv_usec = 0L}`
  *                  if the result too small (`*end` is set)
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1, 2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1, 2))))
 int libsimple_strtotimeval(struct timeval *restrict, const char *restrict, char **restrict);
 #ifndef strtotimeval
 # define strtotimeval libsimple_strtotimeval
@@ -252,7 +252,7 @@ int libsimple_strtotimeval(struct timeval *restrict, const char *restrict, char
  * @throws  ENOMEM  Output buffer could not be allocated (only if `buf == NULL`)
  * @throws  EINVAL  `ts->tv_nsec` is negative or greater than 999999999
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
 char *libsimple_timespectostr(char *restrict, const struct timespec *restrict);
 #ifndef timespectostr
 # define timespectostr libsimple_timespectostr
@@ -271,7 +271,7 @@ char *libsimple_timespectostr(char *restrict, const struct timespec *restrict);
  * @throws  ENOMEM  Output buffer could not be allocated (only if `buf == NULL`)
  * @throws  EINVAL  `ts->tv_usec` is negative or greater than 999999
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
 char *libsimple_timevaltostr(char *restrict, const struct timeval *restrict);
 #ifndef timevaltostr
 # define timevaltostr libsimple_timevaltostr
@@ -284,14 +284,14 @@ char *libsimple_timevaltostr(char *restrict, const struct timeval *restrict);
  * @param   ts  The value to convert
  * @return      The result
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
-static inline double
-libsimple_timespectodouble(const struct timespec *__ts)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
+inline double
+libsimple_timespectodouble(const struct timespec *ts__)
 {
-	double __ret = (double)(__ts->tv_nsec);
-	__ret /= (double)1000000000L;
-	__ret += (double)(__ts->tv_sec);
-	return __ret;
+	double ret__ = (double)(ts__->tv_nsec);
+	ret__ /= (double)1000000000L;
+	ret__ += (double)(ts__->tv_sec);
+	return ret__;
 }
 #ifndef timespectodouble
 # define timespectodouble libsimple_timespectodouble
@@ -304,14 +304,14 @@ libsimple_timespectodouble(const struct timespec *__ts)
  * @param   tv  The value to convert
  * @return      The result
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
-static inline double
-libsimple_timevaltodouble(const struct timeval *__tv)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
+inline double
+libsimple_timevaltodouble(const struct timeval *tv__)
 {
-	double __ret = (double)(__tv->tv_usec);
-	__ret /= (double)1000000L;
-	__ret += (double)(__tv->tv_sec);
-	return __ret;
+	double ret__ = (double)(tv__->tv_usec);
+	ret__ /= (double)1000000L;
+	ret__ += (double)(tv__->tv_sec);
+	return ret__;
 }
 #ifndef timevaltodouble
 # define timevaltodouble libsimple_timevaltodouble
@@ -326,7 +326,7 @@ libsimple_timevaltodouble(const struct timeval *__tv)
  * @param  ts  Output parameter for the result
  * @param  d   The value to convert
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 void libsimple_doubletotimespec(struct timespec *, double);
 #ifndef doubletotimespec
 # define doubletotimespec libsimple_doubletotimespec
@@ -341,7 +341,7 @@ void libsimple_doubletotimespec(struct timespec *, double);
  * @param  tv  Output parameter for the result
  * @param  d   The value to convert
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__)))
 void libsimple_doubletotimeval(struct timeval *, double);
 #ifndef doubletotimeval
 # define doubletotimeval libsimple_doubletotimeval
@@ -356,7 +356,7 @@ void libsimple_doubletotimeval(struct timeval *, double);
  * @param   s  The string to minimise
  * @return     `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__returns_nonnull__, __nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__returns_nonnull__, __nonnull__)))
 char *libsimple_minimise_number_string(char *);
 #ifndef minimise_number_string
 # define minimise_number_string libsimple_minimise_number_string
@@ -374,7 +374,7 @@ char *libsimple_minimise_number_string(char *);
  * 
  * @since  1.2
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
 int libsimple_localtime(struct tm *, struct timespec *);
 
 /**
@@ -392,7 +392,7 @@ int libsimple_localtime(struct tm *, struct timespec *);
  * 
  * @since  1.2
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
 void libsimple_enlocaltime(int, struct tm *, struct timespec *);
 
 /**
@@ -409,9 +409,12 @@ void libsimple_enlocaltime(int, struct tm *, struct timespec *);
  * 
  * @since  1.2
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void libsimple_elocaltime(struct tm *__tm, struct timespec *__ts)
-{ libsimple_enlocaltime(libsimple_default_failure_exit, __tm, __ts); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_elocaltime(struct tm *tm__, struct timespec *ts__)
+{
+	libsimple_enlocaltime(libsimple_default_failure_exit, tm__, ts__);
+}
 
 
 /**
@@ -425,7 +428,7 @@ static inline void libsimple_elocaltime(struct tm *__tm, struct timespec *__ts)
  * 
  * @since  1.2
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
 int libsimple_gmtime(struct tm *, struct timespec *);
 
 /**
@@ -443,7 +446,7 @@ int libsimple_gmtime(struct tm *, struct timespec *);
  * 
  * @since  1.2
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2))))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2))))
 void libsimple_engmtime(int, struct tm *, struct timespec *);
 
 /**
@@ -460,6 +463,9 @@ void libsimple_engmtime(int, struct tm *, struct timespec *);
  * 
  * @since  1.2
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(1))))
-static inline void libsimple_egmtime(struct tm *__tm, struct timespec *__ts)
-{ libsimple_engmtime(libsimple_default_failure_exit, __tm, __ts); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1))))
+inline void
+libsimple_egmtime(struct tm *tm__, struct timespec *ts__)
+{
+	libsimple_engmtime(libsimple_default_failure_exit, tm__, ts__);
+}
diff --git a/libsimple/valloc.h b/libsimple/valloc.h
index c0fcd03..55e8fd5 100644
--- a/libsimple/valloc.h
+++ b/libsimple/valloc.h
@@ -17,9 +17,12 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *libsimple_vvallocn(size_t __n, va_list __ap)
-{ return libsimple_vvalloczn(0, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+static inline void *
+libsimple_vvallocn(size_t n__, va_list ap__)
+{
+	return libsimple_vvalloczn(0, n__, ap__);
+}
 #ifndef vvallocn
 # define vvallocn libsimple_vvallocn
 #endif
@@ -35,9 +38,12 @@ static inline void *libsimple_vvallocn(size_t __n, va_list __ap)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__)))
-static inline void *libsimple_valloc(size_t __n)
-{ return libsimple_vallocz(0, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__)))
+static inline void *
+libsimple_valloc(size_t n__)
+{
+	return libsimple_vallocz(0, n__);
+}
 #ifndef valloc
 # define valloc libsimple_valloc
 #endif
@@ -59,14 +65,14 @@ static inline void *libsimple_valloc(size_t __n)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
 static inline void *
-libsimple_vallocn(size_t __n, ... /*, (size_t)0 */)
+libsimple_vallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vvallocn(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vvallocn(n__, ap__);
+	va_end(ap__);
 }
 #ifndef vallocn
 # define vallocn libsimple_vallocn
@@ -87,9 +93,12 @@ libsimple_vallocn(size_t __n, ... /*, (size_t)0 */)
  * @return          A unique pointer with at least the specified size
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envalloc(int __status, size_t __n)
-{ return libsimple_envallocz(__status, 0, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_envalloc(int status__, size_t n__)
+{
+	return libsimple_envallocz(status__, 0, n__);
+}
 #ifndef envalloc
 # define envalloc libsimple_envalloc
 #endif
@@ -114,9 +123,12 @@ static inline void *libsimple_envalloc(int __status, size_t __n)
  * @return          A unique pointer with at least the specified size
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_envvallocn(int __status, size_t __n, va_list __ap)
-{ return libsimple_envvalloczn(__status, 0, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_envvallocn(int status__, size_t n__, va_list ap__)
+{
+	return libsimple_envvalloczn(status__, 0, n__, ap__);
+}
 #ifndef envvallocn
 # define envvallocn libsimple_envvallocn
 #endif
@@ -141,14 +153,14 @@ static inline void *libsimple_envvallocn(int __status, size_t __n, va_list __ap)
  * @return          A unique pointer with at least the specified size
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_envallocn(int __status, size_t __n, ... /*, (size_t)0 */)
+libsimple_envallocn(int status__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envvalloczn(__status, 0, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envvalloczn(status__, 0, n__, ap__);
+	va_end(ap__);
 }
 #ifndef envallocn
 # define envallocn libsimple_envallocn
@@ -168,9 +180,12 @@ libsimple_envallocn(int __status, size_t __n, ... /*, (size_t)0 */)
  * @return     A unique pointer with at least the specified size
  *             and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evalloc(size_t __n)
-{ return libsimple_envalloc(libsimple_default_failure_exit, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evalloc(size_t n__)
+{
+	return libsimple_envalloc(libsimple_default_failure_exit, n__);
+}
 #ifndef evalloc
 # define evalloc libsimple_evalloc
 #endif
@@ -194,9 +209,12 @@ static inline void *libsimple_evalloc(size_t __n)
  * @return      A unique pointer with at least the specified size
  *              and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evvallocn(size_t __n, va_list __ap)
-{ return libsimple_envvallocn(libsimple_default_failure_exit, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+static inline void *
+libsimple_evvallocn(size_t n__, va_list ap__)
+{
+	return libsimple_envvallocn(libsimple_default_failure_exit, n__, ap__);
+}
 #ifndef evvallocn
 # define evvallocn libsimple_evvallocn
 #endif
@@ -220,14 +238,14 @@ static inline void *libsimple_evvallocn(size_t __n, va_list __ap)
  * @return       A unique pointer with at least the specified size
  *               and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
 static inline void *
-libsimple_evallocn(size_t __n, ... /*, (size_t)0 */)
+libsimple_evallocn(size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evvallocn(__n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evvallocn(n__, ap__);
+	va_end(ap__);
 }
 #ifndef evallocn
 # define evallocn libsimple_evallocn
diff --git a/libsimple/vallocz.h b/libsimple/vallocz.h
index 3d8b4ec..5c8258e 100644
--- a/libsimple/vallocz.h
+++ b/libsimple/vallocz.h
@@ -18,12 +18,12 @@
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_vvalloczn(int __clear, size_t __n, va_list __ap)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_vvalloczn(int clear__, size_t n__, va_list ap__)
 {
-	return libsimple_memalloc(0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, __n, __ap,
-	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_memalloc(0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, n__, ap__,
+	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                          LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                          LIBSIMPLE_MEMALLOC_END);
 }
@@ -43,12 +43,12 @@ libsimple_vvalloczn(int __clear, size_t __n, va_list __ap)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__)))
-static inline void *
-libsimple_vallocz(int __clear, size_t __n)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__)))
+inline void *
+libsimple_vallocz(int clear__, size_t n__)
 {
-	return libsimple_memalloc(__n,
-	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_memalloc(n__,
+	                          LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                          LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                          LIBSIMPLE_MEMALLOC_END);
 }
@@ -74,14 +74,14 @@ libsimple_vallocz(int __clear, size_t __n)
  * @throws  EINVAL  `n` is 0
  * @throws  ENOMEM  Could not allocated enough memory
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__)))
-static inline void *
-libsimple_valloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__)))
+inline void *
+libsimple_valloczn(int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_vvalloczn(__clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_vvalloczn(clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef valloczn
 # define valloczn libsimple_valloczn
@@ -103,12 +103,12 @@ libsimple_valloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
  * @return          A unique pointer with at least the specified size
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_envallocz(int __status, int __clear, size_t __n)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(3), __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_envallocz(int status__, int clear__, size_t n__)
 {
-	return libsimple_enmemalloc(__status, __n,
-	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_enmemalloc(status__, n__,
+	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                            LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                            LIBSIMPLE_MEMALLOC_END);
 }
@@ -138,13 +138,13 @@ libsimple_envallocz(int __status, int __clear, size_t __n)
  * @return          A unique pointer with at least the specified size
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_envvalloczn(int __status, int __clear, size_t __n, va_list __ap)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_envvalloczn(int status__, int clear__, size_t n__, va_list ap__)
 {
-	return libsimple_enmemalloc(__status,
-	                            0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, __n, __ap,
-	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, __clear,
+	return libsimple_enmemalloc(status__,
+	                            0, LIBSIMPLE_MEMALLOC_1_VA_PRODUCT_SIZE, n__, ap__,
+	                            LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__,
 	                            LIBSIMPLE_MEMALLOC_PAGE_ALIGNMENT,
 	                            LIBSIMPLE_MEMALLOC_END);
 }
@@ -174,14 +174,14 @@ libsimple_envvalloczn(int __status, int __clear, size_t __n, va_list __ap)
  * @return          A unique pointer with at least the specified size
  *                  and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_envalloczn(int __status, int __clear, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_envalloczn(int status__, int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_envvalloczn(__status, __clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_envvalloczn(status__, clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef envalloczn
 # define envalloczn libsimple_envalloczn
@@ -202,9 +202,12 @@ libsimple_envalloczn(int __status, int __clear, size_t __n, ... /*, (size_t)0 */
  * @return         A unique pointer with at least the specified size
  *                 and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evallocz(int __clear, size_t __n)
-{ return libsimple_envallocz(libsimple_default_failure_exit, __clear, __n); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_evallocz(int clear__, size_t n__)
+{
+	return libsimple_envallocz(libsimple_default_failure_exit, clear__, n__);
+}
 #ifndef evallocz
 # define evallocz libsimple_evallocz
 #endif
@@ -229,9 +232,12 @@ static inline void *libsimple_evallocz(int __clear, size_t __n)
  * @return         A unique pointer with at least the specified size
  *                 and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *libsimple_evvalloczn(int __clear, size_t __n, va_list __ap)
-{ return libsimple_envvalloczn(libsimple_default_failure_exit, __clear, __n, __ap); }
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_evvalloczn(int clear__, size_t n__, va_list ap__)
+{
+	return libsimple_envvalloczn(libsimple_default_failure_exit, clear__, n__, ap__);
+}
 #ifndef evvalloczn
 # define evvalloczn libsimple_evvalloczn
 #endif
@@ -256,14 +262,14 @@ static inline void *libsimple_evvalloczn(int __clear, size_t __n, va_list __ap)
  * @return         A unique pointer with at least the specified size
  *                 and with page size alignment
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
-static inline void *
-libsimple_evalloczn(int __clear, size_t __n, ... /*, (size_t)0 */)
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__)))
+inline void *
+libsimple_evalloczn(int clear__, size_t n__, ... /*, (size_t)0 */)
 {
-	va_list __ap;
-	va_start(__ap, __n);
-	return libsimple_evvalloczn(__clear, __n, __ap);
-	va_end(__ap);
+	va_list ap__;
+	va_start(ap__, n__);
+	return libsimple_evvalloczn(clear__, n__, ap__);
+	va_end(ap__);
 }
 #ifndef evalloczn
 # define evalloczn libsimple_evalloczn
diff --git a/libsimple/wcsdup.h b/libsimple/wcsdup.h
index 8a2e8d2..9b15103 100644
--- a/libsimple/wcsdup.h
+++ b/libsimple/wcsdup.h
@@ -9,11 +9,12 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_wcsdupa(s)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const wchar_t *__s = (s);\
-		size_t __n = wcslen(__s) + 1;\
-		wchar_t *__r = alloca(__n * sizeof(wchar_t));\
-		wmemcpy(__r, __s, __n);\
+		const wchar_t *s__ = (s);\
+		size_t n__ = wcslen(s__) + 1;\
+		wchar_t *r__ = alloca(n__ * sizeof(wchar_t));\
+		wmemcpy(r__, s__, n__);\
 	})
 # ifndef wcsdupa
 #  define wcsdupa(s) libsimple_wcsdupa(s)
@@ -28,7 +29,7 @@
  * @param   s       The string to copy
  * @return          Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t), __nonnull__,
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t), __nonnull__,
                                    __warn_unused_result__, __returns_nonnull__)))
 wchar_t *libsimple_enwcsdup(int, const wchar_t *);
 #ifndef enwcsdup
@@ -42,12 +43,12 @@ wchar_t *libsimple_enwcsdup(int, const wchar_t *);
  * @param   s  The string to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t),
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t),
                                    __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline wchar_t *
-libsimple_ewcsdup(const wchar_t *__s)
+libsimple_ewcsdup(const wchar_t *s__)
 {
-	return enwcsdup(libsimple_default_failure_exit, __s);
+	return enwcsdup(libsimple_default_failure_exit, s__);
 }
 #ifndef ewcsdup
 # define ewcsdup libsimple_ewcsdup
diff --git a/libsimple/wcsndup.h b/libsimple/wcsndup.h
index 583ce65..0d36a25 100644
--- a/libsimple/wcsndup.h
+++ b/libsimple/wcsndup.h
@@ -10,14 +10,15 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_wcsndupa(s, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const wchar_t *__s = (s);\
-		size_t __n = wcsnlen(__s, n);\
-		wchar_t *__r;\
-		__r = alloca((__n + 1) * sizeof(wchar_t));\
-		wmemcpy(__r, __s, __n);\
-		__r[__n] = 0;\
-		__r;\
+		const wchar_t *s__ = (s);\
+		size_t n__ = wcsnlen(s__, n);\
+		wchar_t *r__;\
+		r__ = alloca((n__ + 1) * sizeof(wchar_t));\
+		wmemcpy(r__, s__, n__);\
+		r__[n__] = 0;\
+		r__;\
 	})
 # ifndef wcsndupa
 #  define wcsndupa(s, n) libsimple_wcsndupa(s, n)
@@ -32,7 +33,7 @@
  * @param   n  The maximum number of wide characters to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t), __nonnull__,
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t), __nonnull__,
                                    __warn_unused_result__)))
 wchar_t *libsimple_wcsndup(const wchar_t *, size_t);
 #ifndef wcsndup
@@ -48,7 +49,7 @@ wchar_t *libsimple_wcsndup(const wchar_t *, size_t);
  * @param   n       The maximum number of wide characters to copy
  * @return          Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t), __nonnull__,
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t), __nonnull__,
                                    __warn_unused_result__, __returns_nonnull__)))
 wchar_t *libsimple_enwcsndup(int, const wchar_t *, size_t);
 #ifndef enwcsndup
@@ -63,12 +64,12 @@ wchar_t *libsimple_enwcsndup(int, const wchar_t *, size_t);
  * @param   n  The maximum number of wide characters to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t),
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t),
                                    __nonnull__, __warn_unused_result__, __returns_nonnull__)))
 inline wchar_t *
-libsimple_ewcsndup(const wchar_t *__s, size_t __n)
+libsimple_ewcsndup(const wchar_t *s__, size_t n__)
 {
-	return libsimple_enwcsndup(libsimple_default_failure_exit, __s, __n);
+	return libsimple_enwcsndup(libsimple_default_failure_exit, s__, n__);
 }
 #ifndef ewcsndup
 # define ewcsndup libsimple_ewcsndup
diff --git a/libsimple/wmemdup.h b/libsimple/wmemdup.h
index 9c63cbc..467aa61 100644
--- a/libsimple/wmemdup.h
+++ b/libsimple/wmemdup.h
@@ -10,11 +10,12 @@
  */
 #if defined(__GNUC__) || defined(__clang__)
 # define libsimple_wmemdupa(s, n)\
+	LIBSIMPLE_GCC_ONLY__(__extension__)\
 	({\
-		const wchar_t *__s = (s);\
-		size_t __n = (n);\
-		wchar_t *__r = alloca(__n * sizeof(wchar_t) + !__n);\
-		wmemcpy(__r, __s, __n);\
+		const wchar_t *s__ = (s);\
+		size_t n__ = (n);\
+		wchar_t *r__ = alloca(n__ * sizeof(wchar_t) + !n__);\
+		wmemcpy(r__, s__, n__);\
 	})
 # ifndef wmemdupa
 #  define wmemdupa(s, n) libsimple_wmemdupa(s, n)
@@ -29,7 +30,7 @@
  * @param   n  The number of wide characters to copy
  * @return     Duplicate of `s`, `NULL` on failure
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t), __alloc_size__(2), __warn_unused_result__)))
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t), __alloc_size__(2), __warn_unused_result__)))
 wchar_t *libsimple_wmemdup(const wchar_t *, size_t);
 #ifndef wmemdup
 # define wmemdup libsimple_wmemdup
@@ -44,7 +45,7 @@ wchar_t *libsimple_wmemdup(const wchar_t *, size_t);
  * @param   n       The number of wide characters to copy
  * @return          Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t), __alloc_size__(3),
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t), __alloc_size__(3),
                                    __warn_unused_result__, __returns_nonnull__)))
 wchar_t *libsimple_enwmemdup(int, const wchar_t *, size_t);
 #ifndef enwmemdup
@@ -59,12 +60,12 @@ wchar_t *libsimple_enwmemdup(int, const wchar_t *, size_t);
  * @param   n  The number of wide characters to copy
  * @return     Duplicate of `s`
  */
-_LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, _libsimple_assume_aligned_as(wchar_t), __alloc_size__(2),
+LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, libsimple_assume_aligned_as__(wchar_t), __alloc_size__(2),
                                    __warn_unused_result__, __returns_nonnull__)))
 inline wchar_t *
-libsimple_ewmemdup(const wchar_t *__s, size_t __n)
+libsimple_ewmemdup(const wchar_t *s__, size_t n__)
 {
-	return libsimple_enwmemdup(libsimple_default_failure_exit, __s, __n);
+	return libsimple_enwmemdup(libsimple_default_failure_exit, s__, n__);
 }
 #ifndef ewmemdup
 # define ewmemdup libsimple_ewmemdup
diff --git a/man3/libsimple_aligned_allocz.3 b/man3/libsimple_aligned_allocz.3
index 0bee4d9..b61232b 100644
--- a/man3/libsimple_aligned_allocz.3
+++ b/man3/libsimple_aligned_allocz.3
@@ -6,9 +6,9 @@ libsimple_aligned_allocz \- allocate optionally initialised memory with custom a
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_aligned_allocz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_aligned_allocz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 void *libsimple_enaligned_allocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_ealigned_allocz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_ealigned_allocz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_allocz
 # define aligned_allocz libsimple_aligned_allocz
diff --git a/man3/libsimple_aligned_memdup.3 b/man3/libsimple_aligned_memdup.3
index cff094d..14d6c7a 100644
--- a/man3/libsimple_aligned_memdup.3
+++ b/man3/libsimple_aligned_memdup.3
@@ -9,7 +9,7 @@ libsimple_aligned_memdup, libsimple_aligned_memdupa \- duplicate bytes in memory
 void *libsimple_aligned_memdupa(const void *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 void *libsimple_aligned_memdup(const void *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 void *libsimple_enaligned_memdup(int \fIstatus\fP, const void *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_ealigned_memdup(const void *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_ealigned_memdup(const void *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_memdupa
 # define aligned_memdupa libsimple_aligned_memdupa
diff --git a/man3/libsimple_aligned_realloc.3 b/man3/libsimple_aligned_realloc.3
index 1845408..0e176b9 100644
--- a/man3/libsimple_aligned_realloc.3
+++ b/man3/libsimple_aligned_realloc.3
@@ -6,9 +6,9 @@ libsimple_aligned_realloc \- reallocate memory and customise alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_aligned_realloc(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_aligned_realloc(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 void *libsimple_enaligned_realloc(int \fIstatus\fP, void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_ealigned_realloc(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_ealigned_realloc(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_realloc
 # define aligned_realloc libsimple_aligned_realloc
diff --git a/man3/libsimple_aligned_reallocarray.3 b/man3/libsimple_aligned_reallocarray.3
index e056c72..c4cc765 100644
--- a/man3/libsimple_aligned_reallocarray.3
+++ b/man3/libsimple_aligned_reallocarray.3
@@ -6,9 +6,9 @@ libsimple_aligned_reallocarray \- reallocate memory and customise alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_aligned_reallocarray(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_aligned_reallocarray(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
 void *libsimple_enaligned_reallocarray(int \fIstatus\fP, void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
-static inline void *libsimple_ealigned_reallocarray(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_ealigned_reallocarray(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
 
 #ifndef aligned_reallocarray
 # define aligned_reallocarray libsimple_aligned_reallocarray
diff --git a/man3/libsimple_aligned_reallocarrayf.3 b/man3/libsimple_aligned_reallocarrayf.3
index 998d49a..46a4057 100644
--- a/man3/libsimple_aligned_reallocarrayf.3
+++ b/man3/libsimple_aligned_reallocarrayf.3
@@ -6,7 +6,7 @@ libsimple_aligned_reallocarrayf \- reallocate memory and customise alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_aligned_reallocarrayf(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_aligned_reallocarrayf(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, size_t \fIm\fP);
 
 #ifndef aligned_reallocarrayf
 # define aligned_reallocarrayf libsimple_aligned_reallocarrayf
diff --git a/man3/libsimple_aligned_reallocf.3 b/man3/libsimple_aligned_reallocf.3
index 97d6dff..4ad9fcc 100644
--- a/man3/libsimple_aligned_reallocf.3
+++ b/man3/libsimple_aligned_reallocf.3
@@ -6,7 +6,7 @@ libsimple_aligned_reallocf \- reallocate memory and customise alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_aligned_reallocf(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_aligned_reallocf(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_reallocf
 # define aligned_reallocf libsimple_aligned_reallocf
diff --git a/man3/libsimple_aligned_strdup.3 b/man3/libsimple_aligned_strdup.3
index 1570e68..c365a18 100644
--- a/man3/libsimple_aligned_strdup.3
+++ b/man3/libsimple_aligned_strdup.3
@@ -9,7 +9,7 @@ libsimple_aligned_strdup, libsimple_aligned_strdupa \- duplicate a string
 char *libsimple_aligned_strdupa(const char *\fIs\fP, size_t \fIn\fP);
 char *libsimple_aligned_strdup(const char *\fIs\fP, size_t \fIn\fP);
 char *libsimple_enaligned_strdup(int \fIstatus\fP, const char *\fIs\fP, size_t \fIn\fP);
-static inline char *libsimple_ealigned_strdup(const char *\fIs\fP, size_t \fIn\fP);
+inline char *libsimple_ealigned_strdup(const char *\fIs\fP, size_t \fIn\fP);
 
 #ifndef aligned_strdupa
 # define aligned_strdupa libsimple_aligned_strdupa
diff --git a/man3/libsimple_aligned_strndup.3 b/man3/libsimple_aligned_strndup.3
index 05c6d3a..773f0ee 100644
--- a/man3/libsimple_aligned_strndup.3
+++ b/man3/libsimple_aligned_strndup.3
@@ -9,7 +9,7 @@ libsimple_aligned_strndup, libsimple_aligned_strndupa \- duplicate a string
 char *libsimple_aligned_strndupa(const char *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 char *libsimple_aligned_strndup(const char *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 char *libsimple_enaligned_strndup(int \fIstatus\fP, const char *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline char *libsimple_ealigned_strndup(const char *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline char *libsimple_ealigned_strndup(const char *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_strndupa
 # define aligned_strndupa libsimple_aligned_strndupa
diff --git a/man3/libsimple_aligned_wcsdup.3 b/man3/libsimple_aligned_wcsdup.3
index 42f9cd9..6332064 100644
--- a/man3/libsimple_aligned_wcsdup.3
+++ b/man3/libsimple_aligned_wcsdup.3
@@ -9,7 +9,7 @@ libsimple_aligned_wcsdup, libsimple_aligned_wcsdupa \- duplicate a wide-characte
 wchar_t *libsimple_aligned_wcsdupa(const wchar_t *\fIs\fP, size_t \fIalignment\fP);
 wchar_t *libsimple_aligned_wcsdup(const wchar_t *\fIs\fP, size_t \fIalignment\fP);
 wchar_t *libsimple_enaligned_wcsdup(int \fIstatus\fP, const wchar_t *\fIs\fP, size_t \fIalignment\fP);
-static inline wchar_t *libsimple_ealigned_wcsdup(const wchar_t *\fIs\fP, size_t \fIalignment\fP);
+inline wchar_t *libsimple_ealigned_wcsdup(const wchar_t *\fIs\fP, size_t \fIalignment\fP);
 
 #ifndef aligned_wcsdupa
 # define aligned_wcsdupa libsimple_aligned_wcsdupa
diff --git a/man3/libsimple_aligned_wcsndup.3 b/man3/libsimple_aligned_wcsndup.3
index 669b790..f70a099 100644
--- a/man3/libsimple_aligned_wcsndup.3
+++ b/man3/libsimple_aligned_wcsndup.3
@@ -9,7 +9,7 @@ libsimple_aligned_wcsndup, libsimple_aligned_wcsndupa \- duplicate a wide-charac
 wchar_t *libsimple_aligned_wcsndupa(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 wchar_t *libsimple_aligned_wcsndup(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 wchar_t *libsimple_enaligned_wcsndup(int \fIstatus\fP, const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline wchar_t *libsimple_ealigned_wcsndup(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline wchar_t *libsimple_ealigned_wcsndup(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_wcsndupa
 # define aligned_wcsndupa libsimple_aligned_wcsndupa
diff --git a/man3/libsimple_aligned_wmemdup.3 b/man3/libsimple_aligned_wmemdup.3
index a269082..353d716 100644
--- a/man3/libsimple_aligned_wmemdup.3
+++ b/man3/libsimple_aligned_wmemdup.3
@@ -9,7 +9,7 @@ libsimple_aligned_wmemdup, libsimple_aligned_wmemdupa \- duplicate a wide-charac
 wchar_t *libsimple_aligned_wmemdupa(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 wchar_t *libsimple_aligned_wmemdup(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 wchar_t *libsimple_enaligned_wmemdup(int \fIstatus\fP, const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline wchar_t *libsimple_ealigned_wmemdup(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline wchar_t *libsimple_ealigned_wmemdup(const wchar_t *\fIs\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef aligned_wmemdupa
 # define aligned_wmemdupa libsimple_aligned_wmemdupa
diff --git a/man3/libsimple_close.3 b/man3/libsimple_close.3
index d9fb852..7050899 100644
--- a/man3/libsimple_close.3
+++ b/man3/libsimple_close.3
@@ -6,7 +6,7 @@ libsimple_close \- close file descriptor and mark it as closed
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_close(int *\fIfdp\fP);
+inline int libsimple_close(int *\fIfdp\fP);
 .fi
 .PP
 Link with
diff --git a/man3/libsimple_cmptimespec.3 b/man3/libsimple_cmptimespec.3
index 9d6869a..34de111 100644
--- a/man3/libsimple_cmptimespec.3
+++ b/man3/libsimple_cmptimespec.3
@@ -6,8 +6,8 @@ libsimple_cmptimespec, libsimple_cmptimeval \- calculate the sum of two duration
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_cmptimespec(const struct timespec *\fIa\fP, const struct timespec *\fIb\fP);
-static inline int libsimple_cmptimeval(const struct timeval *\fIa\fP, const struct timeval *\fIb\fP);
+inline int libsimple_cmptimespec(const struct timespec *\fIa\fP, const struct timespec *\fIb\fP);
+inline int libsimple_cmptimeval(const struct timeval *\fIa\fP, const struct timeval *\fIb\fP);
 
 #ifndef cmptimespec
 # define cmptimespec libsimple_cmptimespec
diff --git a/man3/libsimple_enaligned_alloc.3 b/man3/libsimple_enaligned_alloc.3
index 27abe3d..0e6c4c7 100644
--- a/man3/libsimple_enaligned_alloc.3
+++ b/man3/libsimple_enaligned_alloc.3
@@ -6,8 +6,8 @@ libsimple_enaligned_alloc \- allocate memory with custom alignment or die
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_enaligned_alloc(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_ealigned_alloc(size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_enaligned_alloc(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_ealigned_alloc(size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef enaligned_alloc
 # define enaligned_alloc libsimple_enaligned_alloc
diff --git a/man3/libsimple_encalloc.3 b/man3/libsimple_encalloc.3
index 905bdd2..c373fa5 100644
--- a/man3/libsimple_encalloc.3
+++ b/man3/libsimple_encalloc.3
@@ -7,7 +7,7 @@ libsimple_encalloc \- allocate initialised memory or die
 #include <libsimple.h>
 
 void *libsimple_encalloc(int \fIstatus\fP, size_t \fIn\fP, size_t \fIm\fP);
-static inline void *libsimple_ecalloc(size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_ecalloc(size_t \fIn\fP, size_t \fIm\fP);
 
 #ifndef encalloc
 # define encalloc libsimple_encalloc
diff --git a/man3/libsimple_enmalloc.3 b/man3/libsimple_enmalloc.3
index 975f44c..c1d166a 100644
--- a/man3/libsimple_enmalloc.3
+++ b/man3/libsimple_enmalloc.3
@@ -7,7 +7,7 @@ libsimple_enmalloc \- allocate memory or die
 #include <libsimple.h>
 
 void *libsimple_enmalloc(int \fIstatus\fP, size_t \fIn\fP);
-static inline void *libsimple_emalloc(size_t \fIn\fP);
+inline void *libsimple_emalloc(size_t \fIn\fP);
 
 #ifndef enmalloc
 # define enmalloc libsimple_enmalloc
diff --git a/man3/libsimple_enposix_memalign.3 b/man3/libsimple_enposix_memalign.3
index 1d8ec20..33df98e 100644
--- a/man3/libsimple_enposix_memalign.3
+++ b/man3/libsimple_enposix_memalign.3
@@ -6,8 +6,8 @@ libsimple_enposix_memalign \- allocate memory with custom alignment or die
 .nf
 #include <libsimple.h>
 
-static inline void libsimple_enposix_memalign(int \fIstatus\fP, void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void libsimple_eposix_memalign(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void libsimple_enposix_memalign(int \fIstatus\fP, void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void libsimple_eposix_memalign(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef enposix_memalign
 # define enposix_memalign libsimple_enposix_memalign
diff --git a/man3/libsimple_enrealloc.3 b/man3/libsimple_enrealloc.3
index 829a0f5..430fecd 100644
--- a/man3/libsimple_enrealloc.3
+++ b/man3/libsimple_enrealloc.3
@@ -7,7 +7,7 @@ libsimple_enrealloc \- reallocate memory or die
 #include <libsimple.h>
 
 void *libsimple_enrealloc(int \fIstatus\fP, void *\fIptr\fP, size_t \fIn\fP);
-static inline void *libsimple_erealloc(void *\fIptr\fP, size_t \fIn\fP);
+inline void *libsimple_erealloc(void *\fIptr\fP, size_t \fIn\fP);
 
 #ifndef enrealloc
 # define enrealloc libsimple_enrealloc
diff --git a/man3/libsimple_enstrdup.3 b/man3/libsimple_enstrdup.3
index 33cc6c7..b6224f4 100644
--- a/man3/libsimple_enstrdup.3
+++ b/man3/libsimple_enstrdup.3
@@ -8,7 +8,7 @@ libsimple_enstrdup, libsimple_strdupa \- duplicate a string
 
 char *libsimple_strdupa(const char *\fIs\fP);
 char *libsimple_enstrdup(int \fIstatus\fP, const char *\fIs\fP);
-static inline char *libsimple_estrdup(const char *\fIs\fP);
+inline char *libsimple_estrdup(const char *\fIs\fP);
 
 #ifndef strdupa
 # define strdupa libsimple_strdupa
diff --git a/man3/libsimple_enstrndup.3 b/man3/libsimple_enstrndup.3
index 2c62600..455f895 100644
--- a/man3/libsimple_enstrndup.3
+++ b/man3/libsimple_enstrndup.3
@@ -8,7 +8,7 @@ libsimple_enstrndup, libsimple_strndupa \- duplicate the beginning of a string
 
 char *libsimple_strndupa(const char *\fIs\fP, size_t \fIn\fP);
 char *libsimple_enstrndup(int \fIstatus\fP, const char *\fIs\fP, size_t \fIn\fP);
-static inline char *libsimple_estrndup(const char *\fIs\fP, size_t \fIn\fP);
+inline char *libsimple_estrndup(const char *\fIs\fP, size_t \fIn\fP);
 
 #ifndef strndupa
 # define strndupa libsimple_strndupa
diff --git a/man3/libsimple_enwcsdup.3 b/man3/libsimple_enwcsdup.3
index df013a8..10560b4 100644
--- a/man3/libsimple_enwcsdup.3
+++ b/man3/libsimple_enwcsdup.3
@@ -8,7 +8,7 @@ libsimple_enwcsdup, libsimple_wcsdupa \- duplicate a wide-character string
 
 wchar_t *libsimple_wcsdupa(const wchar_t *\fIs\fP);
 wchar_t *libsimple_enwcsdup(int \fIstatus\fP, const wchar_t *\fIs\fP);
-static inline char *libsimple_ewcsdup(const wchar_t *\fIs\fP);
+inline char *libsimple_ewcsdup(const wchar_t *\fIs\fP);
 
 #ifndef wcsdupa
 # define wcsdupa libsimple_wcsdupa
diff --git a/man3/libsimple_getenv_e.3 b/man3/libsimple_getenv_e.3
index 0ed445b..c9d12e3 100644
--- a/man3/libsimple_getenv_e.3
+++ b/man3/libsimple_getenv_e.3
@@ -6,7 +6,7 @@ libsimple_getenv_e \- get value of an environment variable or the empty string
 .nf
 #include <libsimple.h>
 
-static inline const char *libsimple_getenv_e(const char *\fIname\fP);
+inline const char *libsimple_getenv_e(const char *\fIname\fP);
 
 #ifndef getenv_e
 # define getenv_e libsimple_getenv_e
diff --git a/man3/libsimple_getenv_ne.3 b/man3/libsimple_getenv_ne.3
index 69c7de8..574b78e 100644
--- a/man3/libsimple_getenv_ne.3
+++ b/man3/libsimple_getenv_ne.3
@@ -6,7 +6,7 @@ libsimple_getenv_ne \- get non-empty value of an environment variable
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_getenv_ne(const char *\fIname\fP);
+inline char *libsimple_getenv_ne(const char *\fIname\fP);
 
 #ifndef getenv_ne
 # define getenv_ne libsimple_getenv_ne
diff --git a/man3/libsimple_gmtime.3 b/man3/libsimple_gmtime.3
index be050f2..ac5ab17 100644
--- a/man3/libsimple_gmtime.3
+++ b/man3/libsimple_gmtime.3
@@ -7,8 +7,8 @@ libsimple_gmtime \- get the current UTC time with leap second adjustment
 #include <libsimple.h>
 
 int libsimple_gmtime(struct tm *\fItm\fP, struct timespec *\fIts\fP);
-static inline void libsimple_engmtime(int \fIstatus\fPstruct tm *\fItm\fP, struct timespec *\fIts\fP);
-static inline void libsimple_egmtime(struct tm *\fItm\fP, struct timespec *\fIts\fP);
+inline void libsimple_engmtime(int \fIstatus\fPstruct tm *\fItm\fP, struct timespec *\fIts\fP);
+inline void libsimple_egmtime(struct tm *\fItm\fP, struct timespec *\fIts\fP);
 .fi
 .PP
 Link with
diff --git a/man3/libsimple_inchrset.3 b/man3/libsimple_inchrset.3
index 44a3eb1..07d1fe4 100644
--- a/man3/libsimple_inchrset.3
+++ b/man3/libsimple_inchrset.3
@@ -6,8 +6,8 @@ libsimple_inchrset, libsimple_inchrcaseset \- the whether a character belongs to
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_inchrset(int \fIc\fP, const char *\fIs\fP);
-static inline int libsimple_inchrcaseset(int \fIc\fP, const char *\fIs\fP);
+inline int libsimple_inchrset(int \fIc\fP, const char *\fIs\fP);
+inline int libsimple_inchrcaseset(int \fIc\fP, const char *\fIs\fP);
 
 #ifndef inchrset
 # define inchrset libsimple_inchrset
diff --git a/man3/libsimple_localtime.3 b/man3/libsimple_localtime.3
index 0f6aa19..18e0375 100644
--- a/man3/libsimple_localtime.3
+++ b/man3/libsimple_localtime.3
@@ -7,8 +7,8 @@ libsimple_localtime \- get the current local time with leap second adjustment
 #include <libsimple.h>
 
 int libsimple_localtime(struct tm *\fItm\fP, struct timespec *\fIts\fP);
-static inline void libsimple_enlocaltime(int \fIstatus\fPstruct tm *\fItm\fP, struct timespec *\fIts\fP);
-static inline void libsimple_elocaltime(struct tm *\fItm\fP, struct timespec *\fIts\fP);
+inline void libsimple_enlocaltime(int \fIstatus\fPstruct tm *\fItm\fP, struct timespec *\fIts\fP);
+inline void libsimple_elocaltime(struct tm *\fItm\fP, struct timespec *\fIts\fP);
 .fi
 .PP
 Link with
diff --git a/man3/libsimple_mallocz.3 b/man3/libsimple_mallocz.3
index 54ca3e7..e04c0c7 100644
--- a/man3/libsimple_mallocz.3
+++ b/man3/libsimple_mallocz.3
@@ -6,9 +6,9 @@ libsimple_mallocz \- allocate optionally initialised memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_mallocz(int \fIclear\fP, size_t \fIn\fP);
-static inline void *libsimple_enmallocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP);
-static inline void *libsimple_emallocz(int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_mallocz(int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_enmallocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_emallocz(int \fIclear\fP, size_t \fIn\fP);
 
 #ifndef mallocz
 # define mallocz libsimple_mallocz
diff --git a/man3/libsimple_memalign.3 b/man3/libsimple_memalign.3
index 8bbf57e..d8b0c89 100644
--- a/man3/libsimple_memalign.3
+++ b/man3/libsimple_memalign.3
@@ -6,9 +6,9 @@ libsimple_memalign \- allocate memory with custom alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memalign(size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_enmemalign(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_ememalign(size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_memalign(size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_enmemalign(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_ememalign(size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef memalign
 # define memalign libsimple_memalign
diff --git a/man3/libsimple_memalignz.3 b/man3/libsimple_memalignz.3
index f756539..c7e0af2 100644
--- a/man3/libsimple_memalignz.3
+++ b/man3/libsimple_memalignz.3
@@ -6,9 +6,9 @@ libsimple_memalignz \- allocate optionally initialised memory with custom alignm
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memalignz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_enmemalignz(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void *libsimple_ememalignz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_memalignz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_enmemalignz(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void *libsimple_ememalignz(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef memalignz
 # define memalignz libsimple_memalignz
diff --git a/man3/libsimple_memcasecmp.3 b/man3/libsimple_memcasecmp.3
index a7ccf79..e8852ae 100644
--- a/man3/libsimple_memcasecmp.3
+++ b/man3/libsimple_memcasecmp.3
@@ -6,7 +6,7 @@ libsimple_memcasecmp \- compare two memory segments
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_memcasecmp(const void *\fIa\fP, const void *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_memcasecmp(const void *\fIa\fP, const void *\fIb\fP, size_t \fIn\fP);
 
 #ifndef memcasecmp
 # define memcasecmp libsimple_memcasecmp
diff --git a/man3/libsimple_memcaseeq.3 b/man3/libsimple_memcaseeq.3
index c48b7c5..3728cd7 100644
--- a/man3/libsimple_memcaseeq.3
+++ b/man3/libsimple_memcaseeq.3
@@ -6,7 +6,7 @@ libsimple_memcaseeq \- check two memory segments for equality
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_memcaseeq(const void *\fIa\fP, const void *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_memcaseeq(const void *\fIa\fP, const void *\fIb\fP, size_t \fIn\fP);
 
 #ifndef memcaseeq
 # define memcaseeq libsimple_memcaseeq
diff --git a/man3/libsimple_memdup.3 b/man3/libsimple_memdup.3
index 8a6903d..756297c 100644
--- a/man3/libsimple_memdup.3
+++ b/man3/libsimple_memdup.3
@@ -9,7 +9,7 @@ libsimple_memdup \- duplicate bytes in memory
 void *libsimple_memdupa(const void *\fIs\fP, size_t \fIn\fP);
 void *libsimple_memdup(const void *\fIs\fP, size_t \fIn\fP);
 void *libsimple_enmemdup(int \fIstatus\fP, const void *\fIs\fP, size_t \fIn\fP);
-static inline void *libsimple_ememdup(const void *\fIs\fP, size_t \fIn\fP);
+inline void *libsimple_ememdup(const void *\fIs\fP, size_t \fIn\fP);
 
 #ifndef memdupa
 # define memdupa libsimple_memdupa
diff --git a/man3/libsimple_memelemmove.3 b/man3/libsimple_memelemmove.3
index 194ff79..5422d12 100644
--- a/man3/libsimple_memelemmove.3
+++ b/man3/libsimple_memelemmove.3
@@ -6,8 +6,8 @@ libsimple_memelemmove, libsimple_memelemcpy \- copy or move elements within an a
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memelemmove(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP, size_t \fIn\fP);
-static inline void *libsimple_memelemcpy(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP, size_t \fIn\fP);
+inline void *libsimple_memelemmove(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP, size_t \fIn\fP);
+inline void *libsimple_memelemcpy(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP, size_t \fIn\fP);
 
 #ifndef memelemmove
 # define memelemmove libsimple_memelemmove
diff --git a/man3/libsimple_memeq.3 b/man3/libsimple_memeq.3
index a5683e5..a04e975 100644
--- a/man3/libsimple_memeq.3
+++ b/man3/libsimple_memeq.3
@@ -6,7 +6,7 @@ libsimple_memeq \- check two memory segments for equality
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_memeq(const void *\fIa\fP, const void *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_memeq(const void *\fIa\fP, const void *\fIb\fP, size_t \fIn\fP);
 
 #ifndef memeq
 # define memeq libsimple_memeq
diff --git a/man3/libsimple_mempcpy.3 b/man3/libsimple_mempcpy.3
index a10bba0..3fe7865 100644
--- a/man3/libsimple_mempcpy.3
+++ b/man3/libsimple_mempcpy.3
@@ -6,7 +6,7 @@ libsimple_mempcpy \- copy an array of bytes into another
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_mempcpy(void *restrict \fIdest\fP, const void *restrict \fIsrc\fP, size_t \fIn\fP);
+inline void *libsimple_mempcpy(void *restrict \fIdest\fP, const void *restrict \fIsrc\fP, size_t \fIn\fP);
 
 #ifndef mempcpy
 # define mempcpy libsimple_mempcpy
diff --git a/man3/libsimple_mempmove.3 b/man3/libsimple_mempmove.3
index 29b7e4e..8a89ea1 100644
--- a/man3/libsimple_mempmove.3
+++ b/man3/libsimple_mempmove.3
@@ -6,7 +6,7 @@ libsimple_mempmove \- move bytes within an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_mempmove(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
+inline void *libsimple_mempmove(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef mempmove
 # define mempmove libsimple_mempmove
diff --git a/man3/libsimple_mempset.3 b/man3/libsimple_mempset.3
index 31ebd06..69e8951 100644
--- a/man3/libsimple_mempset.3
+++ b/man3/libsimple_mempset.3
@@ -6,7 +6,7 @@ libsimple_mempset \- fill an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_mempset(void *\fIs\fP, int \fIc\fP, size_t \fIn\fP);
+inline void *libsimple_mempset(void *\fIs\fP, int \fIc\fP, size_t \fIn\fP);
 
 #ifndef mempset
 # define mempset libsimple_mempset
diff --git a/man3/libsimple_memreplace.3 b/man3/libsimple_memreplace.3
index 45800bb..c77e9ed 100644
--- a/man3/libsimple_memreplace.3
+++ b/man3/libsimple_memreplace.3
@@ -6,7 +6,7 @@ libsimple_memreplace \- replace bytes in an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memreplace(void *\fIs\fP, int \fIold\fP, int \fInew\fP, size_t \fIn\fP);
+inline void *libsimple_memreplace(void *\fIs\fP, int \fIold\fP, int \fInew\fP, size_t \fIn\fP);
 
 #ifndef memreplace
 # define memreplace libsimple_memreplace
diff --git a/man3/libsimple_memsetelem.3 b/man3/libsimple_memsetelem.3
index 37e7022..2bbf488 100644
--- a/man3/libsimple_memsetelem.3
+++ b/man3/libsimple_memsetelem.3
@@ -6,7 +6,7 @@ libsimple_memsetelem \- fill an array with a value
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memsetelem(void *\fIbuf\fP, const void *\fIitem\fP, size_t \fIwidth\fP, size_t \fIn\fP);
+inline void *libsimple_memsetelem(void *\fIbuf\fP, const void *\fIitem\fP, size_t \fIwidth\fP, size_t \fIn\fP);
 
 #ifndef memsetelem
 # define memsetelem libsimple_memsetelem
diff --git a/man3/libsimple_memtolower.3 b/man3/libsimple_memtolower.3
index facb09d..8e36915 100644
--- a/man3/libsimple_memtolower.3
+++ b/man3/libsimple_memtolower.3
@@ -6,7 +6,7 @@ libsimple_memtolower, libsimple_memptolower \- convert a character array to lowe
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memtolower(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
+inline void *libsimple_memtolower(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 void *libsimple_memptolower(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef memtolower
diff --git a/man3/libsimple_memtoupper.3 b/man3/libsimple_memtoupper.3
index 17a747c..cbac534 100644
--- a/man3/libsimple_memtoupper.3
+++ b/man3/libsimple_memtoupper.3
@@ -6,7 +6,7 @@ libsimple_memtoupper, libsimple_memptoupper \- convert a character array to uppe
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_memtoupper(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
+inline void *libsimple_memtoupper(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 void *libsimple_memptoupper(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef memtoupper
diff --git a/man3/libsimple_posix_memalignz.3 b/man3/libsimple_posix_memalignz.3
index a82605f..e79e85b 100644
--- a/man3/libsimple_posix_memalignz.3
+++ b/man3/libsimple_posix_memalignz.3
@@ -6,9 +6,9 @@ libsimple_posix_memalignz \- allocate optionally initialised memory with custom
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_posix_memalignz(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline int libsimple_posix_memalignz(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 void libsimple_enposix_memalignz(int \fIstatus\fP, void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
-static inline void libsimple_eposix_memalignz(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
+inline void libsimple_eposix_memalignz(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP);
 
 #ifndef posix_memalignz
 # define posix_memalignz libsimple_posix_memalignz
diff --git a/man3/libsimple_pvalloc.3 b/man3/libsimple_pvalloc.3
index 9440712..e552a51 100644
--- a/man3/libsimple_pvalloc.3
+++ b/man3/libsimple_pvalloc.3
@@ -6,9 +6,9 @@ libsimple_pvalloc \- allocate memory with page size alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_pvalloc(size_t \fIn\fP);
-static inline void *libsimple_enpvalloc(int \fIstatus\fP, size_t \fIn\fP);
-static inline void *libsimple_epvalloc(size_t \fIn\fP);
+inline void *libsimple_pvalloc(size_t \fIn\fP);
+inline void *libsimple_enpvalloc(int \fIstatus\fP, size_t \fIn\fP);
+inline void *libsimple_epvalloc(size_t \fIn\fP);
 
 #ifndef pvalloc
 # define pvalloc libsimple_pvalloc
diff --git a/man3/libsimple_pvallocz.3 b/man3/libsimple_pvallocz.3
index 1fcc898..d18253a 100644
--- a/man3/libsimple_pvallocz.3
+++ b/man3/libsimple_pvallocz.3
@@ -6,9 +6,9 @@ libsimple_pvallocz \- allocate optionally initialised memory with page size alig
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_pvallocz(int \fIclear\fP, size_t \fIn\fP);
-static inline void *libsimple_enpvallocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP);
-static inline void *libsimple_epvallocz(int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_pvallocz(int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_enpvallocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_epvallocz(int \fIclear\fP, size_t \fIn\fP);
 
 #ifndef pvallocz
 # define pvallocz libsimple_pvallocz
diff --git a/man3/libsimple_rawmemcmove.3 b/man3/libsimple_rawmemcmove.3
index d4df247..246ccfa 100644
--- a/man3/libsimple_rawmemcmove.3
+++ b/man3/libsimple_rawmemcmove.3
@@ -6,8 +6,8 @@ libsimple_rawmemcmove, libsimple_rawmemccpy \- copy or move bytes within an arra
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_rawmemcmove(void *\fIdest\fP, const void *\fIsrc\fP, int \fIc\fP);
-static inline void *libsimple_rawmemccpy(void *\fIdest\fP, const void *\fIsrc\fP, int \fIc\fP);
+inline void *libsimple_rawmemcmove(void *\fIdest\fP, const void *\fIsrc\fP, int \fIc\fP);
+inline void *libsimple_rawmemccpy(void *\fIdest\fP, const void *\fIsrc\fP, int \fIc\fP);
 
 #ifndef rawmemcmove
 # define rawmemcmove libsimple_rawmemcmove
diff --git a/man3/libsimple_rawmemelemmove.3 b/man3/libsimple_rawmemelemmove.3
index da7b242..6b0f7a3 100644
--- a/man3/libsimple_rawmemelemmove.3
+++ b/man3/libsimple_rawmemelemmove.3
@@ -6,8 +6,8 @@ libsimple_rawmemelemmove, libsimple_rawmemelemcpy \- copy or move elements withi
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_rawmemelemmove(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP);
-static inline void *libsimple_rawmemelemcpy(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP);
+inline void *libsimple_rawmemelemmove(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP);
+inline void *libsimple_rawmemelemcpy(void *\fIdest\fP, const void *\fIsrc\fP, int \fIelem\fP, size_t \fIwidth\fP);
 
 #ifndef rawmemelemmove
 # define rawmemelemmove libsimple_rawmemelemmove
diff --git a/man3/libsimple_reallocarray.3 b/man3/libsimple_reallocarray.3
index c6c6635..5626e63 100644
--- a/man3/libsimple_reallocarray.3
+++ b/man3/libsimple_reallocarray.3
@@ -6,9 +6,9 @@ libsimple_reallocarray \- reallocate memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_reallocarray(void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
-static inline void *libsimple_enreallocarray(int \fIstatus\fP, void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
-static inline void *libsimple_ereallocarray(void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_reallocarray(void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_enreallocarray(int \fIstatus\fP, void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_ereallocarray(void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
 
 #ifndef reallocarray
 # define reallocarray libsimple_reallocarray
diff --git a/man3/libsimple_reallocarrayf.3 b/man3/libsimple_reallocarrayf.3
index b3c2504..f0d3104 100644
--- a/man3/libsimple_reallocarrayf.3
+++ b/man3/libsimple_reallocarrayf.3
@@ -6,7 +6,7 @@ libsimple_reallocarrayf \- reallocate memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_reallocarrayf(void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
+inline void *libsimple_reallocarrayf(void *\fIptr\fP, size_t \fIn\fP, size_t \fIm\fP);
 
 #ifndef reallocarrayf
 # define reallocarrayf libsimple_reallocarrayf
diff --git a/man3/libsimple_reallocf.3 b/man3/libsimple_reallocf.3
index b0c2d1b..d3b7523 100644
--- a/man3/libsimple_reallocf.3
+++ b/man3/libsimple_reallocf.3
@@ -6,7 +6,7 @@ libsimple_reallocf \- reallocate memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_reallocf(void *\fIptr\fP, size_t \fIn\fP);
+inline void *libsimple_reallocf(void *\fIptr\fP, size_t \fIn\fP);
 
 #ifndef reallocf
 # define reallocf libsimple_reallocf
diff --git a/man3/libsimple_stpmove.3 b/man3/libsimple_stpmove.3
index d9e8db1..09eb764 100644
--- a/man3/libsimple_stpmove.3
+++ b/man3/libsimple_stpmove.3
@@ -6,7 +6,7 @@ libsimple_stpmove \- move a string within an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_stpmove(void *\fIdest\fP, const void *\fIsrc\fP);
+inline void *libsimple_stpmove(void *\fIdest\fP, const void *\fIsrc\fP);
 
 #ifndef stpmove
 # define stpmove libsimple_stpmove
diff --git a/man3/libsimple_stpnmove.3 b/man3/libsimple_stpnmove.3
index f2fd267..7d3b4a9 100644
--- a/man3/libsimple_stpnmove.3
+++ b/man3/libsimple_stpnmove.3
@@ -6,7 +6,7 @@ libsimple_stpnmove \- move a string within an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_stpnmove(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
+inline void *libsimple_stpnmove(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef stpnmove
 # define stpnmove libsimple_stpnmove
diff --git a/man3/libsimple_strcasecmpnul.3 b/man3/libsimple_strcasecmpnul.3
index 1f4561e..48b9dce 100644
--- a/man3/libsimple_strcasecmpnul.3
+++ b/man3/libsimple_strcasecmpnul.3
@@ -6,7 +6,7 @@ libsimple_strcasecmpnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strcasecmpnul(const char *\fIa\fP, const char *\fIb\fP);
+inline int libsimple_strcasecmpnul(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef strcasecmpnul
 # define strcasecmpnul libsimple_strcasecmpnul
diff --git a/man3/libsimple_strcaseeq.3 b/man3/libsimple_strcaseeq.3
index e0dbf7f..737565a 100644
--- a/man3/libsimple_strcaseeq.3
+++ b/man3/libsimple_strcaseeq.3
@@ -6,7 +6,7 @@ libsimple_strcaseeq \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strcaseeq(const char *\fIa\fP, const char *\fIb\fP);
+inline int libsimple_strcaseeq(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef strcaseeq
 # define strcaseeq libsimple_strcaseeq
diff --git a/man3/libsimple_strcaseeqnul.3 b/man3/libsimple_strcaseeqnul.3
index 27595b0..4e4ac0c 100644
--- a/man3/libsimple_strcaseeqnul.3
+++ b/man3/libsimple_strcaseeqnul.3
@@ -6,7 +6,7 @@ libsimple_strcaseeqnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strcaseeqnul(const char *\fIa\fP, const char *\fIb\fP);
+inline int libsimple_strcaseeqnul(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef strcaseeqnul
 # define strcaseeqnul libsimple_strcaseeqnul
diff --git a/man3/libsimple_strcasestarts.3 b/man3/libsimple_strcasestarts.3
index bf6786c..2f30942 100644
--- a/man3/libsimple_strcasestarts.3
+++ b/man3/libsimple_strcasestarts.3
@@ -6,7 +6,7 @@ libsimple_strcasestarts \- check the beginning of a string
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strcasestarts(const char *\fIs\fP, const char *\fIt\fP);
+inline int libsimple_strcasestarts(const char *\fIs\fP, const char *\fIt\fP);
 
 #ifndef strcasestarts
 # define strcasestarts libsimple_strcasestarts
diff --git a/man3/libsimple_strcmove.3 b/man3/libsimple_strcmove.3
index 4888832..44b3579 100644
--- a/man3/libsimple_strcmove.3
+++ b/man3/libsimple_strcmove.3
@@ -7,7 +7,7 @@ libsimple_strcmove, libsimple_strccpy \- copy or move a string within an array o
 #include <libsimple.h>
 
 char *libsimple_strcmove(char *\fIdest\fP, const char *\fIsrc\fP, int \fIc\fP);
-static inline char *libsimple_strccpy(char *restrict \fIdest\fP, const char *restrict \fIsrc\fP, int \fIc\fP);
+inline char *libsimple_strccpy(char *restrict \fIdest\fP, const char *restrict \fIsrc\fP, int \fIc\fP);
 
 #ifndef strcmove
 # define strcmove libsimple_strcmove
diff --git a/man3/libsimple_strcmpnul.3 b/man3/libsimple_strcmpnul.3
index 01a512c..f196ded 100644
--- a/man3/libsimple_strcmpnul.3
+++ b/man3/libsimple_strcmpnul.3
@@ -6,7 +6,7 @@ libsimple_strcmpnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strcmpnul(const char *\fIa\fP, const char *\fIb\fP);
+inline int libsimple_strcmpnul(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef strcmpnul
 # define strcmpnul libsimple_strcmpnul
diff --git a/man3/libsimple_strend.3 b/man3/libsimple_strend.3
index a3a1bfe..e046742 100644
--- a/man3/libsimple_strend.3
+++ b/man3/libsimple_strend.3
@@ -6,7 +6,7 @@ libsimple_strend \- find a character in a string
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strend(const char *\fIs\fP);
+inline char *libsimple_strend(const char *\fIs\fP);
 
 #ifndef strend
 # define strend libsimple_strend
diff --git a/man3/libsimple_streq.3 b/man3/libsimple_streq.3
index 2a1fada..372a85b 100644
--- a/man3/libsimple_streq.3
+++ b/man3/libsimple_streq.3
@@ -6,7 +6,7 @@ libsimple_streq \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_streq(const char *\fIa\fP, const char *\fIb\fP);
+inline int libsimple_streq(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef streq
 # define streq libsimple_streq
diff --git a/man3/libsimple_streqnul.3 b/man3/libsimple_streqnul.3
index f2d7d07..f2474ad 100644
--- a/man3/libsimple_streqnul.3
+++ b/man3/libsimple_streqnul.3
@@ -6,7 +6,7 @@ libsimple_streqnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_streqnul(const char *\fIa\fP, const char *\fIb\fP);
+inline int libsimple_streqnul(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef streqnul
 # define streqnul libsimple_streqnul
diff --git a/man3/libsimple_strisutf8.3 b/man3/libsimple_strisutf8.3
index 0a525f1..3eecce6 100644
--- a/man3/libsimple_strisutf8.3
+++ b/man3/libsimple_strisutf8.3
@@ -6,8 +6,8 @@ libsimple_strisutf8, libsimple_strnisutf8, libsimple_memisutf8 \- check if a str
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strisutf8(const char *\fIstring\fP, int \fIallow_modified_nul\fP);
-static inline int libsimple_strnisutf8(const char *\fIstring\fP, size_t \fIn\fP, int \fIallow_modified_nul\fP);
+inline int libsimple_strisutf8(const char *\fIstring\fP, int \fIallow_modified_nul\fP);
+inline int libsimple_strnisutf8(const char *\fIstring\fP, size_t \fIn\fP, int \fIallow_modified_nul\fP);
 int libsimple_memisutf8(const char *\fIstring\fP, size_t \fIn\fP, int \fIallow_modified_nul\fP);
 
 #ifndef strisutf8
diff --git a/man3/libsimple_strmove.3 b/man3/libsimple_strmove.3
index 1b03800..a0b492c 100644
--- a/man3/libsimple_strmove.3
+++ b/man3/libsimple_strmove.3
@@ -6,7 +6,7 @@ libsimple_strmove \- move a string within an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strmove(char *\fIdest\fP, const char *\fIsrc\fP);
+inline char *libsimple_strmove(char *\fIdest\fP, const char *\fIsrc\fP);
 
 #ifndef strmove
 # define strmove libsimple_strmove
diff --git a/man3/libsimple_strncasecmpnul.3 b/man3/libsimple_strncasecmpnul.3
index 25b7239..aa7272d 100644
--- a/man3/libsimple_strncasecmpnul.3
+++ b/man3/libsimple_strncasecmpnul.3
@@ -6,7 +6,7 @@ libsimple_strncasecmpnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strncasecmpnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_strncasecmpnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strncasecmpnul
 # define strncasecmpnul libsimple_strncasecmpnul
diff --git a/man3/libsimple_strncaseeq.3 b/man3/libsimple_strncaseeq.3
index 5b7a6a9..ff880ac 100644
--- a/man3/libsimple_strncaseeq.3
+++ b/man3/libsimple_strncaseeq.3
@@ -6,7 +6,7 @@ libsimple_strncaseeq \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strncaseeq(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_strncaseeq(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strncaseeq
 # define strncaseeq libsimple_strncaseeq
diff --git a/man3/libsimple_strncaseeqnul.3 b/man3/libsimple_strncaseeqnul.3
index b713996..0805f5a 100644
--- a/man3/libsimple_strncaseeqnul.3
+++ b/man3/libsimple_strncaseeqnul.3
@@ -6,7 +6,7 @@ libsimple_strncaseeqnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strncaseeqnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_strncaseeqnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strncaseeqnul
 # define strncaseeqnul libsimple_strncaseeqnul
diff --git a/man3/libsimple_strncmove.3 b/man3/libsimple_strncmove.3
index 0f33ad9..4cdc0d3 100644
--- a/man3/libsimple_strncmove.3
+++ b/man3/libsimple_strncmove.3
@@ -7,7 +7,7 @@ libsimple_strncmove, libsimple_strnccpy \- copy or move a string within an array
 #include <libsimple.h>
 
 char *libsimple_strncmove(char *\fIdest\fP, const char *\fIsrc\fP, int \fIc\fP, size_t \fIn\fP);
-static inline char *libsimple_strnccpy(char *restrict \fIdest\fP, const char *restrict \fIsrc\fP, int \fIc\fP, size_t \fIn\fP);
+inline char *libsimple_strnccpy(char *restrict \fIdest\fP, const char *restrict \fIsrc\fP, int \fIc\fP, size_t \fIn\fP);
 
 #ifndef strncmove
 # define strncmove libsimple_strncmove
diff --git a/man3/libsimple_strncmpnul.3 b/man3/libsimple_strncmpnul.3
index d6a6cbe..fbb1e53 100644
--- a/man3/libsimple_strncmpnul.3
+++ b/man3/libsimple_strncmpnul.3
@@ -6,7 +6,7 @@ libsimple_strncmpnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strncmpnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_strncmpnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strncmpnul
 # define strncmpnul libsimple_strncmpnul
diff --git a/man3/libsimple_strnend.3 b/man3/libsimple_strnend.3
index c3d918d..f5c2f53 100644
--- a/man3/libsimple_strnend.3
+++ b/man3/libsimple_strnend.3
@@ -6,7 +6,7 @@ libsimple_strnend \- find a character in a string
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strnend(const char *\fIs\fP, size_t \fIn\fP);
+inline char *libsimple_strnend(const char *\fIs\fP, size_t \fIn\fP);
 
 #ifndef strnend
 # define strnend libsimple_strnend
diff --git a/man3/libsimple_strneq.3 b/man3/libsimple_strneq.3
index 43f2442..f447bc6 100644
--- a/man3/libsimple_strneq.3
+++ b/man3/libsimple_strneq.3
@@ -6,7 +6,7 @@ libsimple_strneq \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strneq(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_strneq(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strneq
 # define strneq libsimple_strneq
diff --git a/man3/libsimple_strneqnul.3 b/man3/libsimple_strneqnul.3
index b3de167..96dcae6 100644
--- a/man3/libsimple_strneqnul.3
+++ b/man3/libsimple_strneqnul.3
@@ -6,7 +6,7 @@ libsimple_strneqnul \- compare two strings
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_strneqnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline int libsimple_strneqnul(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strneqnul
 # define strneqnul libsimple_strneqnul
diff --git a/man3/libsimple_strnmove.3 b/man3/libsimple_strnmove.3
index 38c58f6..e817bb4 100644
--- a/man3/libsimple_strnmove.3
+++ b/man3/libsimple_strnmove.3
@@ -6,7 +6,7 @@ libsimple_strnmove \- move a string within an array of bytes
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_strnmove(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
+inline void *libsimple_strnmove(void *\fIdest\fP, const void *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef strnmove
 # define strnmove libsimple_strnmove
diff --git a/man3/libsimple_strnreplace.3 b/man3/libsimple_strnreplace.3
index fc8718c..0c73a2f 100644
--- a/man3/libsimple_strnreplace.3
+++ b/man3/libsimple_strnreplace.3
@@ -6,7 +6,7 @@ libsimple_strnreplace \- replace characters in a string
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strnreplace(char *\fIs\fP, int \fIold\fP, int \fInew\fP, size_t \fIn\fP);
+inline char *libsimple_strnreplace(char *\fIs\fP, int \fIold\fP, int \fInew\fP, size_t \fIn\fP);
 
 #ifndef strnreplace
 # define strnreplace libsimple_strnreplace
diff --git a/man3/libsimple_strnset.3 b/man3/libsimple_strnset.3
index 1a9ce21..1991b5d 100644
--- a/man3/libsimple_strnset.3
+++ b/man3/libsimple_strnset.3
@@ -6,8 +6,8 @@ libsimple_strnset, libsimple_stpnset \- fill a string with a character
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strnset(char *\fIs\fP, int \fIc\fP, size_t \fIn\fP);
-static inline char *libsimple_stpnset(char *\fIs\fP, int \fIc\fP, size_t \fIn\fP);
+inline char *libsimple_strnset(char *\fIs\fP, int \fIc\fP, size_t \fIn\fP);
+inline char *libsimple_stpnset(char *\fIs\fP, int \fIc\fP, size_t \fIn\fP);
 
 #ifndef strnset
 # define strnset libsimple_strnset
diff --git a/man3/libsimple_strntolower.3 b/man3/libsimple_strntolower.3
index 8c0f41c..061666e 100644
--- a/man3/libsimple_strntolower.3
+++ b/man3/libsimple_strntolower.3
@@ -6,7 +6,7 @@ libsimple_strntolower, libsimple_stpntolower \- convert a string to lower case
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strntolower(char *\fIdest\fP, const char *\fIsrc\fP, size_t \fIn\fP);
+inline char *libsimple_strntolower(char *\fIdest\fP, const char *\fIsrc\fP, size_t \fIn\fP);
 char *libsimple_stpntolower(char *\fIdest\fP, const char *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef strntolower
diff --git a/man3/libsimple_strntoupper.3 b/man3/libsimple_strntoupper.3
index abb3408..995f6bf 100644
--- a/man3/libsimple_strntoupper.3
+++ b/man3/libsimple_strntoupper.3
@@ -6,7 +6,7 @@ libsimple_strntoupper, libsimple_stpntoupper \- convert a string to upper case
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strntoupper(char *\fIdest\fP, const char *\fIsrc\fP, size_t \fIn\fP);
+inline char *libsimple_strntoupper(char *\fIdest\fP, const char *\fIsrc\fP, size_t \fIn\fP);
 char *libsimple_stpntoupper(char *\fIdest\fP, const char *\fIsrc\fP, size_t \fIn\fP);
 
 #ifndef strntoupper
diff --git a/man3/libsimple_strrcaseeqlen.3 b/man3/libsimple_strrcaseeqlen.3
index 714c65a..ac525b2 100644
--- a/man3/libsimple_strrcaseeqlen.3
+++ b/man3/libsimple_strrcaseeqlen.3
@@ -6,7 +6,7 @@ libsimple_strrcaseeqlen \- check terminal commonality
 .nf
 #include <libsimple.h>
 
-static inline size_t libsimple_strrcaseeqlen(const char *\fIa\fP, const char *\fIb\fP);
+inline size_t libsimple_strrcaseeqlen(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef strrcaseeqlen
 # define strrcaseeqlen libsimple_strrcaseeqlen
diff --git a/man3/libsimple_strreplace.3 b/man3/libsimple_strreplace.3
index 0cdedd8..aabff9a 100644
--- a/man3/libsimple_strreplace.3
+++ b/man3/libsimple_strreplace.3
@@ -6,7 +6,7 @@ libsimple_strreplace \- replace characters in a string
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strreplace(char *\fIs\fP, int \fIold\fP, int \fInew\fP);
+inline char *libsimple_strreplace(char *\fIs\fP, int \fIold\fP, int \fInew\fP);
 
 #ifndef strreplace
 # define strreplace libsimple_strreplace
diff --git a/man3/libsimple_strreqlen.3 b/man3/libsimple_strreqlen.3
index 16c785e..0933a83 100644
--- a/man3/libsimple_strreqlen.3
+++ b/man3/libsimple_strreqlen.3
@@ -6,7 +6,7 @@ libsimple_strreqlen \- check terminal commonality
 .nf
 #include <libsimple.h>
 
-static inline size_t libsimple_strreqlen(const char *\fIa\fP, const char *\fIb\fP);
+inline size_t libsimple_strreqlen(const char *\fIa\fP, const char *\fIb\fP);
 
 #ifndef strreqlen
 # define strreqlen libsimple_strreqlen
diff --git a/man3/libsimple_strrncaseeqlen.3 b/man3/libsimple_strrncaseeqlen.3
index 0d245f0..8a001c1 100644
--- a/man3/libsimple_strrncaseeqlen.3
+++ b/man3/libsimple_strrncaseeqlen.3
@@ -6,7 +6,7 @@ libsimple_strrncaseeqlen \- check terminal commonality
 .nf
 #include <libsimple.h>
 
-static inline size_t libsimple_strrncaseeqlen(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline size_t libsimple_strrncaseeqlen(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strrncaseeqlen
 # define strrncaseeqlen libsimple_strrncaseeqlen
diff --git a/man3/libsimple_strrneqlen.3 b/man3/libsimple_strrneqlen.3
index eced333..8744c6d 100644
--- a/man3/libsimple_strrneqlen.3
+++ b/man3/libsimple_strrneqlen.3
@@ -6,7 +6,7 @@ libsimple_strrneqlen \- check terminal commonality
 .nf
 #include <libsimple.h>
 
-static inline size_t libsimple_strrneqlen(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
+inline size_t libsimple_strrneqlen(const char *\fIa\fP, const char *\fIb\fP, size_t \fIn\fP);
 
 #ifndef strrneqlen
 # define strrneqlen libsimple_strrneqlen
diff --git a/man3/libsimple_strset.3 b/man3/libsimple_strset.3
index 6ed9ff4..a635c74 100644
--- a/man3/libsimple_strset.3
+++ b/man3/libsimple_strset.3
@@ -6,8 +6,8 @@ libsimple_strset, libsimple_stpset \- fill a string with a character
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strset(char *\fIs\fP, int \fIc\fP);
-static inline char *libsimple_stpset(char *\fIs\fP, int \fIc\fP);
+inline char *libsimple_strset(char *\fIs\fP, int \fIc\fP);
+inline char *libsimple_stpset(char *\fIs\fP, int \fIc\fP);
 
 #ifndef strset
 # define strset libsimple_strset
diff --git a/man3/libsimple_strtolower.3 b/man3/libsimple_strtolower.3
index 8075dde..695f5eb 100644
--- a/man3/libsimple_strtolower.3
+++ b/man3/libsimple_strtolower.3
@@ -6,7 +6,7 @@ libsimple_strtolower, libsimple_stptolower \- convert a string to lower case
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strtolower(char *\fIdest\fP, const char *\fIsrc\fP);
+inline char *libsimple_strtolower(char *\fIdest\fP, const char *\fIsrc\fP);
 char *libsimple_stptolower(char *\fIdest\fP, const char *\fIsrc\fP);
 
 #ifndef strtolower
diff --git a/man3/libsimple_strtoupper.3 b/man3/libsimple_strtoupper.3
index 10333e5..75f3959 100644
--- a/man3/libsimple_strtoupper.3
+++ b/man3/libsimple_strtoupper.3
@@ -6,7 +6,7 @@ libsimple_strtoupper, libsimple_stptoupper \- convert a string to upper case
 .nf
 #include <libsimple.h>
 
-static inline char *libsimple_strtoupper(char *\fIdest\fP, const char *\fIsrc\fP);
+inline char *libsimple_strtoupper(char *\fIdest\fP, const char *\fIsrc\fP);
 char *libsimple_stptoupper(char *\fIdest\fP, const char *\fIsrc\fP);
 
 #ifndef strtoupper
diff --git a/man3/libsimple_timespectodouble.3 b/man3/libsimple_timespectodouble.3
index 4413f8f..83cdcbc 100644
--- a/man3/libsimple_timespectodouble.3
+++ b/man3/libsimple_timespectodouble.3
@@ -6,8 +6,8 @@ libsimple_timespectodouble, libsimple_timevaltodouble \- convert a duration data
 .nf
 #include <libsimple.h>
 
-static inline double libsimple_timespectodouble(const struct timespec *\fIts\fP);
-static inline double libsimple_timevaltodouble(const struct timeval *\fItv\fP);
+inline double libsimple_timespectodouble(const struct timespec *\fIts\fP);
+inline double libsimple_timevaltodouble(const struct timeval *\fItv\fP);
 
 #ifndef timespectodouble
 # define timespectodouble libsimple_timespectodouble
diff --git a/man3/libsimple_timeval2timespec.3 b/man3/libsimple_timeval2timespec.3
index f6dcf90..f827463 100644
--- a/man3/libsimple_timeval2timespec.3
+++ b/man3/libsimple_timeval2timespec.3
@@ -6,7 +6,7 @@ libsimple_timeval2timespec, libsimple_timespec2timeval \- convert between timesp
 .nf
 #include <libsimple.h>
 
-static inline void libsimple_timeval2timespec(struct timespec *restrict \fIts\fP, const struct timeval *restrict \fItv\fP);
+inline void libsimple_timeval2timespec(struct timespec *restrict \fIts\fP, const struct timeval *restrict \fItv\fP);
 int libsimple_timespec2timeval(struct timeval *restrict \fItv\fP, const struct timespec *restrict \fIts\fP);
 
 #ifndef timeval2timespec
diff --git a/man3/libsimple_valigned_allocn.3 b/man3/libsimple_valigned_allocn.3
index ab93f30..59edbb5 100644
--- a/man3/libsimple_valigned_allocn.3
+++ b/man3/libsimple_valigned_allocn.3
@@ -6,12 +6,12 @@ libsimple_valigned_allocn \- allocate memory with custom alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_valigned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envaligned_allocn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evaligned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_aligned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enaligned_allocn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ealigned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_valigned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envaligned_allocn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evaligned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_aligned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enaligned_allocn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ealigned_allocn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef valigned_allocn
 # define valigned_allocn libsimple_valigned_allocn
diff --git a/man3/libsimple_valigned_alloczn.3 b/man3/libsimple_valigned_alloczn.3
index c40979e..a272bb1 100644
--- a/man3/libsimple_valigned_alloczn.3
+++ b/man3/libsimple_valigned_alloczn.3
@@ -8,10 +8,10 @@ libsimple_valigned_alloczn \- allocate optionally initialised memory with custom
 
 void *libsimple_valigned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
 void *libsimple_envaligned_alloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evaligned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_aligned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enaligned_alloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ealigned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_evaligned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_aligned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enaligned_alloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ealigned_alloczn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef valigned_alloczn
 # define valigned_alloczn libsimple_valigned_alloczn
diff --git a/man3/libsimple_valigned_reallocfn.3 b/man3/libsimple_valigned_reallocfn.3
index 0acf175..2afa6c2 100644
--- a/man3/libsimple_valigned_reallocfn.3
+++ b/man3/libsimple_valigned_reallocfn.3
@@ -6,8 +6,8 @@ libsimple_valigned_reallocfn \- reallocate memory and customise alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_valigned_reallocfn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_aligned_reallocfn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_valigned_reallocfn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_aligned_reallocfn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef valigned_reallocfn
 # define valigned_reallocfn libsimple_valigned_reallocfn
diff --git a/man3/libsimple_valigned_reallocn.3 b/man3/libsimple_valigned_reallocn.3
index 94baffb..607684b 100644
--- a/man3/libsimple_valigned_reallocn.3
+++ b/man3/libsimple_valigned_reallocn.3
@@ -8,10 +8,10 @@ libsimple_valigned_reallocn \- reallocate memory and customise alignment
 
 void *libsimple_valigned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
 void *libsimple_envaligned_reallocn(int \fIstatus\fP, void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evaligned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_aligned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enaligned_reallocn(int \fIstatus\fP, void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ealigned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_evaligned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_aligned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enaligned_reallocn(int \fIstatus\fP, void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ealigned_reallocn(void *\fIptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef valigned_reallocn
 # define valigned_reallocn libsimple_valigned_reallocn
diff --git a/man3/libsimple_valloc.3 b/man3/libsimple_valloc.3
index 97e7b97..d7b0114 100644
--- a/man3/libsimple_valloc.3
+++ b/man3/libsimple_valloc.3
@@ -6,9 +6,9 @@ libsimple_valloc \- allocate memory with page size alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_valloc(size_t \fIn\fP);
-static inline void *libsimple_envalloc(int \fIstatus\fP, size_t \fIn\fP);
-static inline void *libsimple_evalloc(size_t \fIn\fP);
+inline void *libsimple_valloc(size_t \fIn\fP);
+inline void *libsimple_envalloc(int \fIstatus\fP, size_t \fIn\fP);
+inline void *libsimple_evalloc(size_t \fIn\fP);
 
 #ifndef valloc
 # define valloc libsimple_valloc
diff --git a/man3/libsimple_vallocz.3 b/man3/libsimple_vallocz.3
index bc2f8b8..10138ed 100644
--- a/man3/libsimple_vallocz.3
+++ b/man3/libsimple_vallocz.3
@@ -6,9 +6,9 @@ libsimple_vallocz \- allocate optionally initialised memory with page size align
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vallocz(int \fIclear\fP, size_t \fIn\fP);
-static inline void *libsimple_envallocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP);
-static inline void *libsimple_evallocz(int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_vallocz(int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_envallocz(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP);
+inline void *libsimple_evallocz(int \fIclear\fP, size_t \fIn\fP);
 
 #ifndef vallocz
 # define vallocz libsimple_vallocz
diff --git a/man3/libsimple_vcallocn.3 b/man3/libsimple_vcallocn.3
index 449cfd6..8d32c6a 100644
--- a/man3/libsimple_vcallocn.3
+++ b/man3/libsimple_vcallocn.3
@@ -6,12 +6,12 @@ libsimple_vcallocn \- allocate memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vcallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envcallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evcallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_callocn(size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_encallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ecallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vcallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envcallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evcallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_callocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_encallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ecallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vcallocn
 # define vcallocn libsimple_vcallocn
diff --git a/man3/libsimple_vmallocn.3 b/man3/libsimple_vmallocn.3
index 9383069..130743f 100644
--- a/man3/libsimple_vmallocn.3
+++ b/man3/libsimple_vmallocn.3
@@ -6,12 +6,12 @@ libsimple_vmallocn \- allocate memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vmallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envmallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evmallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_mallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enmallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_emallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vmallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envmallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evmallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_mallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enmallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_emallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vmallocn
 # define vmallocn libsimple_vmallocn
diff --git a/man3/libsimple_vmalloczn.3 b/man3/libsimple_vmalloczn.3
index 67354e6..a16f0d8 100644
--- a/man3/libsimple_vmalloczn.3
+++ b/man3/libsimple_vmalloczn.3
@@ -8,10 +8,10 @@ libsimple_vmalloczn \- allocate optionally initialised memory
 
 void *libsimple_vmalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
 void *libsimple_envmalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evmalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_malloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enmalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_emalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_evmalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_malloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enmalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_emalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vmalloczn
 # define vmalloczn libsimple_vmalloczn
diff --git a/man3/libsimple_vmemalignn.3 b/man3/libsimple_vmemalignn.3
index 1f13cd7..96f7794 100644
--- a/man3/libsimple_vmemalignn.3
+++ b/man3/libsimple_vmemalignn.3
@@ -6,12 +6,12 @@ libsimple_vmemalignn \- allocate memory with custom alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vmemalignn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envmemalignn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evmemalignn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_memalignn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enmemalignn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ememalignn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vmemalignn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envmemalignn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evmemalignn(size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_memalignn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enmemalignn(int \fIstatus\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ememalignn(size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vmemalignn
 # define vmemalignn libsimple_vmemalignn
diff --git a/man3/libsimple_vmemalignzn.3 b/man3/libsimple_vmemalignzn.3
index d9b0434..d048701 100644
--- a/man3/libsimple_vmemalignzn.3
+++ b/man3/libsimple_vmemalignzn.3
@@ -6,12 +6,12 @@ libsimple_vmemalignzn \- allocate optionally initialised memory with custom alig
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vmemalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envmemalignzn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evmemalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_memalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enmemalignzn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ememalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vmemalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envmemalignzn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evmemalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_memalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enmemalignzn(int \fIstatus\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ememalignzn(int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vmemalignzn
 # define vmemalignzn libsimple_vmemalignzn
diff --git a/man3/libsimple_vmemalloc.3 b/man3/libsimple_vmemalloc.3
index ab0b4c3..0be0b71 100644
--- a/man3/libsimple_vmemalloc.3
+++ b/man3/libsimple_vmemalloc.3
@@ -12,10 +12,10 @@ enum libsimple_memalloc_option {
 
 void *libsimple_vmemalloc(size_t \fIn\fP, va_list \fIap\fP);
 void *libsimple_envmemalloc(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evmemalloc(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_memalloc(size_t \fIn\fP, ..., /* LIBSIMPLE_MEMALLOC_END */);
-static inline void *libsimple_enmemalloc(int \fIstatus\fP, size_t \fIn\fP, ..., /* LIBSIMPLE_MEMALLOC_END */);
-static inline void *libsimple_ememalloc(size_t \fIn\fP, ..., /* LIBSIMPLE_MEMALLOC_END */);
+inline void *libsimple_evmemalloc(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_memalloc(size_t \fIn\fP, ..., /* LIBSIMPLE_MEMALLOC_END */);
+inline void *libsimple_enmemalloc(int \fIstatus\fP, size_t \fIn\fP, ..., /* LIBSIMPLE_MEMALLOC_END */);
+inline void *libsimple_ememalloc(size_t \fIn\fP, ..., /* LIBSIMPLE_MEMALLOC_END */);
 .fi
 .PP
 Link with
diff --git a/man3/libsimple_vposix_memalignn.3 b/man3/libsimple_vposix_memalignn.3
index b8da3e8..614165d 100644
--- a/man3/libsimple_vposix_memalignn.3
+++ b/man3/libsimple_vposix_memalignn.3
@@ -6,12 +6,12 @@ libsimple_vposix_memalignn \- allocate memory with custom alignment
 .nf
 #include <libsimple.h>
 
-static inline int libsimple_vposix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void libsimple_envposix_memalignn(int \fIstatus\fP, void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void libsimple_evposix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline int libsimple_posix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void libsimple_enposix_memalignn(int \fIstatus\fP, void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void libsimple_eposix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline int libsimple_vposix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void libsimple_envposix_memalignn(int \fIstatus\fP, void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void libsimple_evposix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline int libsimple_posix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void libsimple_enposix_memalignn(int \fIstatus\fP, void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void libsimple_eposix_memalignn(void **\fImemptr\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vposix_memalignn
 # define vposix_memalignn libsimple_vposix_memalignn
diff --git a/man3/libsimple_vposix_memalignzn.3 b/man3/libsimple_vposix_memalignzn.3
index fd4c682..62dc434 100644
--- a/man3/libsimple_vposix_memalignzn.3
+++ b/man3/libsimple_vposix_memalignzn.3
@@ -8,10 +8,10 @@ libsimple_vposix_memalignzn \- allocate optionally initialised memory with custo
 
 int libsimple_vposix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
 void libsimple_envposix_memalignzn(int \fIstatus\fP, void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void libsimple_evposix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline int libsimple_posix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void libsimple_enposix_memalignzn(int \fIstatus\fP, void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline int libsimple_eposix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void libsimple_evposix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline int libsimple_posix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void libsimple_enposix_memalignzn(int \fIstatus\fP, void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline int libsimple_eposix_memalignzn(void **\fImemptr\fP, int \fIclear\fP, size_t \fIalignment\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vposix_memalignzn
 # define vposix_memalignzn libsimple_vposix_memalignzn
diff --git a/man3/libsimple_vputenvf.3 b/man3/libsimple_vputenvf.3
index d772c81..88748e7 100644
--- a/man3/libsimple_vputenvf.3
+++ b/man3/libsimple_vputenvf.3
@@ -7,11 +7,11 @@ libsimple_vputenvf \- change or add a string formatted value to the environment
 #include <libsimple.h>
 
 int libsimple_vputenvf(const char *\fIfmt\fP, va_list \fIap\fP);
-static inline int libsimple_putenvf(const char *\fIfmt\fP, ...);
+inline int libsimple_putenvf(const char *\fIfmt\fP, ...);
 void libsimple_envputenvf(int \fIstatus\fP, const char *\fIfmt\fP, va_list \fIap\fP);
-static inline void libsimple_enputenvf(int \fIstatus\fP, const char *\fIfmt\fP, ...);
-static inline void libsimple_evputenvf(const char *\fIfmt\fP, va_list \fIap\fP);
-static inline void libsimple_eputenvf(const char *\fIfmt\fP, ...);
+inline void libsimple_enputenvf(int \fIstatus\fP, const char *\fIfmt\fP, ...);
+inline void libsimple_evputenvf(const char *\fIfmt\fP, va_list \fIap\fP);
+inline void libsimple_eputenvf(const char *\fIfmt\fP, ...);
 
 #ifndef vputenvf
 # define vputenvf libsimple_vputenvf
diff --git a/man3/libsimple_vpvallocn.3 b/man3/libsimple_vpvallocn.3
index 1d4bbbb..2769478 100644
--- a/man3/libsimple_vpvallocn.3
+++ b/man3/libsimple_vpvallocn.3
@@ -6,12 +6,12 @@ libsimple_vpvallocn \- allocate memory with page size alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vpvallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envpvallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evpvallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_pvallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enpvallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_epvallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vpvallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envpvallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evpvallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_pvallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enpvallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_epvallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vpvallocn
 # define vpvallocn libsimple_vpvallocn
diff --git a/man3/libsimple_vpvalloczn.3 b/man3/libsimple_vpvalloczn.3
index e620758..9070b98 100644
--- a/man3/libsimple_vpvalloczn.3
+++ b/man3/libsimple_vpvalloczn.3
@@ -6,12 +6,12 @@ libsimple_vpvalloczn \- allocate optionally initialised memory with page size al
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vpvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envpvalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evpvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_pvalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enpvalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_epvalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vpvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envpvalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evpvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_pvalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enpvalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_epvalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vpvalloczn
 # define vpvalloczn libsimple_vpvalloczn
diff --git a/man3/libsimple_vreallocfn.3 b/man3/libsimple_vreallocfn.3
index 5dd5390..e0e75e0 100644
--- a/man3/libsimple_vreallocfn.3
+++ b/man3/libsimple_vreallocfn.3
@@ -6,8 +6,8 @@ libsimple_vreallocfn \- reallocate memory
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vreallocfn(void *\fIptr\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_reallocfn(void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vreallocfn(void *\fIptr\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_reallocfn(void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vreallocfn
 # define vreallocfn libsimple_vreallocfn
diff --git a/man3/libsimple_vreallocn.3 b/man3/libsimple_vreallocn.3
index bddce8b..f1a8fad 100644
--- a/man3/libsimple_vreallocn.3
+++ b/man3/libsimple_vreallocn.3
@@ -8,10 +8,10 @@ libsimple_vreallocn \- reallocate memory
 
 void *libsimple_vreallocn(void *\fIptr\fP, size_t \fIn\fP, va_list \fIap\fP);
 void *libsimple_envreallocn(int \fIstatus\fP, void *\fIptr\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evreallocn(void *\fIptr\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_reallocn(void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_enreallocn(int \fIstatus\fP, void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_ereallocn(void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_evreallocn(void *\fIptr\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_reallocn(void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_enreallocn(int \fIstatus\fP, void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_ereallocn(void *\fIptr\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vreallocn
 # define vreallocn libsimple_vreallocn
diff --git a/man3/libsimple_vvallocn.3 b/man3/libsimple_vvallocn.3
index c378660..24d861b 100644
--- a/man3/libsimple_vvallocn.3
+++ b/man3/libsimple_vvallocn.3
@@ -6,12 +6,12 @@ libsimple_vvallocn \- allocate memory with page size alignment
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vvallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envvallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evvallocn(size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_vallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_envallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_evallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vvallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envvallocn(int \fIstatus\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evvallocn(size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_vallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_envallocn(int \fIstatus\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_evallocn(size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vvallocn
 # define vvallocn libsimple_vvallocn
diff --git a/man3/libsimple_vvalloczn.3 b/man3/libsimple_vvalloczn.3
index 9a2f9e4..5cbd57a 100644
--- a/man3/libsimple_vvalloczn.3
+++ b/man3/libsimple_vvalloczn.3
@@ -6,12 +6,12 @@ libsimple_vvalloczn \- allocate optionally initialised memory with page size ali
 .nf
 #include <libsimple.h>
 
-static inline void *libsimple_vvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_envvalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_evvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
-static inline void *libsimple_valloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_envalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
-static inline void *libsimple_evalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_vvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_envvalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_evvalloczn(int \fIclear\fP, size_t \fIn\fP, va_list \fIap\fP);
+inline void *libsimple_valloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_envalloczn(int \fIstatus\fP, int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
+inline void *libsimple_evalloczn(int \fIclear\fP, size_t \fIn\fP, ..., /* (size_t)0 */);
 
 #ifndef vvalloczn
 # define vvalloczn libsimple_vvalloczn
diff --git a/man3/libsimple_vweprintf.3 b/man3/libsimple_vweprintf.3
index 868b8df..b40799d 100644
--- a/man3/libsimple_vweprintf.3
+++ b/man3/libsimple_vweprintf.3
@@ -11,11 +11,11 @@ extern void (*libsimple_eprintf_preprint)(void);
 extern void (*libsimple_eprintf_postprint)(void);
 
 void libsimple_vweprintf(const char *\fIfmt\fP, va_list \fIap\fP);
-static inline void libsimple_weprintf(const char *\fIfmt\fP, ...);
-static inline void libsimple_venprintf(int \fIstatus\fP, const char *\fIfmt\fP, va_list \fIap\fP);
-static inline void libsimple_enprintf(int \fIstatus\fP, const char *\fIfmt\fP, ...);
-static inline void libsimple_veprintf(const char *\fIfmt\fP, va_list \fIap\fP);
-static inline void libsimple_eprintf(const char *\fIfmt\fP, ...);
+inline void libsimple_weprintf(const char *\fIfmt\fP, ...);
+inline void libsimple_venprintf(int \fIstatus\fP, const char *\fIfmt\fP, va_list \fIap\fP);
+inline void libsimple_enprintf(int \fIstatus\fP, const char *\fIfmt\fP, ...);
+inline void libsimple_veprintf(const char *\fIfmt\fP, va_list \fIap\fP);
+inline void libsimple_eprintf(const char *\fIfmt\fP, ...);
 
 #ifndef vweprintf
 # define vweprintf libsimple_vweprintf
diff --git a/man3/libsimple_wcsndup.3 b/man3/libsimple_wcsndup.3
index 6821d25..803a309 100644
--- a/man3/libsimple_wcsndup.3
+++ b/man3/libsimple_wcsndup.3
@@ -9,7 +9,7 @@ libsimple_wcsndup \- duplicate a wide-character string
 wchar_t *libsimple_wcsndupa(const wchar_t *\fIs\fP, size_t \fIn\fP);
 wchar_t *libsimple_wcsndup(const wchar_t *\fIs\fP, size_t \fIn\fP);
 wchar_t *libsimple_enwcsndup(int \fIstatus\fP, const wchar_t *\fIs\fP, size_t \fIn\fP);
-static inline wchar_t *libsimple_ewcsndup(const wchar_t *\fIs\fP, size_t \fIn\fP);
+inline wchar_t *libsimple_ewcsndup(const wchar_t *\fIs\fP, size_t \fIn\fP);
 
 #ifndef wcsndupa
 # define wcsndupa libsimple_wcsndupa
diff --git a/man3/libsimple_wmemdup.3 b/man3/libsimple_wmemdup.3
index 1f9e9cd..9c6305e 100644
--- a/man3/libsimple_wmemdup.3
+++ b/man3/libsimple_wmemdup.3
@@ -9,7 +9,7 @@ libsimple_wmemdup \- duplicate a wide-character array
 wchar_t *libsimple_wmemdupa(const wchar_t *\fIs\fP, size_t \fIn\fP);
 wchar_t *libsimple_wmemdup(const wchar_t *\fIs\fP, size_t \fIn\fP);
 wchar_t *libsimple_enwmemdup(int \fIstatus\fP, const wchar_t *\fIs\fP, size_t \fIn\fP);
-static inline wchar_t *libsimple_ewmemdup(const wchar_t *\fIs\fP, size_t \fIn\fP);
+inline wchar_t *libsimple_ewmemdup(const wchar_t *\fIs\fP, size_t \fIn\fP);
 
 #ifndef wmemdupa
 # define wmemdupa libsimple_wmemdupa
diff --git a/memalloc.c b/memalloc.c
new file mode 100644
index 0000000..e0b9dc9
--- /dev/null
+++ b/memalloc.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_memalloc(size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/memcaseends.c b/memcaseends.c
index 0a673f7..8c938c4 100644
--- a/memcaseends.c
+++ b/memcaseends.c
@@ -9,9 +9,12 @@ libsimple_memcaseends(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--)
+	while (m) {
+		n--;
+		m--;
 		if (tolower(s[n]) != tolower(t[m]))
 			return 0;
+	}
 	return 1;
 }
 
diff --git a/memcaseeq.c b/memcaseeq.c
new file mode 100644
index 0000000..bbcf1b0
--- /dev/null
+++ b/memcaseeq.c
@@ -0,0 +1,26 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_memcaseeq(const void *, const void *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	assert(libsimple_memcaseeq("abcxyz", "abc123", 3));
+	assert(!libsimple_memcaseeq("abcxyz", "abc123", 4));
+	assert(libsimple_memcaseeq("abcxyz", "abcx23", 4));
+	assert(libsimple_memcaseeq("1", "2", 0));
+	assert(!libsimple_memcaseeq("1", "2", 1));
+	assert(libsimple_memcaseeq("abc", "ABC", 3));
+	assert(libsimple_memcaseeq("ABC", "abc", 3));
+	assert(libsimple_memcaseeq("ABC", "ABC", 3));
+	return 0;
+}
+
+#endif
diff --git a/memcasemem.c b/memcasemem.c
index 244042b..e118da8 100644
--- a/memcasemem.c
+++ b/memcasemem.c
@@ -6,11 +6,12 @@
 void *
 libsimple_memcasemem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
 {
-	char *hay = (void *)hay_, *end;
+	const char *hay = hay_;
 	const char *sub = sub_;
+	const char *end;
 
 	if (!subn)
-		return hay;
+		return REMOVE_CONST(hay, char *);
 	if (hayn < subn)
 		return NULL;
 	if (subn == 1)
@@ -18,7 +19,7 @@ libsimple_memcasemem(const void *hay_, size_t hayn, const void *sub_, size_t sub
 
 	for (end = &hay[hayn - subn + 1]; hay != end; hay++)
 		if (tolower(*hay) == tolower(*sub) && !libsimple_memcasecmp(hay, sub, subn))
-			return hay;
+			return REMOVE_CONST(hay, char *);
 
 	return NULL;
 }
diff --git a/memcmove.c b/memcmove.c
index ab9e6d9..11fa9c4 100644
--- a/memcmove.c
+++ b/memcmove.c
@@ -44,7 +44,7 @@ main(void)
 	assert(!strncmp(buf, "-----hello-", 11));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';;
+	stpcpy(&buf[5], "hello")[0] = '-';
 	assert(libsimple_memcmove(&buf[5], &buf[5], 'l', 5) == &buf[5 + 3]);
 	assert(!strncmp(buf, "-----hello-", 11));
 
diff --git a/memelem.c b/memelem.c
index 7d9231d..3344cd8 100644
--- a/memelem.c
+++ b/memelem.c
@@ -8,46 +8,46 @@ libsimple_memelem(const void *hay_, const void *sub_, size_t width, size_t n)
 {
 	switch (width) {
 	case 0:
-		return (void *)hay_;
+		return REMOVE_CONST(hay_, void *);
 	case 1:
-		return memchr(hay_, *(char *)sub_, n);
+		return memchr(hay_, *(const char *)sub_, n);
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (; n--; hay++)
 				if (*hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint16_t *);
 			break;
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (; n--; hay++)
 				if (*hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint32_t *);
 			break;
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (; n--; hay++)
 				if (*hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint64_t *);
 			break;
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (; n--; hay += width) {
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
 						goto next;
-				return hay;
+				return REMOVE_CONST(hay, char *);
 			next:;
 			}
 			break;
diff --git a/memelem_inv.c b/memelem_inv.c
index dace2d4..7e87d4c 100644
--- a/memelem_inv.c
+++ b/memelem_inv.c
@@ -10,43 +10,43 @@ libsimple_memelem_inv(const void *hay_, const void *sub_, size_t width, size_t n
 	case 0:
 		return NULL;
 	case 1:
-		return libsimple_memchr_inv(hay_, *(char *)sub_, n);
+		return libsimple_memchr_inv(hay_, *(const char *)sub_, n);
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (; n--; hay++)
 				if (*hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint16_t *);
 			break;
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (; n--; hay++)
 				if (*hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint32_t *);
 			break;
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (; n--; hay++)
 				if (*hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint64_t *);
 			break;
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (; n--; hay += width) {
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
-						return hay;
+						return REMOVE_CONST(hay, char *);
 			}
 			break;
 		}
diff --git a/memelemmove.c b/memelemmove.c
index 7becbc2..d790a87 100644
--- a/memelemmove.c
+++ b/memelemmove.c
@@ -5,18 +5,19 @@
 
 #define MEMELEMMOVE(TYPE)\
 	do {\
-		TYPE *p;\
+		const TYPE *p;\
+		TYPE *ret;\
 		if (d <= s) {\
 			for (; n; n--, s++)\
 				if ((*d++ = *s) == elem)\
 					return d;\
 		} else {\
-			for (p = *(TYPE **)(void *)&s; n; n--, p++) {\
+			for (p = s; n; n--, p++) {\
 				if (*p == elem) {\
 					n = (size_t)(p - s);\
-					p = &d[n + 1];\
+					ret = &d[n + 1];\
 					do { d[n] = s[n]; } while (n--);\
-					return p;\
+					return ret;\
 				}\
 			}\
 			for (n = (size_t)(p - s); n;) {\
@@ -52,7 +53,8 @@ memelemmove64(uint64_t *restrict d, const uint64_t *restrict s, uint64_t elem, s
 static char *
 memelemmovex(char *restrict d, const char *restrict s, const char *restrict elem, size_t width, size_t n)
 {
-	char *p;
+	const char *p;
+	char *ret;
 	size_t i;
 	if (d <= s) {
 		for (; n; s += width, n--) {
@@ -68,26 +70,26 @@ memelemmovex(char *restrict d, const char *restrict s, const char *restrict elem
 		}
 		return NULL;
 	} else {
-		for (p = *(char **)(void *)&s; n; n--) {
+		for (p = s; n; n--) {
 			for (i = 0; i < width; i++)
 				if (p[i] != elem[i])
 					goto next_backwards;
 			
 			p += width;
 			n = (size_t)(p - s);
-			p = &d[n];
+			ret = &d[n];
 			goto out_backwards;
 		next_backwards:
 			p += width;
 		}
 		n = (size_t)(p - s);
-		p = NULL;
+		ret = NULL;
 	out_backwards:
 		while (n) {
 			n--;
 			d[n] = s[n];
 		}
-		return p;
+		return ret;
 	}
 }
 
@@ -143,7 +145,7 @@ main(void)
 	assert(!strncmp(buf, "-----hello-", 11));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';;
+	stpcpy(&buf[5], "hello")[0] = '-';
 	assert(libsimple_memelemmove(&buf[5], &buf[5], "l", 1, 5) == &buf[5 + 3]);
 	assert(!strncmp(buf, "-----hello-", 11));
 
@@ -189,7 +191,7 @@ main(void)
 	assert(!strncmp(buf, "-----.h.e.l.l.o-", 16));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], ".h.e.l.l.o")[0] = '-';;
+	stpcpy(&buf[5], ".h.e.l.l.o")[0] = '-';
 	assert(libsimple_memelemmove(&buf[5], &buf[5], ".l", 2, 5) == &buf[5 + 3 * 2]);
 	assert(!strncmp(buf, "-----.h.e.l.l.o-", 16));
 
@@ -235,7 +237,7 @@ main(void)
 	assert(!strncmp(buf, "-----..h..e..l..l..o-", 21));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "..h..e..l..l..o")[0] = '-';;
+	stpcpy(&buf[5], "..h..e..l..l..o")[0] = '-';
 	assert(libsimple_memelemmove(&buf[5], &buf[5], "..l", 3, 5) == &buf[5 + 3 * 3]);
 	assert(!strncmp(buf, "-----..h..e..l..l..o-", 21));
 
@@ -281,7 +283,7 @@ main(void)
 	assert(!strncmp(buf, "-----...h...e...l...l...o-", 26));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "...h...e...l...l...o")[0] = '-';;
+	stpcpy(&buf[5], "...h...e...l...l...o")[0] = '-';
 	assert(libsimple_memelemmove(&buf[5], &buf[5], "...l", 4, 5) == &buf[5 + 3 * 4]);
 	assert(!strncmp(buf, "-----...h...e...l...l...o-", 26));
 
@@ -327,7 +329,7 @@ main(void)
 	assert(!strncmp(buf, "-----.......h.......e.......l.......l.......o-", 46));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], ".......h.......e.......l.......l.......o")[0] = '-';;
+	stpcpy(&buf[5], ".......h.......e.......l.......l.......o")[0] = '-';
 	assert(libsimple_memelemmove(&buf[5], &buf[5], ".......l", 8, 5) == &buf[5 + 3 * 8]);
 	assert(!strncmp(buf, "-----.......h.......e.......l.......l.......o-", 46));
 
diff --git a/memelemscan.c b/memelemscan.c
index d17297a..b402570 100644
--- a/memelemscan.c
+++ b/memelemscan.c
@@ -8,43 +8,43 @@ libsimple_memelemscan(const void *hay_, const void *sub_, size_t width, size_t n
 {
 	switch (width) {
 	case 0:
-		return (void *)hay_;
+		return REMOVE_CONST(hay_, void *);
 	case 1:
-		return libsimple_memscan(hay_, *(char *)sub_, n);
+		return libsimple_memscan(hay_, *(const char *)sub_, n);
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (; n-- && *hay != sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint16_t *);
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (; n-- && *hay != sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint32_t *);
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (; n-- && *hay != sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint64_t *);
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (; n--; hay += width) {
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
 						goto next;
-				return hay;
+				return REMOVE_CONST(hay, char *);
 			next:;
 			}
-			return hay;
+			return REMOVE_CONST(hay, char *);
 		}
 	}
 }
diff --git a/memelemscan_inv.c b/memelemscan_inv.c
index 37b479a..48d35b2 100644
--- a/memelemscan_inv.c
+++ b/memelemscan_inv.c
@@ -8,41 +8,41 @@ libsimple_memelemscan_inv(const void *hay_, const void *sub_, size_t width, size
 {
 	switch (width) {
 	case 0:
-		return (void *)hay_;
+		return REMOVE_CONST(hay_, void *);
 	case 1:
-		return libsimple_memscan_inv(hay_, *(char *)sub_, n);
+		return libsimple_memscan_inv(hay_, *(const char *)sub_, n);
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (; n-- && *hay == sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint16_t *);
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (; n-- && *hay == sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint32_t *);
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (; n-- && *hay == sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint64_t *);
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (; n--; hay += width) {
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
-						return hay;
+						return REMOVE_CONST(hay, char *);
 			}
-			return hay;
+			return REMOVE_CONST(hay, char *);
 		}
 	}
 }
diff --git a/memends.c b/memends.c
index f579222..be4b1d4 100644
--- a/memends.c
+++ b/memends.c
@@ -9,9 +9,12 @@ 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--)
+	while (m) {
+		n--;
+		m--;
 		if (s[n] != t[m])
 			return 0;
+	}
 	return 1;
 }
 
diff --git a/memeq.c b/memeq.c
new file mode 100644
index 0000000..f3eb30c
--- /dev/null
+++ b/memeq.c
@@ -0,0 +1,26 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_memeq(const void *, const void *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	assert(libsimple_memeq("abcxyz", "abc123", 3));
+	assert(!libsimple_memeq("abcxyz", "abc123", 4));
+	assert(libsimple_memeq("abcxyz", "abcx23", 4));
+	assert(libsimple_memeq("1", "2", 0));
+	assert(!libsimple_memeq("1", "2", 1));
+	assert(!libsimple_memeq("abc", "ABC", 3));
+	assert(!libsimple_memeq("ABC", "abc", 3));
+	assert(libsimple_memeq("ABC", "ABC", 3));
+	return 0;
+}
+
+#endif
diff --git a/memisutf8.c b/memisutf8.c
index 96a8b6b..b3d321e 100644
--- a/memisutf8.c
+++ b/memisutf8.c
@@ -11,6 +11,8 @@ libsimple_memisutf8(const char *string, size_t n, int allow_modified_nul)
         long int bytes = 0, read_bytes = 0, bits = 0, c, character;
 	size_t i;
 
+	character = 0; /* silence false warning from compiler; `character` is set in `if (!read_bytes)` before `else` */
+
         /*                                                      min bits  max bits
           0.......                                                 0         7
           110..... 10......                                        8        11
@@ -36,8 +38,10 @@ libsimple_memisutf8(const char *string, size_t n, int allow_modified_nul)
                                 return 0;
 
                         /* Multibyte character. */
-                        while ((c & 0x80))
-                                bytes++, c <<= 1;
+                        while ((c & 0x80)) {
+                                bytes++;
+				c <<= 1;
+			}
                         read_bytes = 1;
 			character = (c & 0xFF) >> bytes;
                         if (bytes > 6)
@@ -59,8 +63,10 @@ libsimple_memisutf8(const char *string, size_t n, int allow_modified_nul)
                                 continue;
 
                         /* Check that the character is not unnecessarily long. */
-                        while (character)
-                                character >>= 1, bits++;
+                        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 0;
diff --git a/memmem.c b/memmem.c
index 2cee286..f05be99 100644
--- a/memmem.c
+++ b/memmem.c
@@ -6,11 +6,11 @@
 void *
 libsimple_memmem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
 {
-	char *hay = (void *)hay_, *end;
+	const char *hay = hay_, *end;
 	const char *sub = sub_;
 
 	if (!subn)
-		return hay;
+		return REMOVE_CONST(hay, char *);
 	if (hayn < subn)
 		return NULL;
 	if (subn == 1)
@@ -18,7 +18,7 @@ libsimple_memmem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
 
 	for (end = &hay[hayn - subn + 1]; hay != end; hay++)
 		if (*hay == *sub && !memcmp(hay, sub, subn))
-			return hay;
+			return REMOVE_CONST(hay, char *);
 
 	return NULL;
 }
diff --git a/mempcpy.c b/mempcpy.c
new file mode 100644
index 0000000..8bac405
--- /dev/null
+++ b/mempcpy.c
@@ -0,0 +1,24 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_mempcpy(void *restrict, const void *restrict, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	stpcpy(buf, "abcxyz");
+	assert(libsimple_mempcpy(buf, "123", 3) == &buf[3]);
+	assert(!strcmpnul(buf, "123xyz"));
+
+	return 0;
+}
+
+#endif
diff --git a/mempmove.c b/mempmove.c
new file mode 100644
index 0000000..2d42b0e
--- /dev/null
+++ b/mempmove.c
@@ -0,0 +1,35 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_mempmove(void *, const void *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_mempmove(&buf[5], &buf[5], 5) == &buf[5 + 5]);
+	assert(!strncmp(buf, "-----hello-", 11));
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_mempmove(&buf[3], &buf[5], 5) == &buf[3 + 5]);
+	assert(!strncmp(buf, "---hellolo-", 11));
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_mempmove(&buf[8], &buf[5], 5) == &buf[8 + 5]);
+	assert(!strncmp(buf, "-----helhello-", 14));
+
+	return 0;
+}
+
+#endif
diff --git a/mempset.c b/mempset.c
new file mode 100644
index 0000000..e69dcd1
--- /dev/null
+++ b/mempset.c
@@ -0,0 +1,24 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_mempset(void *, int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	stpcpy(buf, "abc123");
+	assert(!strcmpnul(libsimple_mempset(buf, '.', 3), "123"));
+	assert(!strcmp(buf, "...123"));
+
+	return 0;
+}
+
+#endif
diff --git a/mempsetelem.c b/mempsetelem.c
index 6a3bd4f..cf84702 100644
--- a/mempsetelem.c
+++ b/mempsetelem.c
@@ -10,27 +10,30 @@ libsimple_mempsetelem(void *buf_, const void *item, size_t width, size_t n)
 	case 0:
 		return buf_;
 	case 1:
-		return &((char *)memset(buf_, *(char *)item, n))[n];
+		return &((char *)memset(buf_, *(const char *)item, n))[n];
 	case 2:
 		{
-			uint16_t *buf = buf_, e = *(uint16_t *)item;
+			uint16_t *buf = buf_;
 			uint16_t *end = &buf[n];
+			uint16_t e = *(const uint16_t *)item;
 			for (; buf != end; buf++)
 				*buf = e;
 			return buf;
 		}
 	case 4:
 		{
-			uint32_t *buf = buf_, e = *(uint32_t *)item;
+			uint32_t *buf = buf_;
 			uint32_t *end = &buf[n];
+			uint32_t e = *(const uint32_t *)item;
 			for (; buf != end; buf++)
 				*buf = e;
 			return buf;
 		}
 	case 8:
 		{
-			uint64_t *buf = buf_, e = *(uint64_t *)item;
+			uint64_t *buf = buf_;
 			uint64_t *end = &buf[n];
+			uint64_t e = *(const uint64_t *)item;
 			for (; buf != end; buf++)
 				*buf = e;
 			return buf;
@@ -59,22 +62,22 @@ main(void)
 	size_t i;
 
 	memset(buf, 0, sizeof(buf_));
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 0, 0) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 0, 10) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 1, 0) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 2, 0) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 4, 0) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 8, 0) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 16, 0) == &buf[0]);
-	assert(libsimple_mempsetelem(buf, &(uint64_t){~0}, 3, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 0, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 0, 10) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 1, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 2, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 4, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 8, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 16, 0) == &buf[0]);
+	assert(libsimple_mempsetelem(buf, &(uint64_t){~(uint64_t)0}, 3, 0) == &buf[0]);
 	assert(libsimple_mempsetelem(buf, &(uint8_t){0x09}, 1, 3000) == &buf[3000]);
 	assert(libsimple_mempsetelem(buf, &(uint16_t){0x0807}, 2, 1000) == &buf[2000]);
 	assert(libsimple_mempsetelem(buf, &(uint32_t){0x10203040UL}, 4, 300) == &buf[1200]);
 	assert(libsimple_mempsetelem(buf, &(uint64_t){0x0102030450607080ULL}, 8, 100) == &buf[800]);
-	assert(libsimple_mempsetelem(buf, (char []){0xA0, 0xB0, 0xC0}, 3, 16) == &buf[48]);
+	assert(libsimple_mempsetelem(buf, (char []){(char)0xA0, (char)0xB0, (char)0xC0}, 3, 16) == &buf[48]);
 
 	for (i = 0; i < 48; i++)
-		assert(buf[i] == ((char []){0xA0, 0xB0, 0xC0})[i % 3]);
+		assert(buf[i] == ((char []){(char)0xA0, (char)0xB0, (char)0xC0})[i % 3]);
 	for (; i < 800; i += 8)
 		assert(*(uint64_t *)&buf[i] == 0x0102030450607080ULL);
 	for (; i < 1200; i += 4)
diff --git a/memptolower.c b/memptolower.c
index 251a13a..f9b05e5 100644
--- a/memptolower.c
+++ b/memptolower.c
@@ -10,17 +10,17 @@ libsimple_memptolower(void *d_, const void *s_, size_t n)
 	const char *s = s_;
 	if (d == s) {
 		for (; n; d++, n--)
-			*d = tolower(*d);
+			*d = (char)tolower(*d);
 		return d;
 	} else if (d < s) {
 		for (; n; d++, s++, n--)
-			*d = tolower(*s);
+			*d = (char)tolower(*s);
 		return d;
 	} else {
 		ret = &d[n];
 		while (n) {
 			n--;
-			d[n] = tolower(s[n]);
+			d[n] = (char)tolower(s[n]);
 		}
 		return ret;
 	}
@@ -44,15 +44,6 @@ main(void)
 	stpcpy(buf, "ABCDEabcde12345");
 	assert(libsimple_memptolower(&buf[0], &buf[0], 16) == &buf[16]);
 	assert(!strcmp(buf, "abcdeabcde12345"));
-	stpcpy(buf, "ABCDEabcde12345");
-	assert(!strcmpnul(libsimple_memtolower(&buf[3], &buf[0], 16), "abcdeabcde12345"));
-	assert(!strcmp(buf, "ABCabcdeabcde12345"));
-	stpcpy(buf, "ABCDEabcde12345");
-	assert(!strcmpnul(libsimple_memtolower(&buf[0], &buf[3], 13), "deabcde12345"));
-	assert(!strcmp(buf, "deabcde12345"));
-	stpcpy(buf, "ABCDEabcde12345");
-	assert(!strcmpnul(libsimple_memtolower(&buf[0], &buf[0], 16), "abcdeabcde12345"));
-	assert(!strcmp(buf, "abcdeabcde12345"));
 
 	return 0;
 }
diff --git a/memptoupper.c b/memptoupper.c
index f9798f4..c02cb3c 100644
--- a/memptoupper.c
+++ b/memptoupper.c
@@ -10,17 +10,17 @@ libsimple_memptoupper(void *d_, const void *s_, size_t n)
 	const char *s = s_;
 	if (d == s) {
 		for (; n; d++, n--)
-			*d = toupper(*d);
+			*d = (char)toupper(*d);
 		return d;
 	} else if (d < s) {
 		for (; n; d++, s++, n--)
-			*d = toupper(*s);
+			*d = (char)toupper(*s);
 		return d;
 	} else {
 		ret = &d[n];
 		while (n) {
 			n--;
-			d[n] = toupper(s[n]);
+			d[n] = (char)toupper(s[n]);
 		}
 		return ret;
 	}
@@ -44,15 +44,6 @@ main(void)
 	stpcpy(buf, "abcdeABCDE12345");
 	assert(libsimple_memptoupper(&buf[0], &buf[0], 16) == &buf[16]);
 	assert(!strcmp(buf, "ABCDEABCDE12345"));
-	stpcpy(buf, "abcdeABCDE12345");
-	assert(!strcmpnul(libsimple_memtoupper(&buf[3], &buf[0], 16), "ABCDEABCDE12345"));
-	assert(!strcmp(buf, "abcABCDEABCDE12345"));
-	stpcpy(buf, "abcdeABCDE12345");
-	assert(!strcmpnul(libsimple_memtoupper(&buf[0], &buf[3], 13), "DEABCDE12345"));
-	assert(!strcmp(buf, "DEABCDE12345"));
-	stpcpy(buf, "abcdeABCDE12345");
-	assert(!strcmpnul(libsimple_memtoupper(&buf[0], &buf[0], 16), "ABCDEABCDE12345"));
-	assert(!strcmp(buf, "ABCDEABCDE12345"));
 
 	return 0;
 }
diff --git a/memrcasechr.c b/memrcasechr.c
index e4fe52a..1e6662e 100644
--- a/memrcasechr.c
+++ b/memrcasechr.c
@@ -7,7 +7,7 @@ void *
 libsimple_memrcasechr(const void *s_, int c, size_t n_)
 {
 	char *s = *(char **)(void *)&s_;
-	ssize_t n = n_;
+	ssize_t n = (ssize_t)n_;
 	c = tolower(c);
 	while (n-- && tolower(s[n]) != c);
 	return n < 0 ? NULL : &s[n];
diff --git a/memrcasechr_inv.c b/memrcasechr_inv.c
index 85f1f58..1bcf221 100644
--- a/memrcasechr_inv.c
+++ b/memrcasechr_inv.c
@@ -7,7 +7,7 @@ void *
 libsimple_memrcasechr_inv(const void *s_, int c, size_t n_)
 {
 	char *s = *(char **)(void *)&s_;
-	ssize_t n = n_;
+	ssize_t n = (ssize_t)n_;
 	c = tolower(c);
 	while (n-- && tolower(s[n]) == c);
 	return n < 0 ? NULL : &s[n];
diff --git a/memrcaseeqlen.c b/memrcaseeqlen.c
index 3f586b7..91b98d3 100644
--- a/memrcaseeqlen.c
+++ b/memrcaseeqlen.c
@@ -6,9 +6,15 @@
 size_t
 libsimple_memrcaseeqlen(const void *a_, size_t n, const void *b_, size_t m)
 {
-	const char *a = &((char *)a_)[n], *b = &((char *)b_)[m];
+	const char *a = &((const char *)a_)[n];
+	const char *b = &((const char *)b_)[m];
 	size_t i = 0, len = n < m ? n : m;
-	for (; i < len && (--a, --b, tolower(*a) == tolower(*b)); i++);
+	for (; i < len; i++) {
+		a--;
+		b--;
+		if (tolower(*a) != tolower(*b))
+			break;
+	}
 	return i;
 }
 
diff --git a/memrcasemem.c b/memrcasemem.c
index e7672f9..a7e9462 100644
--- a/memrcasemem.c
+++ b/memrcasemem.c
@@ -6,11 +6,12 @@
 void *
 libsimple_memrcasemem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
 {
-	char *hay = (void *)hay_, *start;
+	const char *hay = hay_;
 	const char *sub = sub_;
+	const char *start;
 
 	if (!subn)
-		return &hay[hayn];
+		return &REMOVE_CONST(hay, char *)[hayn];
 	if (hayn < subn)
 		return NULL;
 	if (subn == 1)
@@ -20,7 +21,7 @@ libsimple_memrcasemem(const void *hay_, size_t hayn, const void *sub_, size_t su
 	hay = &hay[hayn - subn];
 	do {
 		if (tolower(*hay) == tolower(*sub) && !libsimple_memcasecmp(hay, sub, subn))
-			return hay;
+			return REMOVE_CONST(hay, char *);
 	} while (hay-- != start);
 
 	return NULL;
diff --git a/memrchr.c b/memrchr.c
index 36385ec..40186c4 100644
--- a/memrchr.c
+++ b/memrchr.c
@@ -7,7 +7,7 @@ void *
 libsimple_memrchr(const void *s_, int c_, size_t n_)
 {
 	char *s = *(char **)(void *)&s_, c = (char)c_;
-	ssize_t n = n_;
+	ssize_t n = (ssize_t)n_;
 	while (n-- && s[n] != c);
 	return n < 0 ? NULL : &s[n];
 }
diff --git a/memrchr_inv.c b/memrchr_inv.c
index 03613e3..9ebba42 100644
--- a/memrchr_inv.c
+++ b/memrchr_inv.c
@@ -7,7 +7,7 @@ void *
 libsimple_memrchr_inv(const void *s_, int c_, size_t n_)
 {
 	char *s = *(char **)(void *)&s_, c = (char)c_;
-	ssize_t n = n_;
+	ssize_t n = (ssize_t)n_;
 	while (n-- && s[n] == c);
 	return n < 0 ? NULL : &s[n];
 }
diff --git a/memrelem.c b/memrelem.c
index 5b9cf8f..d23cb1b 100644
--- a/memrelem.c
+++ b/memrelem.c
@@ -8,46 +8,46 @@ libsimple_memrelem(const void *hay_, const void *sub_, size_t width, size_t n)
 {
 	switch (width) {
 	case 0:
-		return (void *)hay_;
+		return REMOVE_CONST(hay_, void *);
 	case 1:
 		{
-			uint8_t *hay = (void *)hay_;
-			uint8_t sub = *(uint8_t *)sub_;
+			const uint8_t *hay = hay_;
+			uint8_t sub = *(const uint8_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint8_t *);
 			break;
 		}
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint16_t *);
 			break;
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint32_t *);
 			break;
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay == sub)
-					return hay;
+					return REMOVE_CONST(hay, uint64_t *);
 			break;
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (hay += n * width; n--;) {
@@ -55,7 +55,7 @@ libsimple_memrelem(const void *hay_, const void *sub_, size_t width, size_t n)
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
 						goto next;
-				return hay;
+				return REMOVE_CONST(hay, void *);
 			next:;
 			}
 			break;
diff --git a/memrelem_inv.c b/memrelem_inv.c
index d90f358..3bb0f89 100644
--- a/memrelem_inv.c
+++ b/memrelem_inv.c
@@ -11,50 +11,50 @@ libsimple_memrelem_inv(const void *hay_, const void *sub_, size_t width, size_t
 		return NULL;
 	case 1:
 		{
-			uint8_t *hay = (void *)hay_;
-			uint8_t sub = *(uint8_t *)sub_;
+			const uint8_t *hay = hay_;
+			uint8_t sub = *(const uint8_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint8_t *);
 			break;
 		}
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint16_t *);
 			break;
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint32_t *);
 			break;
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (hay += n; n--;)
 				if (*--hay != sub)
-					return hay;
+					return REMOVE_CONST(hay, uint64_t *);
 			break;
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (hay += n * width; n--;) {
 				hay -= width;
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
-						return hay;
+						return REMOVE_CONST(hay, char *);
 			}
 			break;
 		}
diff --git a/memreplace.c b/memreplace.c
new file mode 100644
index 0000000..563e76c
--- /dev/null
+++ b/memreplace.c
@@ -0,0 +1,28 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void * libsimple_memreplace(void *, int, int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
+	assert(libsimple_memreplace(buf, 'o', 'x', 46) == &buf[46]);
+	assert(!memcmp(buf, "hellx wxrld\0gxxdbye wxrld", 26));
+
+	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
+	assert(libsimple_memreplace(buf, 'o', 'x', 12) == &buf[12]);
+	assert(!memcmp(buf, "hellx wxrld\0goodbye world", 26));
+
+	return 0;
+}
+
+#endif
diff --git a/memreqlen.c b/memreqlen.c
index c276b8d..64a2e83 100644
--- a/memreqlen.c
+++ b/memreqlen.c
@@ -6,7 +6,8 @@
 size_t
 libsimple_memreqlen(const void *a_, size_t n, const void *b_, size_t m)
 {
-	const char *a = &((char *)a_)[n], *b = &((char *)b_)[m];
+	const char *a = &((const char *)a_)[n];
+	const char *b = &((const char *)b_)[m];
 	size_t i = 0, len = n < m ? n : m;
 	for (; i < len && *--a == *--b; i++);
 	return i;
diff --git a/memrmem.c b/memrmem.c
index 3968e73..68352c2 100644
--- a/memrmem.c
+++ b/memrmem.c
@@ -6,11 +6,11 @@
 void *
 libsimple_memrmem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
 {
-	char *hay = (void *)hay_, *start;
+	const char *hay = hay_, *start;
 	const char *sub = sub_;
 
 	if (!subn)
-		return &hay[hayn];
+		return &REMOVE_CONST(hay, char *)[hayn];
 	if (hayn < subn)
 		return NULL;
 	if (subn == 1)
@@ -20,7 +20,7 @@ libsimple_memrmem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
 	hay = &hay[hayn - subn];
 	do {
 		if (*hay == *sub && !memcmp(hay, sub, subn))
-			return hay;
+			return REMOVE_CONST(hay, char *);
 	} while (hay-- != start);
 
 	return NULL;
diff --git a/memsetelem.c b/memsetelem.c
index 6bcf021..32c3f74 100644
--- a/memsetelem.c
+++ b/memsetelem.c
@@ -17,22 +17,22 @@ main(void)
 	size_t i;
 
 	memset(p, 0, sizeof(p_));
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 0, 0) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 0, 10) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 1, 0) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 2, 0) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 4, 0) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 8, 0) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 16, 0) == p);
-	assert(libsimple_memsetelem(p, &(uint64_t){~0}, 3, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 0, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 0, 10) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 1, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 2, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 4, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 8, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 16, 0) == p);
+	assert(libsimple_memsetelem(p, &(uint64_t){~(uint64_t)0}, 3, 0) == p);
 	assert(libsimple_memsetelem(p, &(uint8_t){0x09}, 1, 3000) == p);
 	assert(libsimple_memsetelem(p, &(uint16_t){0x0807}, 2, 1000) == p);
 	assert(libsimple_memsetelem(p, &(uint32_t){0x10203040UL}, 4, 300) == p);
 	assert(libsimple_memsetelem(p, &(uint64_t){0x0102030450607080ULL}, 8, 100) == p);
-	assert(libsimple_memsetelem(p, (char []){0xA0, 0xB0, 0xC0}, 3, 16) == p);
+	assert(libsimple_memsetelem(p, (char []){(char)0xA0, (char)0xB0, (char)0xC0}, 3, 16) == p);
 
 	for (i = 0; i < 48; i++)
-		assert(p[i] == ((char []){0xA0, 0xB0, 0xC0})[i % 3]);
+		assert(p[i] == ((char []){(char)0xA0, (char)0xB0, (char)0xC0})[i % 3]);
 	for (; i < 800; i += 8)
 		assert(*(uint64_t *)&p[i] == 0x0102030450607080ULL);
 	for (; i < 1200; i += 4)
diff --git a/memtolower.c b/memtolower.c
new file mode 100644
index 0000000..364776a
--- /dev/null
+++ b/memtolower.c
@@ -0,0 +1,30 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_memtolower(void *, const void *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	stpcpy(buf, "ABCDEabcde12345");
+	assert(!strcmpnul(libsimple_memtolower(&buf[3], &buf[0], 16), "abcdeabcde12345"));
+	assert(!strcmp(buf, "ABCabcdeabcde12345"));
+	stpcpy(buf, "ABCDEabcde12345");
+	assert(!strcmpnul(libsimple_memtolower(&buf[0], &buf[3], 13), "deabcde12345"));
+	assert(!strcmp(buf, "deabcde12345"));
+	stpcpy(buf, "ABCDEabcde12345");
+	assert(!strcmpnul(libsimple_memtolower(&buf[0], &buf[0], 16), "abcdeabcde12345"));
+	assert(!strcmp(buf, "abcdeabcde12345"));
+
+	return 0;
+}
+
+#endif
diff --git a/memtoupper.c b/memtoupper.c
new file mode 100644
index 0000000..376037a
--- /dev/null
+++ b/memtoupper.c
@@ -0,0 +1,30 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_memtoupper(void *, const void *, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	stpcpy(buf, "abcdeABCDE12345");
+	assert(!strcmpnul(libsimple_memtoupper(&buf[3], &buf[0], 16), "ABCDEABCDE12345"));
+	assert(!strcmp(buf, "abcABCDEABCDE12345"));
+	stpcpy(buf, "abcdeABCDE12345");
+	assert(!strcmpnul(libsimple_memtoupper(&buf[0], &buf[3], 13), "DEABCDE12345"));
+	assert(!strcmp(buf, "DEABCDE12345"));
+	stpcpy(buf, "abcdeABCDE12345");
+	assert(!strcmpnul(libsimple_memtoupper(&buf[0], &buf[0], 16), "ABCDEABCDE12345"));
+	assert(!strcmp(buf, "ABCDEABCDE12345"));
+
+	return 0;
+}
+
+#endif
diff --git a/posix_memalignn.c b/posix_memalignn.c
new file mode 100644
index 0000000..9f2617b
--- /dev/null
+++ b/posix_memalignn.c
@@ -0,0 +1,37 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_posix_memalignn(void **, size_t, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr;
+
+	assert(libsimple_posix_memalignn(&ptr, 128, 0) == EINVAL && !errno);
+
+	assert(libsimple_posix_memalignn(&ptr, 1024, SIZE_MAX, 2, 0) == ENOMEM && !errno);
+
+	assert(!libsimple_posix_memalignn(&ptr, 2 * sizeof(void *), 12, 12, 3, 0));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 432);
+		assert(info->alignment == 2 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	assert(!errno);
+
+	return 0;
+}
+
+#endif
diff --git a/posix_memalignz.c b/posix_memalignz.c
new file mode 100644
index 0000000..18530ca
--- /dev/null
+++ b/posix_memalignz.c
@@ -0,0 +1,56 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_posix_memalignz(void **, int, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_CACHELINE;
+
+	assert(!libsimple_posix_memalignz(&ptr, 0, 8 * sizeof(void *), 8));
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 8);
+		ASSERT_ALIGNMENT(info, 8 * sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert(!libsimple_posix_memalignz(&ptr, 1, 4 * sizeof(void *), 16));
+	assert(ptr);
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 16);
+		ASSERT_ALIGNMENT(info, 4 * sizeof(void *));
+		assert(info->zeroed == 16);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert(libsimple_posix_memalignz(&ptr, 0, 4 * sizeof(void *), 8) == ENOMEM && !errno);
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		assert(libsimple_posix_memalignz(&ptr, 1, 16 * sizeof(void *), 16) == ENOMEM && !errno);
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/posix_memalignzn.c b/posix_memalignzn.c
new file mode 100644
index 0000000..d91924e
--- /dev/null
+++ b/posix_memalignzn.c
@@ -0,0 +1,49 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_posix_memalignzn(void **, int, size_t, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr;
+
+	assert(libsimple_posix_memalignzn(&ptr, 0, 128, 0) == EINVAL && !errno);
+	assert(libsimple_posix_memalignzn(&ptr, 1, 128, 0) == EINVAL && !errno);
+
+	assert(libsimple_posix_memalignzn(&ptr, 0, 1024, SIZE_MAX, 2, 0) == ENOMEM && !errno);
+	assert(libsimple_posix_memalignzn(&ptr, 1, 1024, SIZE_MAX, 2, 0) == ENOMEM && !errno);
+
+	assert(!libsimple_posix_memalignzn(&ptr, 0, sizeof(void *), 12, 12, 0));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 144);
+		assert(info->alignment == sizeof(void *));
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	assert(!libsimple_posix_memalignzn(&ptr, 1, 2 * sizeof(void *), 12, 12, 2, 0));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 288);
+		assert(info->alignment == 2 * sizeof(void *));
+		assert(info->zeroed == 288);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	assert(!errno);
+
+	return 0;
+}
+
+#endif
diff --git a/pvalloc.c b/pvalloc.c
new file mode 100644
index 0000000..e5a9c7b
--- /dev/null
+++ b/pvalloc.c
@@ -0,0 +1,45 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_pvalloc(size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_pvalloc(5)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5 || info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvalloc(5 * pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	return 0;
+}
+
+#endif
diff --git a/pvallocn.c b/pvallocn.c
new file mode 100644
index 0000000..5a51408
--- /dev/null
+++ b/pvallocn.c
@@ -0,0 +1,50 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_pvallocn(size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_pvallocn(5 * pagesize - 1, 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 10 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert(!libsimple_pvallocn(0) && errno == EINVAL);
+	errno = 0;
+
+	assert(!libsimple_pvallocn(SIZE_MAX, 2, 0) && errno == ENOMEM);
+	errno = 0;
+
+	assert((ptr = libsimple_pvallocn(9, (pagesize - 1), 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 9 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	return 0;
+}
+
+#endif
diff --git a/pvallocz.c b/pvallocz.c
new file mode 100644
index 0000000..3e3f187
--- /dev/null
+++ b/pvallocz.c
@@ -0,0 +1,110 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_pvallocz(int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_pvallocz(0, 9)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvallocz(1, 7)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvallocz(1, pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvallocz(1, pagesize)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvallocz(1, pagesize + 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 2 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == 2 * pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvallocz(1, 3 * pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 3 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == 3 * pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvallocz(0, 4 * pagesize - 1)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 4 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert(!libsimple_pvallocz(0, 8) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		assert(!libsimple_pvallocz(1, 16) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/pvalloczn.c b/pvalloczn.c
new file mode 100644
index 0000000..9349f47
--- /dev/null
+++ b/pvalloczn.c
@@ -0,0 +1,75 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_pvalloczn(int, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_pvalloczn(1, 3 * pagesize - 1, 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 6 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == 6 * pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_pvalloczn(0, 4 * pagesize - 1, 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 8 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert(!libsimple_pvalloczn(0, 0) && errno == EINVAL);
+	errno = 0;
+	assert(!libsimple_pvalloczn(1, 0) && errno == EINVAL);
+	errno = 0;
+
+	assert(!libsimple_pvalloczn(0, SIZE_MAX, 2, 0) && errno == ENOMEM);
+	errno = 0;
+	assert(!libsimple_pvalloczn(1, SIZE_MAX, 2, 0) && errno == ENOMEM);
+	errno = 0;
+
+	assert((ptr = libsimple_pvalloczn(0, 9, 9, pagesize - 1, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 81 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	assert((ptr = libsimple_pvalloczn(1, 9, 8, pagesize - 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 72 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	return 0;
+}
+
+#endif
diff --git a/rawmemccpy.c b/rawmemccpy.c
new file mode 100644
index 0000000..cba8476
--- /dev/null
+++ b/rawmemccpy.c
@@ -0,0 +1,28 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_rawmemccpy(void *restrict, const void *restrict, int);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	memset(buf, 'x', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	assert(libsimple_rawmemccpy(buf, "hello", 'o') == &buf[5]);
+	assert(!strncmp(buf, "hellox", 6));
+
+	memset(buf, 'x', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	assert(libsimple_rawmemccpy(buf, "hello", 'l') == &buf[3]);
+	assert(!strncmp(buf, "helx", 4));
+
+	return 0;
+}
+
+#endif
diff --git a/rawmemcmove.c b/rawmemcmove.c
new file mode 100644
index 0000000..fd831af
--- /dev/null
+++ b/rawmemcmove.c
@@ -0,0 +1,52 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void * libsimple_rawmemcmove(void *__d_, const void *__s_, int __c_);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	char buf[100];
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_rawmemcmove(&buf[5], &buf[5], 'o') == &buf[5 + 5]);
+	assert(!strncmp(buf, "-----hello-", 11));
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_rawmemcmove(&buf[5], &buf[5], 'l') == &buf[5 + 3]);
+	assert(!strncmp(buf, "-----hello-", 11));
+
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_rawmemcmove(&buf[3], &buf[5], 'o') == &buf[3 + 5]);
+	assert(!strncmp(buf, "---hellolo-", 11));
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_rawmemcmove(&buf[3], &buf[5], 'l') == &buf[3 + 3]);
+	assert(!strncmp(buf, "---helello-", 11));
+
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_rawmemcmove(&buf[8], &buf[5], 'o') == &buf[8 + 5]);
+	assert(!strncmp(buf, "-----helhello-", 14));
+
+	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
+	stpcpy(&buf[5], "hello")[0] = '-';
+	assert(libsimple_rawmemcmove(&buf[8], &buf[5], 'l') == &buf[8 + 3]);
+	assert(!strncmp(buf, "-----helhel-", 12));
+
+	return 0;
+}
+
+#endif
diff --git a/rawmemelem.c b/rawmemelem.c
index fa67a51..798f275 100644
--- a/rawmemelem.c
+++ b/rawmemelem.c
@@ -8,40 +8,40 @@ libsimple_rawmemelem(const void *hay_, const void *sub_, size_t width)
 {
 	switch (width) {
 	case 0:
-		return (void *)hay_;
+		return REMOVE_CONST(hay_, void *);
 	case 1:
-		return rawmemchr(hay_, *(char *)sub_);
+		return rawmemchr(hay_, *(const char *)sub_);
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (; *hay != sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint16_t *);
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (; *hay != sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint32_t *);
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (; *hay != sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint64_t *);
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (;; hay += width) {
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
 						goto next;
-				return hay;
+				return REMOVE_CONST(hay, char *);
 			next:;
 			}
 		}
diff --git a/rawmemelem_inv.c b/rawmemelem_inv.c
index 7046d3c..d9ed507 100644
--- a/rawmemelem_inv.c
+++ b/rawmemelem_inv.c
@@ -10,37 +10,37 @@ libsimple_rawmemelem_inv(const void *hay_, const void *sub_, size_t width)
 	case 0:
 		abort();
 	case 1:
-		return rawmemchr_inv(hay_, *(char *)sub_);
+		return rawmemchr_inv(hay_, *(const char *)sub_);
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (; *hay == sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint16_t *);
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (; *hay == sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint32_t *);
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (; *hay == sub; hay++);
-			return hay;
+			return REMOVE_CONST(hay, uint64_t *);
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (;; hay += width)
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
-						return hay;
+						return REMOVE_CONST(hay, void *);
 		}
 	}
 }
diff --git a/rawmemelemmove.c b/rawmemelemmove.c
index 8903ae8..717a590 100644
--- a/rawmemelemmove.c
+++ b/rawmemelemmove.c
@@ -5,20 +5,21 @@
 
 #define RAWMEMELEMMOVE(TYPE)\
 	do {\
-		TYPE *p;\
+		const TYPE *p;\
+		TYPE *ret;\
 		size_t n;\
 		if (d <= s) {\
 			for (; (*d++ = *s) != elem; s++);\
 			return d;\
 		} else {\
-			for (p = *(TYPE **)(void *)&s; *p++ != elem;);\
+			for (p = s; *p++ != elem;);\
 			n = (size_t)(p - s);\
-			p = &d[n];\
+			ret = &d[n];\
 			while (n) {\
 				n--;\
 				d[n] = s[n];\
 			}\
-			return p;\
+			return ret;\
 		}\
 	} while (0)
 
@@ -47,7 +48,8 @@ rawmemelemmove64(uint64_t *restrict d, const uint64_t *restrict s, uint64_t elem
 static char *
 rawmemelemmovex(char *restrict d, const char *restrict s, const char *restrict elem, size_t width)
 {
-	char *p;
+	const char *p;
+	char *ret;
 	size_t i, n;
 	if (d <= s) {
 		for (;; s += width) {
@@ -62,7 +64,7 @@ rawmemelemmovex(char *restrict d, const char *restrict s, const char *restrict e
 			d += width;
 		}
 	} else {
-		for (p = *(char **)(void *)&s;;) {
+		for (p = s;;) {
 			for (i = 0; i < width; i++)
 				if (p[i] != elem[i])
 					goto next_backwards;
@@ -72,12 +74,12 @@ rawmemelemmovex(char *restrict d, const char *restrict s, const char *restrict e
 			p += width;
 		}
 		n = (size_t)(p - s);
-		p = &d[n];
+		ret = &d[n];
 		while (n) {
 			n--;
 			d[n] = s[n];
 		}
-		return p;
+		return ret;
 	}
 }
 
@@ -133,7 +135,7 @@ main(void)
 	assert(!strncmp(buf, "-----hello-", 11));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "hello")[0] = '-';;
+	stpcpy(&buf[5], "hello")[0] = '-';
 	assert(libsimple_rawmemelemmove(&buf[5], &buf[5], "l", 1) == &buf[5 + 3]);
 	assert(!strncmp(buf, "-----hello-", 11));
 
@@ -164,7 +166,7 @@ main(void)
 	assert(!strncmp(buf, "-----.h.e.l.l.o-", 16));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], ".h.e.l.l.o")[0] = '-';;
+	stpcpy(&buf[5], ".h.e.l.l.o")[0] = '-';
 	assert(libsimple_rawmemelemmove(&buf[5], &buf[5], ".l", 2) == &buf[5 + 3 * 2]);
 	assert(!strncmp(buf, "-----.h.e.l.l.o-", 16));
 
@@ -195,7 +197,7 @@ main(void)
 	assert(!strncmp(buf, "-----..h..e..l..l..o-", 21));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "..h..e..l..l..o")[0] = '-';;
+	stpcpy(&buf[5], "..h..e..l..l..o")[0] = '-';
 	assert(libsimple_rawmemelemmove(&buf[5], &buf[5], "..l", 3) == &buf[5 + 3 * 3]);
 	assert(!strncmp(buf, "-----..h..e..l..l..o-", 21));
 
@@ -226,7 +228,7 @@ main(void)
 	assert(!strncmp(buf, "-----...h...e...l...l...o-", 26));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], "...h...e...l...l...o")[0] = '-';;
+	stpcpy(&buf[5], "...h...e...l...l...o")[0] = '-';
 	assert(libsimple_rawmemelemmove(&buf[5], &buf[5], "...l", 4) == &buf[5 + 3 * 4]);
 	assert(!strncmp(buf, "-----...h...e...l...l...o-", 26));
 
@@ -257,7 +259,7 @@ main(void)
 	assert(!strncmp(buf, "-----.......h.......e.......l.......l.......o-", 46));
 
 	memset(buf, '-', sizeof(buf)), buf[sizeof(buf) - 1] = '\0';
-	stpcpy(&buf[5], ".......h.......e.......l.......l.......o")[0] = '-';;
+	stpcpy(&buf[5], ".......h.......e.......l.......l.......o")[0] = '-';
 	assert(libsimple_rawmemelemmove(&buf[5], &buf[5], ".......l", 8) == &buf[5 + 3 * 8]);
 	assert(!strncmp(buf, "-----.......h.......e.......l.......l.......o-", 46));
 
diff --git a/rawmemrcasechr.c b/rawmemrcasechr.c
index 68c5645..de33b8f 100644
--- a/rawmemrcasechr.c
+++ b/rawmemrcasechr.c
@@ -8,7 +8,9 @@ libsimple_rawmemrcasechr(const void *s_, int c, size_t n)
 {
 	char *s = *(char **)(void *)&s_;
 	c = tolower(c);
-	while (--n, tolower(s[n]) != c);
+	do {
+		n--;
+	} while (tolower(s[n]) != c);
 	return &s[n];
 }
 
diff --git a/rawmemrcasechr_inv.c b/rawmemrcasechr_inv.c
index 483de3e..74ec992 100644
--- a/rawmemrcasechr_inv.c
+++ b/rawmemrcasechr_inv.c
@@ -8,7 +8,9 @@ libsimple_rawmemrcasechr_inv(const void *s_, int c, size_t n)
 {
 	char *s = *(char **)(void *)&s_;
 	c = tolower(c);
-	while (--n, tolower(s[n]) == c);
+	do {
+		n--;
+	} while (tolower(s[n]) == c);
 	return &s[n];
 }
 
diff --git a/rawmemrelem.c b/rawmemrelem.c
index d8507b3..08e3377 100644
--- a/rawmemrelem.c
+++ b/rawmemrelem.c
@@ -8,38 +8,38 @@ libsimple_rawmemrelem(const void *hay_, const void *sub_, size_t width, size_t n
 {
 	switch (width) {
 	case 0:
-		return (void *)hay_;
+		return REMOVE_CONST(hay_, void *);
 	case 1:
 		{
-			uint8_t *hay = (void *)hay_;
-			uint8_t sub = *(uint8_t *)sub_;
+			const uint8_t *hay = hay_;
+			uint8_t sub = *(const uint8_t *)sub_;
 			for (hay += n; *--hay != sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint8_t *);
 		}
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (hay += n; *--hay != sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint16_t *);
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (hay += n; *--hay != sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint32_t *);
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (hay += n; *--hay != sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint64_t *);
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (hay += n * width;;) {
@@ -47,7 +47,7 @@ libsimple_rawmemrelem(const void *hay_, const void *sub_, size_t width, size_t n
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
 						goto next;
-				return hay;
+				return REMOVE_CONST(hay, char *);
 			next:;
 			}
 		}
diff --git a/rawmemrelem_inv.c b/rawmemrelem_inv.c
index 74a3cfc..e39a271 100644
--- a/rawmemrelem_inv.c
+++ b/rawmemrelem_inv.c
@@ -11,42 +11,42 @@ libsimple_rawmemrelem_inv(const void *hay_, const void *sub_, size_t width, size
 		abort();
 	case 1:
 		{
-			uint8_t *hay = (void *)hay_;
-			uint8_t sub = *(uint8_t *)sub_;
+			const uint8_t *hay = hay_;
+			uint8_t sub = *(const uint8_t *)sub_;
 			for (hay += n; *--hay == sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint8_t *);
 		}
 	case 2:
 		{
-			uint16_t *hay = (void *)hay_;
-			uint16_t sub = *(uint16_t *)sub_;
+			const uint16_t *hay = hay_;
+			uint16_t sub = *(const uint16_t *)sub_;
 			for (hay += n; *--hay == sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint16_t *);
 		}
 	case 4:
 		{
-			uint32_t *hay = (void *)hay_;
-			uint32_t sub = *(uint32_t *)sub_;
+			const uint32_t *hay = hay_;
+			uint32_t sub = *(const uint32_t *)sub_;
 			for (hay += n; *--hay == sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint32_t *);
 		}
 	case 8:
 		{
-			uint64_t *hay = (void *)hay_;
-			uint64_t sub = *(uint64_t *)sub_;
+			const uint64_t *hay = hay_;
+			uint64_t sub = *(const uint64_t *)sub_;
 			for (hay += n; *--hay == sub;);
-			return hay;
+			return REMOVE_CONST(hay, uint64_t *);
 		}
 	default:
 		{
-			char *hay = (void *)hay_;
+			const char *hay = hay_;
 			const char *sub = sub_;
 			size_t i;
 			for (hay += n * width;;) {
 				hay -= width;
 				for (i = 0; i < width; i++)
 					if (hay[i] != sub[i])
-						return hay;
+						return REMOVE_CONST(hay, char *);
 			}
 		}
 	}
diff --git a/reallocarray.c b/reallocarray.c
new file mode 100644
index 0000000..640e84a
--- /dev/null
+++ b/reallocarray.c
@@ -0,0 +1,59 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_reallocarray(void *, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr, *old;
+
+	assert((ptr = libsimple_reallocarray(NULL, 1, 5)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		info->refcount += 1;
+	}
+	stpcpy(ptr, "test");
+	assert((ptr = libsimple_reallocarray(old = ptr, 10, 10)));
+	assert(!strcmp(ptr, "test"));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 100);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		assert(ptr != old);
+		free(old);
+	}
+	free(ptr);
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert(!libsimple_reallocarray(NULL, 1, 1) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+	}
+
+#if defined(__GNUC__) && !defined(__clang)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Walloc-size-larger-than="
+#endif
+
+	assert(!libsimple_reallocarray(NULL, SIZE_MAX, SIZE_MAX) && errno == ENOMEM);
+
+#if defined(__GNUC__) && !defined(__clang)
+# pragma GCC diagnostic pop
+#endif
+
+	return 0;
+}
+
+#endif
diff --git a/reallocarrayf.c b/reallocarrayf.c
new file mode 100644
index 0000000..f95c5ff
--- /dev/null
+++ b/reallocarrayf.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_reallocarrayf(void *, size_t, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/reallocf.c b/reallocf.c
new file mode 100644
index 0000000..ded2f17
--- /dev/null
+++ b/reallocf.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_reallocf(void *, size_t); /* TODO test */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/reallocfn.c b/reallocfn.c
new file mode 100644
index 0000000..b22b1c7
--- /dev/null
+++ b/reallocfn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_reallocfn(void *, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/reallocn.c b/reallocn.c
new file mode 100644
index 0000000..75860bd
--- /dev/null
+++ b/reallocn.c
@@ -0,0 +1,50 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_reallocn(void *, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *info;
+	void *ptr, *old;
+
+	assert(!libsimple_reallocn(NULL, 0) && errno == EINVAL);
+	errno = 0;
+
+	assert(!libsimple_reallocn(NULL, SIZE_MAX, 2, 0) && errno == ENOMEM);
+	errno = 0;
+
+	assert((ptr = libsimple_reallocn(NULL, 5, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 5);
+		assert(!info->zeroed);
+		info->refcount += 1;
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	stpcpy(ptr, "test");
+	assert((ptr = libsimple_reallocn(old = ptr, 10, 0)));
+	assert(!strcmp(ptr, "test"));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 10);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+		assert(ptr != old);
+		free(old);
+	}
+	free(ptr);
+
+	assert(!errno);
+
+	return 0;
+}
+
+#endif
diff --git a/stpntolower.c b/stpntolower.c
index 9aca9f9..86adb89 100644
--- a/stpntolower.c
+++ b/stpntolower.c
@@ -10,11 +10,11 @@ libsimple_stpntolower(char *d, const char *s, size_t n)
 	char *ret;
 	if (d == s) {
 		for (; n && *d; d++, n--)
-			*d = tolower(*d);
+			*d = (char)tolower(*d);
 		return d;
 	} else if (d < s) {
 		for (; n && *s; d++, s++, n--)
-			*d = tolower(*s);
+			*d = (char)tolower(*s);
 		if (n)
 			*d = '\0';
 		return d;
@@ -22,9 +22,9 @@ libsimple_stpntolower(char *d, const char *s, size_t n)
 		for (i = 0; i < n && s[i]; i++);
 		ret = &d[i];
 		if (i != n)
-			d[i] = tolower(s[i]);
+			d[i] = (char)tolower(s[i]);
 		while (i--)
-			d[i] = tolower(s[i]);
+			d[i] = (char)tolower(s[i]);
 		return ret;
 	}
 }
diff --git a/stpntoupper.c b/stpntoupper.c
index a6e3769..a434153 100644
--- a/stpntoupper.c
+++ b/stpntoupper.c
@@ -10,11 +10,11 @@ libsimple_stpntoupper(char *d, const char *s, size_t n)
 	char *ret;
 	if (d == s) {
 		for (; n && *d; d++, n--)
-			*d = toupper(*d);
+			*d = (char)toupper(*d);
 		return d;
 	} else if (d < s) {
 		for (; n && *s; d++, s++, n--)
-			*d = toupper(*s);
+			*d = (char)toupper(*s);
 		if (n)
 			*d = '\0';
 		return d;
@@ -22,9 +22,9 @@ libsimple_stpntoupper(char *d, const char *s, size_t n)
 		for (i = 0; i < n && s[i]; i++);
 		ret = &d[i];
 		if (i != n)
-			d[i] = toupper(s[i]);
+			d[i] = (char)toupper(s[i]);
 		while (i--)
-			d[i] = toupper(s[i]);
+			d[i] = (char)toupper(s[i]);
 		return ret;
 	}
 }
diff --git a/stptolower.c b/stptolower.c
index 61108ad..73259f9 100644
--- a/stptolower.c
+++ b/stptolower.c
@@ -10,18 +10,18 @@ libsimple_stptolower(char *d, const char *s)
 	char *ret;
 	if (d == s) {
 		for (; *d; d++)
-			*d = tolower(*d);
+			*d = (char)tolower(*d);
 		return d;
 	} else if (d < s) {
 		for (; *s; d++, s++)
-			*d = tolower(*s);
+			*d = (char)tolower(*s);
 		*d = '\0';
 		return d;
 	} else {
 		for (n = 0; s[n]; n++);
 		ret = &d[n];
 		do {
-			d[n] = tolower(s[n]);
+			d[n] = (char)tolower(s[n]);
 		} while (n--);
 		return ret;
 	}
diff --git a/stptoupper.c b/stptoupper.c
index ad6c73e..ee56b75 100644
--- a/stptoupper.c
+++ b/stptoupper.c
@@ -10,18 +10,18 @@ libsimple_stptoupper(char *d, const char *s)
 	char *ret;
 	if (d == s) {
 		for (; *d; d++)
-			*d = toupper(*d);
+			*d = (char)toupper(*d);
 		return d;
 	} else if (d < s) {
 		for (; *s; d++, s++)
-			*d = toupper(*s);
+			*d = (char)toupper(*s);
 		*d = '\0';
 		return d;
 	} else {
 		for (n = 0; s[n]; n++);
 		ret = &d[n];
 		do {
-			d[n] = toupper(s[n]);
+			d[n] = (char)toupper(s[n]);
 		} while (n--);
 		return ret;
 	}
diff --git a/strtoi.c b/strtoi.c
index 6b3fcb2..448e485 100644
--- a/strtoi.c
+++ b/strtoi.c
@@ -6,7 +6,7 @@
 signed int
 libsimple_strtoi(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */
 {
-	signed int r = strtol(nptr, end, base);
+	signed long int r = strtol(nptr, end, base);
 	if(r < INT_MIN) {
 		r = INT_MIN;
 		errno = ERANGE;
diff --git a/strtotimespec.c b/strtotimespec.c
index d6bd64c..7c1494e 100644
--- a/strtotimespec.c
+++ b/strtotimespec.c
@@ -11,9 +11,12 @@ libsimple_strtotimespec(struct timespec *restrict ts, const char *restrict s, ch
 	long int nsec = 0;
 	long int mul = 100000000L;
 	const char *p;
+	const char *end_s;
 
-	if (end)
-		*end = (void *)s;
+	if (end) {
+		end_s = s;
+		*end = REMOVE_CONST(end_s, char *);
+	}
 
 	while (isspace(*s))
 		s++;
@@ -58,8 +61,10 @@ libsimple_strtotimespec(struct timespec *restrict ts, const char *restrict s, ch
 	if (*s != '.') {
 		ts->tv_sec = sec;
 		ts->tv_nsec = 0;
-		if (end)
-			*end = (void *)s;
+		if (end) {
+			end_s = s;
+			*end = REMOVE_CONST(end_s, char *);
+		}
 		return 0;
 	}
 
@@ -85,7 +90,7 @@ libsimple_strtotimespec(struct timespec *restrict ts, const char *restrict s, ch
 			}
 		}
 		if (end)
-			*end = (void *)p;
+			*end = REMOVE_CONST(p, char *);
 		p = s;
 		while (mul) {
 			for (s = p; mul && isdigit(*s); s++) {
@@ -118,8 +123,10 @@ libsimple_strtotimespec(struct timespec *restrict ts, const char *restrict s, ch
 			while (isdigit(*s))
 				s++;
 		}
-		if (end)
-			*end = (void *)s;
+		if (end) {
+			end_s = s;
+			*end = REMOVE_CONST(end_s, char *);
+		}
 	}
 
 	if (neg && nsec) {
@@ -164,8 +171,10 @@ overflow_periodic:
 	}
 
 overflow:
-	if (end)
-		*end = (void *)s;
+	if (end) {
+		end_s = s;
+		*end = REMOVE_CONST(end_s, char *);
+	}
 	if (neg) {
 		ts->tv_sec = TIME_MIN;
 		ts->tv_nsec = 0;
diff --git a/strtou.c b/strtou.c
index 4201c1f..1faee3c 100644
--- a/strtou.c
+++ b/strtou.c
@@ -6,7 +6,7 @@
 unsigned int
 libsimple_strtou(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */
 {
-	signed long int r = strtoul(nptr, end, base);
+	unsigned long int r = strtoul(nptr, end, base);
 	if(r > UINT_MAX) {
 		r = UINT_MAX;
 		errno = ERANGE;
diff --git a/strtouh.c b/strtouh.c
index 7e4505f..9033930 100644
--- a/strtouh.c
+++ b/strtouh.c
@@ -6,7 +6,7 @@
 unsigned short int
 libsimple_strtouh(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */
 {
-	signed long int r = strtoul(nptr, end, base);
+	unsigned long int r = strtoul(nptr, end, base);
 	if(r > USHRT_MAX) {
 		r = USHRT_MAX;
 		errno = ERANGE;
diff --git a/strtouhh.c b/strtouhh.c
index b13800d..72dbd7c 100644
--- a/strtouhh.c
+++ b/strtouhh.c
@@ -6,7 +6,7 @@
 unsigned char
 libsimple_strtouhh(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */
 {
-	signed long int r = strtoul(nptr, end, base);
+	unsigned long int r = strtoul(nptr, end, base);
 	if(r > UCHAR_MAX) {
 		r = UCHAR_MAX;
 		errno = ERANGE;
diff --git a/sumtimeval.c b/sumtimeval.c
index e52d58f..09cadb1 100644
--- a/sumtimeval.c
+++ b/sumtimeval.c
@@ -47,62 +47,82 @@ main(void)
 {
 	struct timeval r, a, b;
 
-	a.tv_sec = 0, a.tv_usec = 0;
-	b.tv_sec = 0, b.tv_usec = 0;
+	a.tv_sec  = 0;
+	a.tv_usec = 0;
+	b.tv_sec  = 0;
+	b.tv_usec = 0;
 	assert(!libsimple_sumtimeval(&r, &a, &b));
 	assert(r.tv_sec  == 0);
 	assert(r.tv_usec == 0);
 
-	a.tv_sec = 10, a.tv_usec = 10000L;
-	b.tv_sec =  0, b.tv_usec =     0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 10000L;
+	b.tv_sec  = 0;
+	b.tv_usec = 0L;
 	assert(!libsimple_sumtimeval(&r, &a, &b));
 	assert(r.tv_sec  == 10);
 	assert(r.tv_usec == 10000L);
 
-	a.tv_sec =  10, a.tv_usec = 10000L;
-	b.tv_sec = -10, b.tv_usec =     0L;
+	a.tv_sec  = 10;
+	a.tv_usec = 10000L;
+	b.tv_sec  = -10;
+	b.tv_usec = 0L;
 	assert(!libsimple_sumtimeval(&r, &a, &b));
 	assert(r.tv_sec  == 0);
 	assert(r.tv_usec == 10000L);
 
-	a.tv_sec =  10, a.tv_usec = 10000L;
-	b.tv_sec = -20, b.tv_usec = 20000L;
+	a.tv_sec  = 10;
+	a.tv_usec = 10000L;
+	b.tv_sec  = -20;
+	b.tv_usec = 20000L;
 	assert(!libsimple_sumtimeval(&r, &a, &b));
 	assert(r.tv_sec  == -10);
 	assert(r.tv_usec == 30000L);
 
-	a.tv_sec = 1, a.tv_usec = 999999L;
-	b.tv_sec = 1, b.tv_usec =      1L;
+	a.tv_sec  = 1;
+	a.tv_usec = 999999L;
+	b.tv_sec  = 1;
+	b.tv_usec = 1L;
 	assert(!libsimple_sumtimeval(&r, &a, &b));
 	assert(r.tv_sec  == 3);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = TIME_MAX, a.tv_usec = 0L;
-	b.tv_sec = TIME_MAX, b.tv_usec = 0L;
+	a.tv_sec  = TIME_MAX;
+	a.tv_usec = 0L;
+	b.tv_sec  = TIME_MAX;
+	b.tv_usec = 0L;
 	assert(libsimple_sumtimeval(&r, &a, &b) == -1);
 	assert(r.tv_sec  == TIME_MAX);
 	assert(r.tv_usec == 999999L);
 
-	a.tv_sec = TIME_MAX, a.tv_usec = 999999L;
-	b.tv_sec =        0, b.tv_usec =      1L;
+	a.tv_sec  = TIME_MAX;
+	a.tv_usec = 999999L;
+	b.tv_sec  = 0;
+	b.tv_usec = 1L;
 	assert(libsimple_sumtimeval(&r, &a, &b) == -1);
 	assert(r.tv_sec  == TIME_MAX);
 	assert(r.tv_usec == 999999L);
 
-	a.tv_sec = TIME_MAX, a.tv_usec =      1L;
-	b.tv_sec =        0, b.tv_usec = 999999L;
+	a.tv_sec  = TIME_MAX;
+	a.tv_usec = 1L;
+	b.tv_sec  = 0;
+	b.tv_usec = 999999L;
 	assert(libsimple_sumtimeval(&r, &a, &b) == -1);
 	assert(r.tv_sec  == TIME_MAX);
 	assert(r.tv_usec == 999999L);
 
-	a.tv_sec = TIME_MIN, a.tv_usec = 0L;
-	b.tv_sec = TIME_MIN, b.tv_usec = 0L;
+	a.tv_sec  = TIME_MIN;
+	a.tv_usec = 0L;
+	b.tv_sec  = TIME_MIN;
+	b.tv_usec = 0L;
 	assert(libsimple_sumtimeval(&r, &a, &b) == -1);
 	assert(r.tv_sec  == TIME_MIN);
 	assert(r.tv_usec == 0L);
 
-	a.tv_sec = TIME_MIN, a.tv_usec = 100L;
-	b.tv_sec = TIME_MIN, b.tv_usec = 100L;
+	a.tv_sec  = TIME_MIN;
+	a.tv_usec = 100L;
+	b.tv_sec  = TIME_MIN;
+	b.tv_usec = 100L;
 	assert(libsimple_sumtimeval(&r, &a, &b) == -1);
 	assert(r.tv_sec  == TIME_MIN);
 	assert(r.tv_usec == 0L);
diff --git a/test.c b/test.c
index e5ecf00..29a501b 100644
--- a/test.c
+++ b/test.c
@@ -159,7 +159,7 @@ realloc(void *ptr, size_t size)
 		return malloc(size);
 	ret = malloc(size);
 	if (!ret)
-		return malloc;
+		return NULL;
 	info = get_allocinfo(ret);
 	n = MIN(size, info->size);
 	info->zeroed = MIN(n, info->zeroed);
@@ -347,7 +347,7 @@ test_vfprintf(FILE *restrict stream, const char *restrict format, va_list ap)
 		n = (size_t)r;
 		alloc_fail_in = 0;
 		assert((buf = malloc(n + 1)));
-		n = vsnprintf(buf, n + 1, format, ap);
+		n = (size_t)vsnprintf(buf, n + 1, format, ap);
 		if (fileno(stream) != STDERR_FILENO || stderr_real) {
 			fwrite(buf, 1, n, stream);
 		} else {
diff --git a/test.h b/test.h
index d8ac2d4..a961e13 100644
--- a/test.h
+++ b/test.h
@@ -52,7 +52,7 @@
 		assert(len__ >= 0);\
 		assert((size_t)len__ == stderr_n);\
 		assert(!memcmp(buf__, (char **)(void *)(&stderr_buf), stderr_n)); \
-	} while (0);
+	} while (0)
 
 
 struct allocinfo {
@@ -66,7 +66,9 @@ struct allocinfo {
 };
 
 
+#ifndef LIBSIMPLE_ARG_H
 extern char *argv0;
+#endif
 
 extern volatile size_t alloc_fail_in;
 extern volatile int exit_real;
@@ -98,17 +100,32 @@ test_fprintf(FILE *restrict stream, const char *restrict format, ...)
 
 
 
+#if defined(__GNUC__)
+__attribute__((__const__))
+#endif
 static size_t
 gcd(size_t u, size_t v)
 {
 	size_t t;
 	int shift = 0;
 	/* Not needed because u>0, v>0: if (!(u | v)) return u + v; */
-	while (!((u | v) & 1)) u >>= 1, v >>= 1, shift++;
-	while (!(u & 1))       u >>= 1;
+	while (!((u | v) & 1)) {
+		u >>= 1;
+		v >>= 1;
+		shift++;
+	}
+	while (!(u & 1)) {
+		u >>= 1;
+	}
 	do {
-		while (!(v & 1)) v >>= 1;
-		if (u > v)       t = u, u = v, v = t;
+		while (!(v & 1)) {
+			v >>= 1;
+		}
+		if (u > v) {
+			t = u;
+			u = v;
+			v = t;
+		}
 	} while (v -= u);
 	return u << shift;
 }
diff --git a/timespectodouble.c b/timespectodouble.c
new file mode 100644
index 0000000..e2d1bcc
--- /dev/null
+++ b/timespectodouble.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline double libsimple_timespectodouble(const struct timespec *); /* TODO tested in libsimple.c */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/timeval2timespec.c b/timeval2timespec.c
new file mode 100644
index 0000000..e7e529e
--- /dev/null
+++ b/timeval2timespec.c
@@ -0,0 +1,40 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_timeval2timespec(struct timespec *restrict, const struct timeval *restrict);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct timespec ts;
+	libsimple_timeval2timespec(&ts, &(struct timeval){0, 0L});
+	assert(ts.tv_sec  == 0);
+	assert(ts.tv_nsec == 0L);
+	libsimple_timeval2timespec(&ts, &(struct timeval){0, 1L});
+	assert(ts.tv_sec  == 0);
+	assert(ts.tv_nsec == 1000L);
+	libsimple_timeval2timespec(&ts, &(struct timeval){0, 999999L});
+	assert(ts.tv_sec  == 0);
+	assert(ts.tv_nsec == 999999000L);
+	libsimple_timeval2timespec(&ts, &(struct timeval){10, 0L});
+	assert(ts.tv_sec  == 10);
+	assert(ts.tv_nsec == 0L);
+	libsimple_timeval2timespec(&ts, &(struct timeval){10, 1L});
+	assert(ts.tv_sec  == 10);
+	assert(ts.tv_nsec == 1000L);
+	libsimple_timeval2timespec(&ts, &(struct timeval){-10, 0L});
+	assert(ts.tv_sec  == -10);
+	assert(ts.tv_nsec == 0L);
+	libsimple_timeval2timespec(&ts, &(struct timeval){-10, 1L});
+	assert(ts.tv_sec  == -10);
+	assert(ts.tv_nsec == 1000L);
+	return 0;
+}
+
+#endif
diff --git a/timevaltodouble.c b/timevaltodouble.c
new file mode 100644
index 0000000..1d3dacb
--- /dev/null
+++ b/timevaltodouble.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline double libsimple_timevaltodouble(const struct timeval *); /* TODO tested in libsimple.c */
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0;
+}
+
+#endif
diff --git a/unlist.c b/unlist.c
index 192fad0..92b7f8f 100644
--- a/unlist.c
+++ b/unlist.c
@@ -17,7 +17,7 @@ main(void)
 	size_t i, n;
 
 	for (i = 0, n = 10; i < n; i++)
-		buf[i] = i;
+		buf[i] = (char)i;
 	LIBSIMPLE_UNLIST(buf, 4, &n);
 	LIBSIMPLE_UNLIST(buf, 9 - 1, &n);
 	LIBSIMPLE_UNLIST(buf, 6 - 1, &n);
@@ -31,7 +31,7 @@ main(void)
 	assert(buf[6] == 8);
 
 	for (i = 0, n = 10; i < n; i++)
-		intarray[i] = i;
+		intarray[i] = (int)i;
 	LIBSIMPLE_UNLIST(intarray, 4, &n);
 	LIBSIMPLE_UNLIST(intarray, 9 - 1, &n);
 	LIBSIMPLE_UNLIST(intarray, 6 - 1, &n);
diff --git a/vallocz.c b/vallocz.c
new file mode 100644
index 0000000..06263ed
--- /dev/null
+++ b/vallocz.c
@@ -0,0 +1,77 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_vallocz(int, size_t);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_vallocz(0, 9)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 9 || info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_vallocz(1, 7)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 7 || info->size == pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == 7 || info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_vallocz(1, 3 * pagesize)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 3 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == 3 * pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_vallocz(0, 4 * pagesize)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 4 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	if (have_custom_malloc()) {
+		alloc_fail_in = 1;
+		assert(!libsimple_vallocz(0, 8) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+
+		alloc_fail_in = 1;
+		assert(!libsimple_vallocz(1, 16) && errno == ENOMEM);
+		assert(!alloc_fail_in);
+	}
+
+	return 0;
+}
+
+#endif
diff --git a/valloczn.c b/valloczn.c
new file mode 100644
index 0000000..27d6d1b
--- /dev/null
+++ b/valloczn.c
@@ -0,0 +1,75 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_valloczn(int, size_t, ...);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	struct allocinfo *volatile info;
+	void *ptr;
+	DEFINE_PAGESIZE;
+	DEFINE_CACHELINE;
+
+	assert((ptr = libsimple_valloczn(1, 3 * pagesize, 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 6 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == 6 * pagesize);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert((ptr = libsimple_valloczn(0, 4 * pagesize, 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 8 * pagesize);
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)info->alignment));
+	}
+	free(ptr);
+	ptr = NULL;
+
+	assert(!libsimple_valloczn(0, 0) && errno == EINVAL);
+	errno = 0;
+	assert(!libsimple_valloczn(1, 0) && errno == EINVAL);
+	errno = 0;
+
+	assert(!libsimple_valloczn(0, SIZE_MAX, 2, 0) && errno == ENOMEM);
+	errno = 0;
+	assert(!libsimple_valloczn(1, SIZE_MAX, 2, 0) && errno == ENOMEM);
+	errno = 0;
+
+	assert((ptr = libsimple_valloczn(0, 9, 9, pagesize - 1, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 81 * (pagesize - 1));
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(!info->zeroed);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	assert((ptr = libsimple_valloczn(1, 9, 8, pagesize - 2, 0)));
+	if (have_custom_malloc()) {
+		assert((info = get_allocinfo(ptr)));
+		assert(info->size == 72 * (pagesize - 2));
+		ASSERT_ALIGNMENT(info, pagesize);
+		assert(info->zeroed == info->size);
+		assert(!((uintptr_t)ptr % (uintptr_t)(info->alignment)));
+	}
+	free(ptr);
+
+	return 0;
+}
+
+#endif
diff --git a/venprintf.c b/venprintf.c
new file mode 100644
index 0000000..1657954
--- /dev/null
+++ b/venprintf.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_venprintf(int, const char *, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_enprintf */
+}
+
+#endif
diff --git a/veprintf.c b/veprintf.c
new file mode 100644
index 0000000..36d6f14
--- /dev/null
+++ b/veprintf.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_veprintf(const char *, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_eprintf */
+}
+
+#endif
diff --git a/vmemalloc.c b/vmemalloc.c
index 8d92035..cbaecea 100644
--- a/vmemalloc.c
+++ b/vmemalloc.c
@@ -76,7 +76,7 @@ vmemalloc_parse_args(struct memalloc_state *state, size_t n, va_list ap)
 		case LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT:
 			if (state->zero_init >= 0)
 				goto inval;
-			state->zero_init = va_arg(ap, int);
+			state->zero_init = (char)va_arg(ap, int);
 			state->zero_init = !!state->zero_init;
 			break;
 
@@ -158,7 +158,6 @@ vmemalloc_parse_args(struct memalloc_state *state, size_t n, va_list ap)
 		}
 	}
 
-	return 0;
 inval:
 	errno = EINVAL;
 	return -1;
@@ -170,11 +169,23 @@ gcd(size_t u, size_t v)
 	size_t t;
 	int shift = 0;
 	/* Not needed because u>0, v>0: if (!(u | v)) return u + v; */
-	while (!((u | v) & 1)) u >>= 1, v >>= 1, shift++;
-	while (!(u & 1))       u >>= 1;
+	while (!((u | v) & 1)) {
+		u >>= 1;
+		v >>= 1;
+		shift++;
+	}
+	while (!(u & 1)) {
+		u >>= 1;
+	}
 	do {
-		while (!(v & 1)) v >>= 1;
-		if (u > v)       t = u, u = v, v = t;
+		while (!(v & 1)) {
+			v >>= 1;
+		}
+		if (u > v) {
+			t = u;
+			u = v;
+			v = t;
+		}
 	} while (v -= u);
 	return u << shift;
 }
diff --git a/vposix_memalignn.c b/vposix_memalignn.c
new file mode 100644
index 0000000..6001cdc
--- /dev/null
+++ b/vposix_memalignn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline int libsimple_vposix_memalignn(void **, size_t, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_posix_memalignn */
+}
+
+#endif
diff --git a/vpvallocn.c b/vpvallocn.c
new file mode 100644
index 0000000..2a17882
--- /dev/null
+++ b/vpvallocn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_vpvallocn(size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_pvallocn */
+}
+
+#endif
diff --git a/vpvalloczn.c b/vpvalloczn.c
new file mode 100644
index 0000000..0aad778
--- /dev/null
+++ b/vpvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_vpvalloczn(int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_pvalloczn */
+}
+
+#endif
diff --git a/vreallocfn.c b/vreallocfn.c
new file mode 100644
index 0000000..fcd9c84
--- /dev/null
+++ b/vreallocfn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_vreallocfn(void *, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_reallocfn */
+}
+
+#endif
diff --git a/vvalloczn.c b/vvalloczn.c
new file mode 100644
index 0000000..c387583
--- /dev/null
+++ b/vvalloczn.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void *libsimple_vvalloczn(int, size_t, va_list);
+
+
+#else
+#include "test.h"
+
+int
+main(void)
+{
+	return 0; /* Tested via libsimple_valloczn */
+}
+
+#endif
diff --git a/vweprintf.c b/vweprintf.c
index 9263d52..9c93037 100644
--- a/vweprintf.c
+++ b/vweprintf.c
@@ -69,111 +69,10 @@ libsimple_vweprintf(const char *fmt, va_list ap)
 #else
 #include "test.h"
 
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic ignored "-Wformat-zero-length"
-#endif
-
-static void
-preprint(void)
-{
-	test_fprintf(stderr, "pre\n");
-}
-
-static void
-postprint(void)
-{
-	test_fprintf(stderr, "post\n");
-}
-
 int
 main(void)
 {
-	char prefix[100];
-	int i, j;
-
-#define T(...)\
-	do {\
-		stderr_n = 0;\
-		if (j == 0) {\
-			libsimple_weprintf(__VA_ARGS__);\
-		} else if (j == 1) {\
-			assert_exit(libsimple_enprintf(107, __VA_ARGS__));\
-			assert(exit_status == 107);\
-		} else {\
-			libsimple_default_failure_exit = 108;\
-			assert_exit(libsimple_eprintf(__VA_ARGS__));\
-			assert(exit_status == 108);\
-		}\
-	} while (0)
-
-	sprintf(prefix, "%s: ", argv0);
-	stderr_ok = 1;
-
-	for (i = 0; i < 2; i++, argv0 = NULL, *prefix = '\0') {
-		for (j = 0; j < 3; j++) {
-			T("%s%s%s\n", "abc", "123", "xyz");
-			assert_stderr("%s%s\n", prefix, "abc123xyz");
-			libsimple_eprintf_preprint = preprint;
-			T("%s%s%s\n", "abc", "123", "\n");
-			assert_stderr("pre\n%s%s\n", prefix, "abc123\n");
-			libsimple_eprintf_preprint = NULL;
-			libsimple_eprintf_postprint = postprint;
-			T("%s%s%s", "abc", "123", "xyz");
-			assert_stderr("%s%s\npost\n", prefix, "abc123xyz");
-			libsimple_eprintf_postprint = NULL;
-			T("%s%s%s", "abc", "123", "\n");
-			assert_stderr("%s%s\n", prefix, "abc123\n");
-			errno = EDOM;
-			libsimple_eprintf_preprint = preprint;
-			libsimple_eprintf_postprint = postprint;
-			T("%s%s%s:", "abc", "123", "\n");
-			assert_stderr("pre\n%s%s: %s\npost\n", prefix, "abc123\n", strerror(EDOM));
-			libsimple_eprintf_preprint = NULL;
-			libsimple_eprintf_postprint = NULL;
-			errno = ERANGE;
-			T("%s%s%s:", "abc", "123", "\n");
-			assert_stderr("%s%s: %s\n", prefix, "abc123\n", strerror(ERANGE));
-			errno = EOVERFLOW;
-			T("");
-			assert_stderr("%s%s\n", prefix, strerror(EOVERFLOW));
-
-			T("%s%s%s\n", "usage: ", "123", "xyz");
-			assert_stderr("%s%s\n", prefix, "usage: 123xyz");
-			T("%s%s%s\n", "usage: ", "123", "\n");
-			assert_stderr("%s%s\n", prefix, "usage: 123\n");
-			T("%s%s%s", "usage: ", "123", "xyz");
-			assert_stderr("%s%s\n", prefix, "usage: 123xyz");
-			T("%s%s%s", "usage: ", "123", "\n");
-			assert_stderr("%s%s\n", prefix, "usage: 123\n");
-			errno = EDOM;
-			T("%s%s%s:", "usage: ", "123", "\n");
-			assert_stderr("%s%s: %s\n", prefix, "usage: 123\n", strerror(EDOM));
-			errno = ERANGE;
-			T("%s%s%s:", "usage: ", "123", "\n");
-			assert_stderr("%s%s: %s\n", prefix, "usage: 123\n", strerror(ERANGE));
-
-			T("usage: %s%s%s\n", "abc", "123", "xyz");
-			assert_stderr("%s: %s\n", "usage", "abc123xyz");
-			T("usage: %s%s%s\n", "abc", "123", "\n");
-			assert_stderr("%s: %s\n", "usage", "abc123\n");
-			T("usage: %s%s%s", "abc", "123", "xyz");
-			assert_stderr("%s: %s\n", "usage", "abc123xyz");
-			T("usage: %s%s%s", "abc", "123", "\n");
-			assert_stderr("%s: %s\n", "usage", "abc123\n");
-			errno = EDOM;
-			T("usage: %s%s%s:", "abc", "123", "\n");
-			assert_stderr("%s: %s: %s\n", "usage", "abc123\n", strerror(EDOM));
-			errno = ERANGE;
-			T("usage: %s%s%s:", "abc", "123", "\n");
-			assert_stderr("%s: %s: %s\n", "usage", "abc123\n", strerror(ERANGE));
-			T("usage: ");
-			assert_stderr("%s", "usage: \n");
-		}
-	}
-
-#undef T
-
-	return 0;
+	return 0; /* Tested via libsimple_weprintf */
 }
 
 #endif
diff --git a/weprintf.c b/weprintf.c
new file mode 100644
index 0000000..14984c6
--- /dev/null
+++ b/weprintf.c
@@ -0,0 +1,119 @@
+/* See LICENSE file for copyright and license details. */
+#include "libsimple.h"
+#ifndef TEST
+
+
+extern inline void libsimple_weprintf(const char *, ...);
+
+
+#else
+#include "test.h"
+
+#if defined(__GNUC__) && !defined(__clang__)
+# pragma GCC diagnostic ignored "-Wformat-zero-length"
+#endif
+
+static void
+preprint(void)
+{
+	test_fprintf(stderr, "pre\n");
+}
+
+static void
+postprint(void)
+{
+	test_fprintf(stderr, "post\n");
+}
+
+int
+main(void)
+{
+	char prefix[100];
+	int i, j;
+
+#define T(...)\
+	do {\
+		stderr_n = 0;\
+		if (j == 0) {\
+			libsimple_weprintf(__VA_ARGS__);\
+		} else if (j == 1) {\
+			assert_exit(libsimple_enprintf(107, __VA_ARGS__));\
+			assert(exit_status == 107);\
+		} else {\
+			libsimple_default_failure_exit = 108;\
+			assert_exit(libsimple_eprintf(__VA_ARGS__));\
+			assert(exit_status == 108);\
+		}\
+	} while (0)
+
+	sprintf(prefix, "%s: ", argv0);
+	stderr_ok = 1;
+
+	for (i = 0; i < 2; i++, argv0 = NULL, *prefix = '\0') {
+		for (j = 0; j < 3; j++) {
+			T("%s%s%s\n", "abc", "123", "xyz");
+			assert_stderr("%s%s\n", prefix, "abc123xyz");
+			libsimple_eprintf_preprint = preprint;
+			T("%s%s%s\n", "abc", "123", "\n");
+			assert_stderr("pre\n%s%s\n", prefix, "abc123\n");
+			libsimple_eprintf_preprint = NULL;
+			libsimple_eprintf_postprint = postprint;
+			T("%s%s%s", "abc", "123", "xyz");
+			assert_stderr("%s%s\npost\n", prefix, "abc123xyz");
+			libsimple_eprintf_postprint = NULL;
+			T("%s%s%s", "abc", "123", "\n");
+			assert_stderr("%s%s\n", prefix, "abc123\n");
+			errno = EDOM;
+			libsimple_eprintf_preprint = preprint;
+			libsimple_eprintf_postprint = postprint;
+			T("%s%s%s:", "abc", "123", "\n");
+			assert_stderr("pre\n%s%s: %s\npost\n", prefix, "abc123\n", strerror(EDOM));
+			libsimple_eprintf_preprint = NULL;
+			libsimple_eprintf_postprint = NULL;
+			errno = ERANGE;
+			T("%s%s%s:", "abc", "123", "\n");
+			assert_stderr("%s%s: %s\n", prefix, "abc123\n", strerror(ERANGE));
+			errno = EOVERFLOW;
+			T("");
+			assert_stderr("%s%s\n", prefix, strerror(EOVERFLOW));
+
+			T("%s%s%s\n", "usage: ", "123", "xyz");
+			assert_stderr("%s%s\n", prefix, "usage: 123xyz");
+			T("%s%s%s\n", "usage: ", "123", "\n");
+			assert_stderr("%s%s\n", prefix, "usage: 123\n");
+			T("%s%s%s", "usage: ", "123", "xyz");
+			assert_stderr("%s%s\n", prefix, "usage: 123xyz");
+			T("%s%s%s", "usage: ", "123", "\n");
+			assert_stderr("%s%s\n", prefix, "usage: 123\n");
+			errno = EDOM;
+			T("%s%s%s:", "usage: ", "123", "\n");
+			assert_stderr("%s%s: %s\n", prefix, "usage: 123\n", strerror(EDOM));
+			errno = ERANGE;
+			T("%s%s%s:", "usage: ", "123", "\n");
+			assert_stderr("%s%s: %s\n", prefix, "usage: 123\n", strerror(ERANGE));
+
+			T("usage: %s%s%s\n", "abc", "123", "xyz");
+			assert_stderr("%s: %s\n", "usage", "abc123xyz");
+			T("usage: %s%s%s\n", "abc", "123", "\n");
+			assert_stderr("%s: %s\n", "usage", "abc123\n");
+			T("usage: %s%s%s", "abc", "123", "xyz");
+			assert_stderr("%s: %s\n", "usage", "abc123xyz");
+			T("usage: %s%s%s", "abc", "123", "\n");
+			assert_stderr("%s: %s\n", "usage", "abc123\n");
+			errno = EDOM;
+			T("usage: %s%s%s:", "abc", "123", "\n");
+			assert_stderr("%s: %s: %s\n", "usage", "abc123\n", strerror(EDOM));
+			errno = ERANGE;
+			T("usage: %s%s%s:", "abc", "123", "\n");
+			assert_stderr("%s: %s: %s\n", "usage", "abc123\n", strerror(ERANGE));
+			T("usage: ");
+			assert_stderr("%s", "usage: \n");
+		}
+	}
+
+#undef T
+
+	return 0;
+}
+
+#endif