From 3ab93b732dfe58e12d453f38cf4f424478c4d4bf Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 27 Jan 2024 18:12:58 +0100 Subject: Fix man pages MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- man3/MAX.3libsimple | 6 +----- man3/MAX3.3libsimple | 6 +----- man3/MIN.3libsimple | 6 +----- man3/MIN3.3libsimple | 6 +----- 4 files changed, 4 insertions(+), 20 deletions(-) diff --git a/man3/MAX.3libsimple b/man3/MAX.3libsimple index ac374d0..a8ff50e 100644 --- a/man3/MAX.3libsimple +++ b/man3/MAX.3libsimple @@ -39,11 +39,7 @@ The macro returns to the greater value. .SH ERRORS -The -.BR libsimple_close () -function fail for the reasons specified for the -.BR close (3) -function. +None. .SH EXAMPLES None. diff --git a/man3/MAX3.3libsimple b/man3/MAX3.3libsimple index d0171f8..a578033 100644 --- a/man3/MAX3.3libsimple +++ b/man3/MAX3.3libsimple @@ -42,11 +42,7 @@ The macro returns to the greatest of value. .SH ERRORS -The -.BR libsimple_close () -function fail for the reasons specified for the -.BR close (3) -function. +None. .SH EXAMPLES None. diff --git a/man3/MIN.3libsimple b/man3/MIN.3libsimple index 552b334..e54a867 100644 --- a/man3/MIN.3libsimple +++ b/man3/MIN.3libsimple @@ -39,11 +39,7 @@ The macro returns to the lesser value. .SH ERRORS -The -.BR libsimple_close () -function fail for the reasons specified for the -.BR close (3) -function. +None. .SH EXAMPLES None. diff --git a/man3/MIN3.3libsimple b/man3/MIN3.3libsimple index 19eeae9..0c257c5 100644 --- a/man3/MIN3.3libsimple +++ b/man3/MIN3.3libsimple @@ -42,11 +42,7 @@ The macro returns to the smallest of value. .SH ERRORS -The -.BR libsimple_close () -function fail for the reasons specified for the -.BR close (3) -function. +None. .SH EXAMPLES None. -- cgit v1.2.3-70-g09d2 From d055dfe7bbdbcbc7fbd521168b4dc728e004dcd1 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 27 Jan 2024 19:05:28 +0100 Subject: Add libsimple_close_range MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 1 + close_range.c | 142 +++++++++++++++++++++++++++++++++++++++++++ libsimple.h | 14 +++++ man0/libsimple.h.0 | 3 + man3/libsimple_close.3 | 3 +- man3/libsimple_close_range.3 | 74 ++++++++++++++++++++++ 6 files changed, 236 insertions(+), 1 deletion(-) create mode 100644 close_range.c create mode 100644 man3/libsimple_close_range.3 diff --git a/Makefile b/Makefile index 63843ae..4783e37 100644 --- a/Makefile +++ b/Makefile @@ -85,6 +85,7 @@ OBJ =\ bindex_r.o\ callocn.o\ close.o\ + close_range.o\ cmptimespec.o\ cmptimeval.o\ difftimespec.o\ diff --git a/close_range.c b/close_range.c new file mode 100644 index 0000000..540eba0 --- /dev/null +++ b/close_range.c @@ -0,0 +1,142 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + +#ifdef __linux__ +# include +#endif + + +static int +uintpcmp(const void *av, const void *bv) +{ + const unsigned int *ap = av; + const unsigned int *bp = bv; + const unsigned int a = *ap; + const unsigned int b = *bp; + return a < b ? -1 : a > b; +} + +static unsigned int * +list_fds(unsigned int min, unsigned int max, size_t *count) +{ + DIR *dir; + int ignore_fd; + unsigned int *ret = NULL, *new; + size_t size = 0; + struct dirent *f; + unsigned long int fd; + char *end; + + *count = 0; + + dir = opendir("/dev/fd"); + if (!dir) + return NULL; + ignore_fd = dirfd(dir); + + errno = 0; + while ((f = readdir(dir))) { + if (!isdigit(f->d_name[0])) + continue; + fd = strtoul(f->d_name, &end, 10); + if ((int)fd == ignore_fd || (unsigned int)fd < min || (unsigned int)fd > max) + continue; + if (*end || fd > INT_MAX || (!fd && errno)) + continue; + if (*count == size) { + size += 16; + new = realloc(ret, size * sizeof(*ret)); + if (!new) + goto fail; + ret = new; + } + ret[(*count)++] = (unsigned int)fd; + } + + if (errno) { + fail: + closedir(dir); + fail_closed: + free(ret); + return NULL; + } + + if (closedir(dir)) + goto fail_closed; + + return ret; +} + +int +libsimple_close_range(unsigned int first, unsigned int last, unsigned int *next) /* TODO test */ +{ + int saved_errno; + + *next = first; + + if (first > last) { + errno = EINVAL; + return -1; + } + + if (first > INT_MAX) + return 0; + if (last > INT_MAX) + last = INT_MAX; + + saved_errno = errno; + +#if defined(__linux__) && defined(__NR_close_range) + if (!syscall(__NR_close_range, first, last, 0)) + return 0; + else if (errno != ENOSYS) + return -1; +#endif + + if (last - first > 100) { /* TODO best limit should be researched */ + unsigned int *fds; + size_t n, i; + fds = list_fds(first, last, &n); + if (!fds) + goto fallback; + qsort(fds, n, sizeof(*fds), uintpcmp); + for (i = 0; i < n; i++) { + if (close((int)fds[i]) && errno != EBADF) { + if (i + 1 < n) + *next = fds[i + 1]; + else + *next = fds[i] + (fds[i] < LIBSIMPLE_CLOSE_RANGE_MAX); + free(fds); + return -1; + } + } + free(fds); + goto out; + } + +fallback: + do { + if (close((int)first) && errno != EBADF) { + *next = first + (first < LIBSIMPLE_CLOSE_RANGE_MAX); + return -1; + } + } while (first++ < last); + +out: + *next = last + (last < LIBSIMPLE_CLOSE_RANGE_MAX); + errno = saved_errno; + return 0; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/libsimple.h b/libsimple.h index f4238cb..9cc0f8f 100644 --- a/libsimple.h +++ b/libsimple.h @@ -190,6 +190,20 @@ libsimple_close(int *fdp__) } +/** + * Close a range of file descriptors + * + * @param first The lowest file descriptor to close + * @param last The highest file descriptor to close + * @param next Output parameter for the potentially first unclosed file descriptor; may be `NULL` + * @return 0 on successful completion, -1 on failure + * @throws EINVAL If `first > last` + * @throws Any error for close(3) except EBADF + */ +int libsimple_close_range(unsigned int first, unsigned int last, unsigned int *next); +#define LIBSIMPLE_CLOSE_RANGE_MAX (~0U) + + /** * Remove an item from a list, keeping the list ordered * diff --git a/man0/libsimple.h.0 b/man0/libsimple.h.0 index 36e4f71..1f92855 100644 --- a/man0/libsimple.h.0 +++ b/man0/libsimple.h.0 @@ -159,6 +159,9 @@ Flexible allocation of memory suitable for allocating arrays. .BR libsimple_close (3) Close a file and set to stored file descriptor number to mark it file as closed. .TP +.BR libsimple_close_range (3) +Close a range of file descriptors. +.TP .BR libsimple_default_failure_exit (3) Default exit value on failure. .TP diff --git a/man3/libsimple_close.3 b/man3/libsimple_close.3 index 7050899..017318c 100644 --- a/man3/libsimple_close.3 +++ b/man3/libsimple_close.3 @@ -57,4 +57,5 @@ None. None. .SH SEE ALSO -.BR close (3) +.BR close (3), +.BR libsimple_close_range (3) diff --git a/man3/libsimple_close_range.3 b/man3/libsimple_close_range.3 new file mode 100644 index 0000000..891ac3f --- /dev/null +++ b/man3/libsimple_close_range.3 @@ -0,0 +1,74 @@ +.TH LIBSIMPLE_CLOSE 3 libsimple +.SH NAME +libsimple_close_range \- close a range of file descriptors + +.SH SYNOPSIS +.nf +#include + +#define LIBSIMPLE_CLOSE_RANGE_MAX (~0U) + +int libsimple_close_range(unsigned int first, unsigned int last, unsigned int *next); +.fi +.PP +Link with +.IR \-lsimple . + +.SH DESCRIPTION +The +.BR libsimple_close_range () +function closes all file descriptors in the +range inclusive range +.RI [ *first ", " last ]. +.PP +Unless +.I next +is, +.IR NULL , +the first potentially unclosed file descriptor +will be written to +.I *next . + +.SH RETURN VALUE +The +.BR libsimple_close_range () +function returns 0 upon successful completion; +otherwise \-1 is returned (potentially partially +successful). + +.SH ERRORS +The +.BR libsimple_close_range () +function fail for the reasons specified for the +.BR close (3) +function except +.BR EBADF , +or if +.TP +.B EINVAL +.I first +is greater than +.IR last . + +.SH EXAMPLES +None. + +.SH APPLICATION USAGE +None. + +.SH RATIONALE +None. + +.SH FUTURE DIRECTIONS +None. + +.SH NOTES +None. + +.SH BUGS +None. + +.SH SEE ALSO +.BR close_range (2), +.BR close (3), +.BR libsimple_close (3) -- cgit v1.2.3-70-g09d2 From 310928bf5eb7cec8f43b105c1957584415f7b254 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 27 Jan 2024 19:08:59 +0100 Subject: Update library version number MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 4783e37..cc99bc0 100644 --- a/Makefile +++ b/Makefile @@ -11,7 +11,7 @@ include mk/$(OS).mk LIB_MAJOR = 1 -LIB_MINOR = 5 +LIB_MINOR = 6 LIB_VERSION = $(LIB_MAJOR).$(LIB_MINOR) LIB_NAME = simple -- cgit v1.2.3-70-g09d2 From 6153c38a1104b5e3c44f3c516456a35834e5ac0d Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sun, 28 Jan 2024 07:45:19 +0100 Subject: Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- man3/libsimple_aligned_realloc.3 | 2 +- man3/libsimple_aligned_reallocarray.3 | 2 +- man3/libsimple_aligned_reallocarrayf.3 | 2 +- man3/libsimple_aligned_reallocf.3 | 2 +- man3/libsimple_reallocarray.3 | 2 +- man3/libsimple_reallocarrayf.3 | 2 +- man3/libsimple_reallocf.3 | 2 +- man3/libsimple_valigned_reallocfn.3 | 2 +- man3/libsimple_valigned_reallocn.3 | 2 +- man3/libsimple_vreallocfn.3 | 2 +- man3/libsimple_vreallocn.3 | 2 +- 11 files changed, 11 insertions(+), 11 deletions(-) diff --git a/man3/libsimple_aligned_realloc.3 b/man3/libsimple_aligned_realloc.3 index 0e176b9..244ad8f 100644 --- a/man3/libsimple_aligned_realloc.3 +++ b/man3/libsimple_aligned_realloc.3 @@ -44,7 +44,7 @@ same content as but truncated to .I n bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_aligned_reallocarray.3 b/man3/libsimple_aligned_reallocarray.3 index c4cc765..b2f1361 100644 --- a/man3/libsimple_aligned_reallocarray.3 +++ b/man3/libsimple_aligned_reallocarray.3 @@ -46,7 +46,7 @@ same content as but truncated to .I n*m bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_aligned_reallocarrayf.3 b/man3/libsimple_aligned_reallocarrayf.3 index 46a4057..22a08a3 100644 --- a/man3/libsimple_aligned_reallocarrayf.3 +++ b/man3/libsimple_aligned_reallocarrayf.3 @@ -31,7 +31,7 @@ same content as but truncated to .I n*m bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_aligned_reallocf.3 b/man3/libsimple_aligned_reallocf.3 index 4ad9fcc..edd52c8 100644 --- a/man3/libsimple_aligned_reallocf.3 +++ b/man3/libsimple_aligned_reallocf.3 @@ -31,7 +31,7 @@ same content as but truncated to .I n bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_reallocarray.3 b/man3/libsimple_reallocarray.3 index 5626e63..44d1dfa 100644 --- a/man3/libsimple_reallocarray.3 +++ b/man3/libsimple_reallocarray.3 @@ -48,7 +48,7 @@ same content as but truncated to .I n*m bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_reallocarrayf.3 b/man3/libsimple_reallocarrayf.3 index f0d3104..e10793b 100644 --- a/man3/libsimple_reallocarrayf.3 +++ b/man3/libsimple_reallocarrayf.3 @@ -33,7 +33,7 @@ same content as but truncated to .I n*m bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_reallocf.3 b/man3/libsimple_reallocf.3 index d3b7523..55e6aad 100644 --- a/man3/libsimple_reallocf.3 +++ b/man3/libsimple_reallocf.3 @@ -33,7 +33,7 @@ same content as but truncated to .I n bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_valigned_reallocfn.3 b/man3/libsimple_valigned_reallocfn.3 index 2afa6c2..b9ac02c 100644 --- a/man3/libsimple_valigned_reallocfn.3 +++ b/man3/libsimple_valigned_reallocfn.3 @@ -43,7 +43,7 @@ same content as but truncated to .I N bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_valigned_reallocn.3 b/man3/libsimple_valigned_reallocn.3 index 607684b..847af93 100644 --- a/man3/libsimple_valigned_reallocn.3 +++ b/man3/libsimple_valigned_reallocn.3 @@ -64,7 +64,7 @@ same content as but truncated to .I N bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_vreallocfn.3 b/man3/libsimple_vreallocfn.3 index e0e75e0..ad588c2 100644 --- a/man3/libsimple_vreallocfn.3 +++ b/man3/libsimple_vreallocfn.3 @@ -45,7 +45,7 @@ same content as but truncated to .I N bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr diff --git a/man3/libsimple_vreallocn.3 b/man3/libsimple_vreallocn.3 index f1a8fad..cedcef9 100644 --- a/man3/libsimple_vreallocn.3 +++ b/man3/libsimple_vreallocn.3 @@ -64,7 +64,7 @@ same content as but truncated to .I N bytes if it is smaller or with the new bytes -unitialised if it is larger. If a new pointer +uninitialised if it is larger. If a new pointer is returned, rather than .IR ptr , .I ptr -- cgit v1.2.3-70-g09d2 From 71811470be4f182b623510cf92ea5cfff16df172 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sun, 28 Jan 2024 16:34:27 +0100 Subject: Add libsimple_generate_seed and libsimple_srand MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 3 +++ generate_seed.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ libsimple.h | 1 + libsimple/random.h | 22 ++++++++++++++++++++ srand.c | 18 +++++++++++++++++ 5 files changed, 103 insertions(+) create mode 100644 generate_seed.c create mode 100644 libsimple/random.h create mode 100644 srand.c diff --git a/Makefile b/Makefile index cc99bc0..38f2537 100644 --- a/Makefile +++ b/Makefile @@ -44,6 +44,7 @@ SUBHDR =\ libsimple/printf.h\ libsimple/pvalloc.h\ libsimple/pvallocz.h\ + libsimple/random.h\ libsimple/realloc.h\ libsimple/search.h\ libsimple/str.h\ @@ -224,6 +225,7 @@ OBJ =\ ewcsdup.o\ ewcsndup.o\ ewmemdup.o\ + generate_seed.o\ getenv_e.o\ getenv_ne.o\ gmtime.o\ @@ -318,6 +320,7 @@ OBJ =\ reallocf.o\ reallocfn.o\ reallocn.o\ + srand.o\ stpmove.o\ stpnmove.o\ stpnset.o\ diff --git a/generate_seed.c b/generate_seed.c new file mode 100644 index 0000000..cce274f --- /dev/null +++ b/generate_seed.c @@ -0,0 +1,59 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + +#include + + +unsigned int +libsimple_generate_seed(void) /* TODO add test */ +{ + uintptr_t longseed = 1; + void *ptr; + uintptr_t ptri; + unsigned int seed; + struct timespec ts; + uint8_t (*at_random)[16]; + size_t i; + + if (!clock_gettime(CLOCK_REALTIME, &ts)) + longseed ^= (uintptr_t)ts.tv_sec * (uintptr_t)1000000000UL + (uintptr_t)ts.tv_nsec; + + ptr = malloc(1); + ptri = (uintptr_t)ptr; + free(ptr); + longseed ^= ptri; + longseed ^= (uintptr_t)&ptri; + longseed ^= (uintptr_t)clock(); + + if (!clock_gettime(CLOCK_MONOTONIC_RAW, &ts)) + longseed ^= (uintptr_t)ts.tv_sec * (uintptr_t)1000000000UL + (uintptr_t)ts.tv_nsec; + + ptri = (uintptr_t)getauxval(AT_RANDOM); + if (ptri) { + at_random = (void *)ptri; + for (i = 0; i < ELEMSOF(*at_random); i++) + longseed ^= (*at_random)[i] << (i % sizeof(longseed) * (size_t)CHAR_BIT); + } + + seed = 0; + while (longseed) { + seed ^= (unsigned int)longseed; + longseed >>= sizeof(unsigned int) * (CHAR_BIT - 1); + longseed >>= sizeof(unsigned int); + } + + return seed; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/libsimple.h b/libsimple.h index 9cc0f8f..1cd7806 100644 --- a/libsimple.h +++ b/libsimple.h @@ -165,6 +165,7 @@ #include "libsimple/strn.h" #include "libsimple/strtoint.h" #include "libsimple/search.h" +#include "libsimple/random.h" /** diff --git a/libsimple/random.h b/libsimple/random.h new file mode 100644 index 0000000..3c09d7a --- /dev/null +++ b/libsimple/random.h @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ + + +/** + * Creates a pseudo-random seed + * + * @return The pseudo-random seed + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__warn_unused_result__))) +unsigned int libsimple_generate_seed(void); /* TODO add man page */ + + +/** + * Wrapper for srand(3) that creates a pseudo-random + * seed with which it seeds the pseudo-random number + * generator + */ +inline void +libsimple_srand(void) /* TODO add man page */ +{ + srand(libsimple_generate_seed()); +} diff --git a/srand.c b/srand.c new file mode 100644 index 0000000..e1648cb --- /dev/null +++ b/srand.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_srand(void); /* TODO add test */ + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif -- cgit v1.2.3-70-g09d2 From cb4b8137902b7c89872f8face7b47704f932b807 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 29 Jan 2024 07:32:29 +0100 Subject: Add to*, *diff, *abs, *uabs, and random_{bits,float,signed,unsigned} MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 53 +++++++++++++++ abs.c | 18 +++++ diff.c | 18 +++++ habs.c | 18 +++++ hdiff.c | 18 +++++ hhabs.c | 18 +++++ hhdiff.c | 18 +++++ i16abs.c | 18 +++++ i16diff.c | 18 +++++ i32abs.c | 18 +++++ i32diff.c | 18 +++++ i64abs.c | 18 +++++ i64diff.c | 18 +++++ i8abs.c | 18 +++++ i8diff.c | 18 +++++ imaxabs.c | 18 +++++ imaxdiff.c | 18 +++++ iptrabs.c | 18 +++++ iptrdiff.c | 18 +++++ labs.c | 18 +++++ ldiff.c | 18 +++++ libsimple.h | 1 + libsimple/abs.h | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++++ libsimple/random.h | 7 ++ llabs.c | 18 +++++ lldiff.c | 18 +++++ random_bits.c | 34 ++++++++++ random_float.c | 58 ++++++++++++++++ random_signed.c | 35 ++++++++++ random_unsigned.c | 40 +++++++++++ toi.c | 18 +++++ toi16.c | 18 +++++ toi32.c | 18 +++++ toi64.c | 18 +++++ toi8.c | 18 +++++ toih.c | 18 +++++ toihh.c | 18 +++++ toil.c | 18 +++++ toill.c | 18 +++++ toimax.c | 18 +++++ toiptr.c | 18 +++++ toiz.c | 18 +++++ u16abs.c | 18 +++++ u32abs.c | 18 +++++ u64abs.c | 18 +++++ u8abs.c | 18 +++++ uabs.c | 18 +++++ uhabs.c | 18 +++++ uhhabs.c | 18 +++++ ulabs.c | 18 +++++ ullabs.c | 18 +++++ umaxabs.c | 18 +++++ uptrabs.c | 18 +++++ uzabs.c | 18 +++++ zabs.c | 18 +++++ zdiff.c | 18 +++++ 56 files changed, 1288 insertions(+) create mode 100644 abs.c create mode 100644 diff.c create mode 100644 habs.c create mode 100644 hdiff.c create mode 100644 hhabs.c create mode 100644 hhdiff.c create mode 100644 i16abs.c create mode 100644 i16diff.c create mode 100644 i32abs.c create mode 100644 i32diff.c create mode 100644 i64abs.c create mode 100644 i64diff.c create mode 100644 i8abs.c create mode 100644 i8diff.c create mode 100644 imaxabs.c create mode 100644 imaxdiff.c create mode 100644 iptrabs.c create mode 100644 iptrdiff.c create mode 100644 labs.c create mode 100644 ldiff.c create mode 100644 libsimple/abs.h create mode 100644 llabs.c create mode 100644 lldiff.c create mode 100644 random_bits.c create mode 100644 random_float.c create mode 100644 random_signed.c create mode 100644 random_unsigned.c create mode 100644 toi.c create mode 100644 toi16.c create mode 100644 toi32.c create mode 100644 toi64.c create mode 100644 toi8.c create mode 100644 toih.c create mode 100644 toihh.c create mode 100644 toil.c create mode 100644 toill.c create mode 100644 toimax.c create mode 100644 toiptr.c create mode 100644 toiz.c create mode 100644 u16abs.c create mode 100644 u32abs.c create mode 100644 u64abs.c create mode 100644 u8abs.c create mode 100644 uabs.c create mode 100644 uhabs.c create mode 100644 uhhabs.c create mode 100644 ulabs.c create mode 100644 ullabs.c create mode 100644 umaxabs.c create mode 100644 uptrabs.c create mode 100644 uzabs.c create mode 100644 zabs.c create mode 100644 zdiff.c diff --git a/Makefile b/Makefile index 38f2537..4a8a324 100644 --- a/Makefile +++ b/Makefile @@ -17,6 +17,7 @@ LIB_NAME = simple SUBHDR =\ + libsimple/abs.h\ libsimple/aligned_alloc.h\ libsimple/aligned_allocz.h\ libsimple/aligned_memdup.h\ @@ -65,6 +66,7 @@ HDR =\ common.h OBJ =\ + abs.o\ aligned_allocn.o\ aligned_allocz.o\ aligned_alloczn.o\ @@ -89,6 +91,7 @@ OBJ =\ close_range.o\ cmptimespec.o\ cmptimeval.o\ + diff.o\ difftimespec.o\ difftimeval.o\ doubletotimespec.o\ @@ -229,8 +232,28 @@ OBJ =\ getenv_e.o\ getenv_ne.o\ gmtime.o\ + habs.o\ + hdiff.o\ + hhabs.o\ + hhdiff.o\ + i16abs.o\ + i16diff.o\ + i32abs.o\ + i32diff.o\ + i64abs.o\ + i64diff.o\ + i8abs.o\ + i8diff.o\ + imaxabs.o\ + imaxdiff.o\ inchrcaseset.o\ inchrset.o\ + iptrabs.o\ + iptrdiff.o\ + labs.o\ + ldiff.o\ + llabs.o\ + lldiff.o\ localtime.o\ mallocn.o\ mallocz.o\ @@ -299,6 +322,10 @@ OBJ =\ pvallocn.o\ pvallocz.o\ pvalloczn.o\ + random_bits.o\ + random_float.o\ + random_signed.o\ + random_unsigned.o\ rawmemcasechr.o\ rawmemcasechr_inv.o\ rawmemccpy.o\ @@ -430,7 +457,31 @@ OBJ =\ timeval2timespec.o\ timevaltodouble.o\ timevaltostr.o\ + toi.o\ + toi16.o\ + toi32.o\ + toi64.o\ + toi8.o\ + toih.o\ + toihh.o\ + toil.o\ + toill.o\ + toimax.o\ + toiptr.o\ + toiz.o\ + u16abs.o\ + u32abs.o\ + u64abs.o\ + u8abs.o\ + uabs.o\ + uhabs.o\ + uhhabs.o\ + ulabs.o\ + ullabs.o\ + umaxabs.o\ unlist.o\ + uptrabs.o\ + uzabs.o\ valigned_allocn.o\ valigned_reallocfn.o\ valloc.o\ @@ -456,6 +507,8 @@ OBJ =\ wcsndup.o\ weprintf.o\ wmemdup.o\ + zabs.o\ + zdiff.o\ libsimple.o MAN0 =\ diff --git a/abs.c b/abs.c new file mode 100644 index 0000000..768a9f6 --- /dev/null +++ b/abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned int libsimple_abs(int, int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/diff.c b/diff.c new file mode 100644 index 0000000..ca556c5 --- /dev/null +++ b/diff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned int libsimple_diff(int, int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/habs.c b/habs.c new file mode 100644 index 0000000..cdfaf70 --- /dev/null +++ b/habs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned short int libsimple_habs(short int, short int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/hdiff.c b/hdiff.c new file mode 100644 index 0000000..89a865b --- /dev/null +++ b/hdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned short int libsimple_hdiff(short int, short int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/hhabs.c b/hhabs.c new file mode 100644 index 0000000..cc43287 --- /dev/null +++ b/hhabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned char libsimple_hhabs(signed char, signed char); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/hhdiff.c b/hhdiff.c new file mode 100644 index 0000000..bfebfd6 --- /dev/null +++ b/hhdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned char libsimple_hhdiff(signed char, signed char); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i16abs.c b/i16abs.c new file mode 100644 index 0000000..1d9e61f --- /dev/null +++ b/i16abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least16_t libsimple_i16abs(int_least16_t, int_least16_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i16diff.c b/i16diff.c new file mode 100644 index 0000000..f8ac7b1 --- /dev/null +++ b/i16diff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least16_t libsimple_i16diff(int_least16_t, int_least16_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i32abs.c b/i32abs.c new file mode 100644 index 0000000..9288e8b --- /dev/null +++ b/i32abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least32_t libsimple_i32abs(int_least32_t, int_least32_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i32diff.c b/i32diff.c new file mode 100644 index 0000000..32a545e --- /dev/null +++ b/i32diff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least32_t libsimple_i32diff(int_least32_t, int_least32_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i64abs.c b/i64abs.c new file mode 100644 index 0000000..72b770c --- /dev/null +++ b/i64abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least64_t libsimple_i64abs(int_least64_t, int_least64_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i64diff.c b/i64diff.c new file mode 100644 index 0000000..35a5e3c --- /dev/null +++ b/i64diff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least64_t libsimple_i64diff(int_least64_t, int_least64_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i8abs.c b/i8abs.c new file mode 100644 index 0000000..ea271a9 --- /dev/null +++ b/i8abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least8_t libsimple_i8abs(int_least8_t, int_least8_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/i8diff.c b/i8diff.c new file mode 100644 index 0000000..cb4086a --- /dev/null +++ b/i8diff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least8_t libsimple_i8diff(int_least8_t, int_least8_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/imaxabs.c b/imaxabs.c new file mode 100644 index 0000000..dd50b78 --- /dev/null +++ b/imaxabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uintmax_t libsimple_imaxabs(intmax_t, intmax_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/imaxdiff.c b/imaxdiff.c new file mode 100644 index 0000000..0555847 --- /dev/null +++ b/imaxdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uintmax_t libsimple_imaxdiff(intmax_t, intmax_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/iptrabs.c b/iptrabs.c new file mode 100644 index 0000000..cd7088f --- /dev/null +++ b/iptrabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uintptr_t libsimple_iptrabs(intptr_t, intptr_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/iptrdiff.c b/iptrdiff.c new file mode 100644 index 0000000..fc406ef --- /dev/null +++ b/iptrdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uintptr_t libsimple_iptrdiff(intptr_t, intptr_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/labs.c b/labs.c new file mode 100644 index 0000000..9825fd1 --- /dev/null +++ b/labs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned long int libsimple_labs(long int, long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/ldiff.c b/ldiff.c new file mode 100644 index 0000000..5a63843 --- /dev/null +++ b/ldiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned long int libsimple_ldiff(long int, long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/libsimple.h b/libsimple.h index 1cd7806..bdfc7c7 100644 --- a/libsimple.h +++ b/libsimple.h @@ -166,6 +166,7 @@ #include "libsimple/strtoint.h" #include "libsimple/search.h" #include "libsimple/random.h" +#include "libsimple/abs.h" /** diff --git a/libsimple/abs.h b/libsimple/abs.h new file mode 100644 index 0000000..c1a9123 --- /dev/null +++ b/libsimple/abs.h @@ -0,0 +1,196 @@ +/* See LICENSE file for copyright and license details. */ + +/* TODO man, doc, test */ + + +/* + * How to calculate the difference between two signed integers + * is not obvious, as the result must be unsigned to avoid + * overflow. The solution is to first covert the number to + * an unsigned type. Doing this ensure either that the value + * is unmodified or will be set the maximum value the unsigned + * type can store plus 1 plus the original negative value — + * it wraps around just just like if two's completement was + * used and the bits simply copied, regardless of how signed + * integers are actually stored. Now the subtraction will + * work adventurously without any overflow or the subtraction + * will overflow to the correct value. For example, say + * we are working with 8-bit integers, calculating (−1) − (−4) + * works out like so: + * (−1) − (−4) + * = (256 − 1) − (256 − 4) + * = 255 − 252 + * = 3 + * and calculating 5 − (−5) like so: + * 5 − (−5) + * ≡ 5 − (256 − 5) + * = 5 − 251 + * ≡ 256 + (5 − 251) + * = 256 + (−246) + * = 256 − 246 + * = 10 + * Importantly, doing the convertion to unsigned type after + * the subtraction result in unspecified behaviour as + * signed integer overflow is unspecified behaviour. + */ + + +#define LIBSIMPLE_DIFF_(UTYPE, MAX, MIN) (UTYPE)((UTYPE)(MAX) - (UTYPE)(MIN)) +#define LIBSIMPLE_IABS_(UTYPE, A, B) ((A) > (B) ? LIBSIMPLE_DIFF_(UTYPE, (A), (B)) : LIBSIMPLE_DIFF_(UTYPE, (B), (A))) +#define LIBSIMPLE_UABS_(UTYPE, A, B) ((UTYPE)((A) > (B) ? (A) - (B) : (B) - (A))) +#define LIBSIMPLE_SIGN_(UTYPE, STYPE, VALUE) ((VALUE) >> (sizeof(UTYPE) * CHAR_BIT - 1) ? (STYPE)(VALUE) : -(STYPE)-(VALUE)) + + +inline unsigned char libsimple_hhdiff(signed char max, signed char min) +{ return LIBSIMPLE_DIFF_(unsigned char, max, min); } + +inline unsigned short int libsimple_hdiff(short int max, short int min) +{ return LIBSIMPLE_DIFF_(unsigned short int, max, min); } + +inline unsigned int libsimple_diff(int max, int min) +{ return LIBSIMPLE_DIFF_(unsigned int, max, min); } + +inline unsigned long int libsimple_ldiff(long int max, long int min) +{ return LIBSIMPLE_DIFF_(unsigned long int, max, min); } + +inline unsigned long long int libsimple_lldiff(long long int max, long long int min) +{ return LIBSIMPLE_DIFF_(unsigned long long int, max, min); } + +inline size_t libsimple_zdiff(ssize_t max, ssize_t min) +{ return LIBSIMPLE_DIFF_(size_t, max, min); } + +inline uint_least8_t libsimple_i8diff(int_least8_t max, int_least8_t min) +{ return LIBSIMPLE_DIFF_(uint_least8_t, max, min); } + +inline uint_least16_t libsimple_i16diff(int_least16_t max, int_least16_t min) +{ return LIBSIMPLE_DIFF_(uint_least16_t, max, min); } + +inline uint_least32_t libsimple_i32diff(int_least32_t max, int_least32_t min) +{ return LIBSIMPLE_DIFF_(uint_least32_t, max, min); } + +inline uint_least64_t libsimple_i64diff(int_least64_t max, int_least64_t min) +{ return LIBSIMPLE_DIFF_(uint_least64_t, max, min); } + +inline uintmax_t libsimple_imaxdiff(intmax_t max, intmax_t min) +{ return LIBSIMPLE_DIFF_(uintmax_t, max, min); } + +inline uintptr_t libsimple_iptrdiff(intptr_t max, intptr_t min) +{ return LIBSIMPLE_DIFF_(uintptr_t, max, min); } + + +inline unsigned char libsimple_hhabs(signed char a, signed char b) +{ return LIBSIMPLE_IABS_(unsigned char, a, b); } + +inline unsigned short int libsimple_habs(short int a, short int b) +{ return LIBSIMPLE_IABS_(unsigned short int, a, b); } + +inline unsigned int libsimple_abs(int a, int b) +{ return LIBSIMPLE_IABS_(unsigned int, a, b); } + +inline unsigned long int libsimple_labs(long int a, long int b) +{ return LIBSIMPLE_IABS_(unsigned long int, a, b); } + +inline unsigned long long int libsimple_llabs(long long int a, long long int b) +{ return LIBSIMPLE_IABS_(unsigned long long int, a, b); } + +inline size_t libsimple_zabs(ssize_t a, ssize_t b) +{ return LIBSIMPLE_IABS_(size_t, a, b); } + +inline uint_least8_t libsimple_i8abs(int_least8_t a, int_least8_t b) +{ return LIBSIMPLE_IABS_(uint_least8_t, a, b); } + +inline uint_least16_t libsimple_i16abs(int_least16_t a, int_least16_t b) +{ return LIBSIMPLE_IABS_(uint_least16_t, a, b); } + +inline uint_least32_t libsimple_i32abs(int_least32_t a, int_least32_t b) +{ return LIBSIMPLE_IABS_(uint_least32_t, a, b); } + +inline uint_least64_t libsimple_i64abs(int_least64_t a, int_least64_t b) +{ return LIBSIMPLE_IABS_(uint_least64_t, a, b); } + +inline uintmax_t libsimple_imaxabs(intmax_t a, intmax_t b) +{ return LIBSIMPLE_IABS_(uintmax_t, a, b); } + +inline uintptr_t libsimple_iptrabs(intptr_t a, intptr_t b) +{ return LIBSIMPLE_IABS_(uintptr_t, a, b); } + + +inline unsigned char libsimple_uhhabs(unsigned char a, unsigned char b) +{ return LIBSIMPLE_UABS_(unsigned char, a, b); } + +inline unsigned short int libsimple_uhabs(unsigned short int a, unsigned short int b) +{ return LIBSIMPLE_UABS_(unsigned short int, a, b); } + +inline unsigned int libsimple_uabs(unsigned int a, unsigned int b) +{ return LIBSIMPLE_UABS_(unsigned int, a, b); } + +inline unsigned long int libsimple_ulabs(unsigned long int a, unsigned long int b) +{ return LIBSIMPLE_UABS_(unsigned long int, a, b); } + +inline unsigned long long int libsimple_ullabs(unsigned long long int a, unsigned long long int b) +{ return LIBSIMPLE_UABS_(unsigned long long int, a, b); } + +inline size_t libsimple_uzabs(size_t a, size_t b) +{ return LIBSIMPLE_UABS_(size_t, a, b); } + +inline uint_least8_t libsimple_u8abs(uint_least8_t a, uint_least8_t b) +{ return LIBSIMPLE_UABS_(uint_least8_t, a, b); } + +inline uint_least16_t libsimple_u16abs(uint_least16_t a, uint_least16_t b) +{ return LIBSIMPLE_UABS_(uint_least16_t, a, b); } + +inline uint_least32_t libsimple_u32abs(uint_least32_t a, uint_least32_t b) +{ return LIBSIMPLE_UABS_(uint_least32_t, a, b); } + +inline uint_least64_t libsimple_u64abs(uint_least64_t a, uint_least64_t b) +{ return LIBSIMPLE_UABS_(uint_least64_t, a, b); } + +inline uintmax_t libsimple_umaxabs(uintmax_t a, uintmax_t b) +{ return LIBSIMPLE_UABS_(uintmax_t, a, b); } + +inline uintptr_t libsimple_uptrabs(uintptr_t a, uintptr_t b) +{ return LIBSIMPLE_UABS_(uintptr_t, a, b); } + + +inline signed char libsimple_toihh(unsigned char value) +{ return LIBSIMPLE_SIGN_(unsigned char, signed char, value); } + +inline short int libsimple_toih(unsigned short int value) +{ return LIBSIMPLE_SIGN_(unsigned short int, short int, value); } + +inline int libsimple_toi(unsigned int value) +{ return LIBSIMPLE_SIGN_(unsigned int, int, value); } + +inline long int libsimple_toil(unsigned long int value) +{ return LIBSIMPLE_SIGN_(unsigned long int, long int, value); } + +inline long long int libsimple_toill(unsigned long long int value) +{ return LIBSIMPLE_SIGN_(unsigned long long int, long long int, value); } + +inline ssize_t libsimple_toiz(size_t value) +{ return LIBSIMPLE_SIGN_(size_t, ssize_t, value); } + +inline int_least8_t libsimple_toi8(uint_least8_t value) +{ return LIBSIMPLE_SIGN_(uint_least8_t, int_least8_t, value); } + +inline int_least16_t libsimple_toi16(uint_least16_t value) +{ return LIBSIMPLE_SIGN_(uint_least16_t, int_least16_t, value); } + +inline int_least32_t libsimple_toi32(uint_least32_t value) +{ return LIBSIMPLE_SIGN_(uint_least32_t, int_least32_t, value); } + +inline int_least64_t libsimple_toi64(uint_least64_t value) +{ return LIBSIMPLE_SIGN_(uint_least32_t, int_least32_t, value); } + +inline intmax_t libsimple_toimax(uintmax_t value) +{ return LIBSIMPLE_SIGN_(uintmax_t, intmax_t, value); } + +inline intptr_t libsimple_toiptr(uintptr_t value) +{ return LIBSIMPLE_SIGN_(uintptr_t, intptr_t, value); } + + + +#undef LIBSIMPLE_DIFF_ +#undef LIBSIMPLE_IABS_ +#undef LIBSIMPLE_UABS_ +#undef LIBSIMPLE_SIGN_ diff --git a/libsimple/random.h b/libsimple/random.h index 3c09d7a..a786661 100644 --- a/libsimple/random.h +++ b/libsimple/random.h @@ -20,3 +20,10 @@ libsimple_srand(void) /* TODO add man page */ { srand(libsimple_generate_seed()); } + + +/* TODO doc, man */ +uintmax_t libsimple_random_bits(size_t bits, void *unused); +uintmax_t libsimple_random_unsigned(uintmax_t (*rng)(size_t bits, void *user), void *user, uintmax_t min, uintmax_t max); +intmax_t libsimple_random_signed(uintmax_t (*rng)(size_t bits, void *user), void *user, intmax_t min, intmax_t max); +long double libsimple_random_float(uintmax_t (*rng)(size_t bits, void *user), void *user, long double min, long double postmax); diff --git a/llabs.c b/llabs.c new file mode 100644 index 0000000..9a8a3dc --- /dev/null +++ b/llabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned long long int libsimple_llabs(long long int, long long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/lldiff.c b/lldiff.c new file mode 100644 index 0000000..d8d1864 --- /dev/null +++ b/lldiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned long long int libsimple_lldiff(long long int, long long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/random_bits.c b/random_bits.c new file mode 100644 index 0000000..528b09e --- /dev/null +++ b/random_bits.c @@ -0,0 +1,34 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +uintmax_t +libsimple_random_bits(size_t bits, void *unused) +{ + uintmax_t ret = 0; + + while (bits >= 8) { + ret <<= 8; + ret |= (uintmax_t)(rand() & 0xFF); + bits -= 8; + } + + ret <<= bits; + ret |= (uintmax_t)(rand() & ((1 << bits) - 1)); + + (void) unused; + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/random_float.c b/random_float.c new file mode 100644 index 0000000..b4b6557 --- /dev/null +++ b/random_float.c @@ -0,0 +1,58 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + +#include + + +long double +libsimple_random_float(uintmax_t (*rng)(size_t bits, void *user), void *user, long double min, long double postmax) /* TODO add test */ +{ + long double range, offset, mantissa, value; + uintmax_t r; + int exp; + size_t bits; + + if (min < postmax) { + range = postmax - min; + offset = min; + } else if (min > postmax) { + range = min - postmax; + offset = postmax; + } else { + return min; + } + + mantissa = frexpl(range, &exp); + do { + bits = sizeof(uintmax_t) * CHAR_BIT; + r = (*rng)(bits, user); + while (bits && (r & 1)) { + exp -= 1; + bits -= 1; + r >>= 1; + } + } while (!bits); + + bits = sizeof(uintmax_t) * CHAR_BIT; + r = (*rng)(bits, user); + value = (long double)r; + value = fmal(value, 0.5, 0.5); + value = ldexpl(value, -(int)bits); + + value = ldexpl(value, exp); + value *= mantissa; + return value + offset; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/random_signed.c b/random_signed.c new file mode 100644 index 0000000..13d5f3b --- /dev/null +++ b/random_signed.c @@ -0,0 +1,35 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +intmax_t +libsimple_random_signed(uintmax_t (*rng)(size_t bits, void *user), void *user, intmax_t min, intmax_t max) /* TODO add test */ +{ + uintmax_t range, offset, t, r; + size_t bits = 0; + + range = libsimple_imaxabs(max, min); + offset = (uintmax_t)MIN(min, max); + + for (t = range; t; t >>= 1) + bits += 1; + + do { + r = (*rng)(bits, user); + } while (r > range); + + return libsimple_toimax(r + offset); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/random_unsigned.c b/random_unsigned.c new file mode 100644 index 0000000..f39392d --- /dev/null +++ b/random_unsigned.c @@ -0,0 +1,40 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +uintmax_t +libsimple_random_unsigned(uintmax_t (*rng)(size_t bits, void *user), void *user, uintmax_t min, uintmax_t max) /* TODO add test */ +{ + uintmax_t range, offset, t, r; + size_t bits = 0; + + if (min < max) { + range = max - min; + offset = min; + } else { + range = min - max; + offset = max; + } + + for (t = range; t; t >>= 1) + bits += 1; + + do { + r = (*rng)(bits, user); + } while (r > range); + + return r + offset; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toi.c b/toi.c new file mode 100644 index 0000000..4026885 --- /dev/null +++ b/toi.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_toi(unsigned int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toi16.c b/toi16.c new file mode 100644 index 0000000..e5d93dd --- /dev/null +++ b/toi16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int_least16_t libsimple_toi16(uint_least16_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toi32.c b/toi32.c new file mode 100644 index 0000000..bf44a6c --- /dev/null +++ b/toi32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int_least32_t libsimple_toi32(uint_least32_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toi64.c b/toi64.c new file mode 100644 index 0000000..b2a92ab --- /dev/null +++ b/toi64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int_least64_t libsimple_toi64(uint_least64_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toi8.c b/toi8.c new file mode 100644 index 0000000..53bda55 --- /dev/null +++ b/toi8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int_least8_t libsimple_toi8(uint_least8_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toih.c b/toih.c new file mode 100644 index 0000000..954ff48 --- /dev/null +++ b/toih.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline short int libsimple_toih(unsigned short int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toihh.c b/toihh.c new file mode 100644 index 0000000..358d426 --- /dev/null +++ b/toihh.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline signed char libsimple_toihh(unsigned char); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toil.c b/toil.c new file mode 100644 index 0000000..c70bc37 --- /dev/null +++ b/toil.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline long int libsimple_toil(unsigned long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toill.c b/toill.c new file mode 100644 index 0000000..4566dc0 --- /dev/null +++ b/toill.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline long long int libsimple_toill(unsigned long long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toimax.c b/toimax.c new file mode 100644 index 0000000..5525999 --- /dev/null +++ b/toimax.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline intmax_t libsimple_toimax(uintmax_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toiptr.c b/toiptr.c new file mode 100644 index 0000000..c85ec1b --- /dev/null +++ b/toiptr.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline intptr_t libsimple_toiptr(uintptr_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/toiz.c b/toiz.c new file mode 100644 index 0000000..1e48aff --- /dev/null +++ b/toiz.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline ssize_t libsimple_toiz(size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/u16abs.c b/u16abs.c new file mode 100644 index 0000000..f7e87c3 --- /dev/null +++ b/u16abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least16_t libsimple_u16abs(uint_least16_t, uint_least16_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/u32abs.c b/u32abs.c new file mode 100644 index 0000000..06861b5 --- /dev/null +++ b/u32abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least32_t libsimple_u32abs(uint_least32_t, uint_least32_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/u64abs.c b/u64abs.c new file mode 100644 index 0000000..29e9fb7 --- /dev/null +++ b/u64abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least64_t libsimple_u64abs(uint_least64_t, uint_least64_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/u8abs.c b/u8abs.c new file mode 100644 index 0000000..827826a --- /dev/null +++ b/u8abs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uint_least8_t libsimple_u8abs(uint_least8_t, uint_least8_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/uabs.c b/uabs.c new file mode 100644 index 0000000..2a5e82b --- /dev/null +++ b/uabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned int libsimple_uabs(unsigned int, unsigned int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/uhabs.c b/uhabs.c new file mode 100644 index 0000000..543f04c --- /dev/null +++ b/uhabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned short int libsimple_uhabs(unsigned short int, unsigned short int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/uhhabs.c b/uhhabs.c new file mode 100644 index 0000000..d00ac96 --- /dev/null +++ b/uhhabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned char libsimple_uhhabs(unsigned char, unsigned char); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/ulabs.c b/ulabs.c new file mode 100644 index 0000000..d806857 --- /dev/null +++ b/ulabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned long int libsimple_ulabs(unsigned long int, unsigned long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/ullabs.c b/ullabs.c new file mode 100644 index 0000000..43c32c0 --- /dev/null +++ b/ullabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline unsigned long long int libsimple_ullabs(unsigned long long int, unsigned long long int); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/umaxabs.c b/umaxabs.c new file mode 100644 index 0000000..f5b1128 --- /dev/null +++ b/umaxabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uintmax_t libsimple_umaxabs(uintmax_t, uintmax_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/uptrabs.c b/uptrabs.c new file mode 100644 index 0000000..5ec5ceb --- /dev/null +++ b/uptrabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline uintptr_t libsimple_uptrabs(uintptr_t, uintptr_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/uzabs.c b/uzabs.c new file mode 100644 index 0000000..49d31fe --- /dev/null +++ b/uzabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline size_t libsimple_uzabs(size_t, size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/zabs.c b/zabs.c new file mode 100644 index 0000000..4d7c43a --- /dev/null +++ b/zabs.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline size_t libsimple_zabs(ssize_t, ssize_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/zdiff.c b/zdiff.c new file mode 100644 index 0000000..1e4bd60 --- /dev/null +++ b/zdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline size_t libsimple_zdiff(ssize_t, ssize_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif -- cgit v1.2.3-70-g09d2 From 398671adea37ed0390e83a627cd31e29ea944c7d Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 29 Jan 2024 17:38:47 +0100 Subject: Add libsimple_bindtemp_un MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 2 ++ README | 4 +-- bindtemp_un.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ libsimple.h | 1 + libsimple/net.h | 16 +++++++++++ 5 files changed, 110 insertions(+), 2 deletions(-) create mode 100644 bindtemp_un.c create mode 100644 libsimple/net.h diff --git a/Makefile b/Makefile index 4a8a324..a66da02 100644 --- a/Makefile +++ b/Makefile @@ -39,6 +39,7 @@ SUBHDR =\ libsimple/memalloc.h\ libsimple/memdup.h\ libsimple/memelem.h\ + libsimple/net.h\ libsimple/overflow.h\ libsimple/posix_memalign.h\ libsimple/posix_memalignz.h\ @@ -86,6 +87,7 @@ OBJ =\ asprintf.o\ bindex.o\ bindex_r.o\ + bindtemp_un.o\ callocn.o\ close.o\ close_range.o\ diff --git a/README b/README index 1de7b5c..d7aa9ea 100644 --- a/README +++ b/README @@ -5,8 +5,8 @@ values for integer data types. All functions are namespaced with `libsimple_` and aliased with macro definitions to unnamespaced names unless there already is a macro with that -name. However, some functions are seen as libsimple specific and do not -have unnamespaced. +name. However, some functions are seen as libsimple specific and are not +namespaced. Programs using this library should define `char *argv0` and set it to the 0:th command line argument. diff --git a/bindtemp_un.c b/bindtemp_un.c new file mode 100644 index 0000000..0362e47 --- /dev/null +++ b/bindtemp_un.c @@ -0,0 +1,89 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +/** + * Fill a buffer with random alphanumerical symbols, and '_' and '-' + * + * @param buf The buffer to fill + * @param n The size of the buffer + */ +static void +random_alnum(char *buf, size_t n) +{ + size_t i; + int rnd; + double drnd; + +#if defined(__linux__) && defined(GRND_NONBLOCK) + ssize_t r = getrandom(buf, n, GRND_NONBLOCK); + i = r < 0 ? 0 : (size_t)r; +#else + i = 0; +#endif + + for (; i < n; i++) { + rnd = rand(); + drnd = (double)rnd / (double)RAND_MAX; + drnd *= 63; + rnd = (int)drnd; + buf[i] = (char)rnd; + } + + for (i = 0; i < n; i++) + buf[i] = "0123456789_abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ"[buf[i] & 63]; +} + + +int +libsimple_bindtemp_un(int fd, int dir_fd, struct sockaddr_un *addr, socklen_t *addrlen) +{ + int len, saved_errno = errno; + size_t rem, try_limit = 1000; + struct sockaddr_un addr_; + + if (!addr) + addr = &addr_; + if (addrlen) + *addrlen = sizeof(*addr); + + memset(addr, 0, sizeof(*addr)); + addr->sun_family = AF_UNIX; + + if (dir_fd == AT_FDCWD) + len = snprintf(addr->sun_path, sizeof(addr->sun_path), "tmp"); + else + len = snprintf(addr->sun_path, sizeof(addr->sun_path), "/dev/fd/%i/tmp", dir_fd); + if (len < 0 || (size_t)len >= sizeof(addr->sun_path) || sizeof(addr->sun_path) - (size_t)len < 6) + abort(); + rem = sizeof(addr->sun_path) - 1 - len; + addr->sun_path[sizeof(addr->sun_path) - 1] = 0; + + while (try_limit--) { + again: + random_alnum(&addr->sun_path[len], rem); + if (!bind(fd, (void *)&addr, (socklen_t)sizeof(*addr))) { + errno = saved_errno; + return 0; + } else if (errno == ENAMETOOLONG && rem > 5) { + addr->sun_path[len + --rem] = 0; + goto again; + } else if (errno != EEXIST && errno != EADDRINUSE) { + return -1; + } + } + return -1; +} + + +#else +#include "test.h" + +int +main(void) /* TODO add test */ +{ + return 0; +} + +#endif diff --git a/libsimple.h b/libsimple.h index bdfc7c7..1d72f46 100644 --- a/libsimple.h +++ b/libsimple.h @@ -167,6 +167,7 @@ #include "libsimple/search.h" #include "libsimple/random.h" #include "libsimple/abs.h" +#include "libsimple/net.h" /** diff --git a/libsimple/net.h b/libsimple/net.h new file mode 100644 index 0000000..c30020b --- /dev/null +++ b/libsimple/net.h @@ -0,0 +1,16 @@ +/* See LICENSE file for copyright and license details. */ + + +/** + * Bind a unix(7) socket to a random file name in a specific directory + * + * @param fd The socket's file descriptor + * @param dir_fd File descriptor to the directory the socket shall be + * stored in (may be `AT_FDCWD`) + * @param addr_out Output parameter for the socket name (may be `NULL`); + * `&strrchr(addr_out->sun_path, '/')[1]` will be the + * name of the file the socket will be bound to + * @param addrlen_out Output parameter for the size of the socket name (may be `NULL`) + * @return 0 on success, -1 on failure + */ +int libsimple_bindtemp_un(int fd, int dir_fd, struct sockaddr_un *addr_out, socklen_t *addrlen_out); /* TODO man */ -- cgit v1.2.3-70-g09d2 -- cgit v1.2.3-70-g09d2 From 8ea489c16ce6c790084110fcd742150eb59db274 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 13 Apr 2024 10:54:41 +0200 Subject: Add libsimple_getcwd with e- and en- versions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 4 ++++ egetcwd.c | 18 ++++++++++++++++++ engetcwd.c | 25 +++++++++++++++++++++++++ getcwd.c | 40 ++++++++++++++++++++++++++++++++++++++++ libsimple.h | 1 + libsimple/path.h | 31 +++++++++++++++++++++++++++++++ 6 files changed, 119 insertions(+) create mode 100644 egetcwd.c create mode 100644 engetcwd.c create mode 100644 getcwd.c create mode 100644 libsimple/path.h diff --git a/Makefile b/Makefile index a66da02..02a409d 100644 --- a/Makefile +++ b/Makefile @@ -41,6 +41,7 @@ SUBHDR =\ libsimple/memelem.h\ libsimple/net.h\ libsimple/overflow.h\ + libsimple/path.h\ libsimple/posix_memalign.h\ libsimple/posix_memalignz.h\ libsimple/printf.h\ @@ -113,6 +114,7 @@ OBJ =\ ealigned_wmemdup.o\ ecalloc.o\ ecallocn.o\ + egetcwd.o\ egmtime.o\ elocaltime.o\ emalloc.o\ @@ -140,6 +142,7 @@ OBJ =\ enaligned_wmemdup.o\ encalloc.o\ encallocn.o\ + engetcwd.o\ engmtime.o\ enlocaltime.o\ enmalloc.o\ @@ -231,6 +234,7 @@ OBJ =\ ewcsndup.o\ ewmemdup.o\ generate_seed.o\ + getcwd.o\ getenv_e.o\ getenv_ne.o\ gmtime.o\ diff --git a/egetcwd.c b/egetcwd.c new file mode 100644 index 0000000..ac32bab --- /dev/null +++ b/egetcwd.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_egetcwd(void); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/engetcwd.c b/engetcwd.c new file mode 100644 index 0000000..e5fce2b --- /dev/null +++ b/engetcwd.c @@ -0,0 +1,25 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_engetcwd(int status) +{ + char *ret = libsimple_getcwd(); + if (!ret) + libsimple_enprintf(status, "libsimple_getcwd:"); + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/getcwd.c b/getcwd.c new file mode 100644 index 0000000..38c7bcf --- /dev/null +++ b/getcwd.c @@ -0,0 +1,40 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_getcwd(void) +{ + char *cwd = NULL, *new; + size_t cwd_size = 0; + + for (;;) { + new = realloc(cwd, cwd_size += 512); + if (!new) + goto error; + cwd = new; + if (getcwd(cwd, cwd_size)) + break; + if (errno != ERANGE) + goto error; + } + + return cwd; + +error: + free(cwd); + return NULL; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/libsimple.h b/libsimple.h index 1d72f46..2b45dfa 100644 --- a/libsimple.h +++ b/libsimple.h @@ -168,6 +168,7 @@ #include "libsimple/random.h" #include "libsimple/abs.h" #include "libsimple/net.h" +#include "libsimple/path.h" /** diff --git a/libsimple/path.h b/libsimple/path.h new file mode 100644 index 0000000..99aea28 --- /dev/null +++ b/libsimple/path.h @@ -0,0 +1,31 @@ +/* See LICENSE file for copyright and license details. */ + + +/** + * Get the current working directory + * + * @return The current working directory, or `NULL` on failure + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__))) +char *libsimple_getcwd(void); /* TODO man */ + +/** + * Version of `libsimple_getcwd` that calls `libsimple_enprintf` on error + * + * @param status Exit value in case of failure + * @return The current working directory + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) +char *libsimple_engetcwd(int status); /* TODO man */ + +/** + * Version of `libsimple_getcwd` that calls `libsimple_eprintf` on error + * + * @return The current working directory + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) +inline char * +libsimple_egetcwd(void) /* TODO man */ +{ + return libsimple_engetcwd(libsimple_default_failure_exit); +} -- cgit v1.2.3-70-g09d2 From 220bce53e145684c41476e85dbab319f5da48f13 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 13 Apr 2024 10:58:50 +0200 Subject: Add assume_aligned to libsimple_getcwd MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libsimple/path.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/libsimple/path.h b/libsimple/path.h index 99aea28..0e6ad7b 100644 --- a/libsimple/path.h +++ b/libsimple/path.h @@ -6,7 +6,7 @@ * * @return The current working directory, or `NULL` on failure */ -LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__))) +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__))) char *libsimple_getcwd(void); /* TODO man */ /** @@ -15,7 +15,7 @@ char *libsimple_getcwd(void); /* TODO man */ * @param status Exit value in case of failure * @return The current working directory */ -LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __returns_nonnull__))) char *libsimple_engetcwd(int status); /* TODO man */ /** @@ -23,7 +23,7 @@ char *libsimple_engetcwd(int status); /* TODO man */ * * @return The current working directory */ -LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __returns_nonnull__))) inline char * libsimple_egetcwd(void) /* TODO man */ { -- cgit v1.2.3-70-g09d2 From e2346f713d55f3bcb81c8b724aaa0d9d27b8f6bd Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 13 Apr 2024 11:10:20 +0200 Subject: Add libsimple_abspath with e- and en- versions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 3 +++ abspath.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ eabspath.c | 18 ++++++++++++++++++ enabspath.c | 25 +++++++++++++++++++++++++ libsimple/path.h | 38 +++++++++++++++++++++++++++++++++++++- 5 files changed, 127 insertions(+), 1 deletion(-) create mode 100644 abspath.c create mode 100644 eabspath.c create mode 100644 enabspath.c diff --git a/Makefile b/Makefile index 02a409d..d9c2b5a 100644 --- a/Makefile +++ b/Makefile @@ -69,6 +69,7 @@ HDR =\ OBJ =\ abs.o\ + abspath.o\ aligned_allocn.o\ aligned_allocz.o\ aligned_alloczn.o\ @@ -99,6 +100,7 @@ OBJ =\ difftimeval.o\ doubletotimespec.o\ doubletotimeval.o\ + eabspath.o\ ealigned_alloc.o\ ealigned_allocn.o\ ealigned_allocz.o\ @@ -127,6 +129,7 @@ OBJ =\ ememalignzn.o\ ememalloc.o\ ememdup.o\ + enabspath.o\ enaligned_alloc.o\ enaligned_allocn.o\ enaligned_allocz.o\ diff --git a/abspath.c b/abspath.c new file mode 100644 index 0000000..60454ff --- /dev/null +++ b/abspath.c @@ -0,0 +1,44 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_abspath(const char *path, const char *relto) +{ + size_t size; + int add_slash; + char *p, *ret; + + if (*path == '/') { + ret = strdup(path); + return ret; + } + + while (path[0] == '.' && path[1] == '/') + path = &path[2]; + + add_slash = (strchr(relto, '\0')[-1] != '/'); + size = strlen(relto) + strlen(path) + (size_t)(1 + add_slash); + + ret = malloc(size); + if (ret) { + p = stpcpy(ret, relto); + if (add_slash) + *p++ = '/'; + stpcpy(p, path); + } + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/eabspath.c b/eabspath.c new file mode 100644 index 0000000..41b7ea0 --- /dev/null +++ b/eabspath.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_eabspath(const char *, const char *); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/enabspath.c b/enabspath.c new file mode 100644 index 0000000..039144e --- /dev/null +++ b/enabspath.c @@ -0,0 +1,25 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_enabspath(int status, const char *path, const char *relto) +{ + char *ret = libsimple_abspath(path, relto); + if (!ret) + libsimple_enprintf(status, "libsimple_abspath %s %s:", path, relto); + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/libsimple/path.h b/libsimple/path.h index 0e6ad7b..ace64ac 100644 --- a/libsimple/path.h +++ b/libsimple/path.h @@ -16,7 +16,7 @@ char *libsimple_getcwd(void); /* TODO man */ * @return The current working directory */ LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __returns_nonnull__))) -char *libsimple_engetcwd(int status); /* TODO man */ +char *libsimple_engetcwd(int); /* TODO man */ /** * Version of `libsimple_getcwd` that calls `libsimple_eprintf` on error @@ -29,3 +29,39 @@ libsimple_egetcwd(void) /* TODO man */ { return libsimple_engetcwd(libsimple_default_failure_exit); } + + +/** + * Turn a path into an absolute path if it is a relative path + * + * @param path The path to transform + * @param relto The directory `path` is relative to if it is a relative path + * @return `path` as an absolute path, or `NULL` on failure + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__(1)))) +char *libsimple_abspath(const char *, const char *); /* TODO man */ + +/** + * Version of `libsimple_abspath` that calls `libsimple_enprintf` on error + * + * @param status Exit value in case of failure + * @param path The path to transform + * @param relto The directory `path` is relative to if it is a relative path + * @return `path` as an absolute path + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__(2), __returns_nonnull__))) +char *libsimple_enabspath(int, const char *, const char *); /* TODO man */ + +/** + * Version of `libsimple_abspath` that calls `libsimple_eprintf` on error + * + * @param path The path to transform + * @param relto The directory `path` is relative to if it is a relative path + * @return `path` as an absolute path + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__(1), __returns_nonnull__))) +inline char * +libsimple_eabspath(const char *p__, const char *r__) /* TODO man */ +{ + return libsimple_enabspath(libsimple_default_failure_exit, p__, r__); +} -- cgit v1.2.3-70-g09d2 From bbad2aa1db028c33728c1a49a517882756ef3c13 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 13 Apr 2024 11:17:57 +0200 Subject: Add -lm MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- config.mk | 2 +- libsimple/random.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/config.mk b/config.mk index c9919fd..9bafe24 100644 --- a/config.mk +++ b/config.mk @@ -5,4 +5,4 @@ CC = cc CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 CFLAGS = -std=c11 -Wall -Wextra -O2 -LDFLAGS = -s +LDFLAGS = -s -lm diff --git a/libsimple/random.h b/libsimple/random.h index a786661..a3b1739 100644 --- a/libsimple/random.h +++ b/libsimple/random.h @@ -22,7 +22,7 @@ libsimple_srand(void) /* TODO add man page */ } -/* TODO doc, man */ +/* TODO doc, man (libsimple_random_float requires -lm) */ uintmax_t libsimple_random_bits(size_t bits, void *unused); uintmax_t libsimple_random_unsigned(uintmax_t (*rng)(size_t bits, void *user), void *user, uintmax_t min, uintmax_t max); intmax_t libsimple_random_signed(uintmax_t (*rng)(size_t bits, void *user), void *user, intmax_t min, intmax_t max); -- cgit v1.2.3-70-g09d2 From 53b8e053312ff1753e5b243060716d2612355f16 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 13 Apr 2024 11:34:43 +0200 Subject: libsimple_abspath: accept NULL for cwd MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- abspath.c | 10 +++++++++- enabspath.c | 2 +- libsimple/path.h | 9 ++++++--- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/abspath.c b/abspath.c index 60454ff..57cd644 100644 --- a/abspath.c +++ b/abspath.c @@ -8,7 +8,7 @@ libsimple_abspath(const char *path, const char *relto) { size_t size; int add_slash; - char *p, *ret; + char *p, *ret, *relto_free = NULL; if (*path == '/') { ret = strdup(path); @@ -18,6 +18,13 @@ libsimple_abspath(const char *path, const char *relto) while (path[0] == '.' && path[1] == '/') path = &path[2]; + if (relto) { + relto_free = libsimple_getcwd(); + if (!relto_free) + return NULL; + relto = relto_free; + } + add_slash = (strchr(relto, '\0')[-1] != '/'); size = strlen(relto) + strlen(path) + (size_t)(1 + add_slash); @@ -28,6 +35,7 @@ libsimple_abspath(const char *path, const char *relto) *p++ = '/'; stpcpy(p, path); } + free(relto_free); return ret; } diff --git a/enabspath.c b/enabspath.c index 039144e..528f9a9 100644 --- a/enabspath.c +++ b/enabspath.c @@ -8,7 +8,7 @@ libsimple_enabspath(int status, const char *path, const char *relto) { char *ret = libsimple_abspath(path, relto); if (!ret) - libsimple_enprintf(status, "libsimple_abspath %s %s:", path, relto); + libsimple_enprintf(status, "libsimple_abspath %s %s:", path, relto ? relto : "NULL"); return ret; } diff --git a/libsimple/path.h b/libsimple/path.h index ace64ac..65f2751 100644 --- a/libsimple/path.h +++ b/libsimple/path.h @@ -35,7 +35,8 @@ libsimple_egetcwd(void) /* TODO man */ * Turn a path into an absolute path if it is a relative path * * @param path The path to transform - * @param relto The directory `path` is relative to if it is a relative path + * @param relto The directory `path` is relative to if it is a relative path, + * `NULL` for the current working directory * @return `path` as an absolute path, or `NULL` on failure */ LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__(1)))) @@ -46,7 +47,8 @@ char *libsimple_abspath(const char *, const char *); /* TODO man */ * * @param status Exit value in case of failure * @param path The path to transform - * @param relto The directory `path` is relative to if it is a relative path + * @param relto The directory `path` is relative to if it is a relative path, + * `NULL` for the current working directory * @return `path` as an absolute path */ LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__(2), __returns_nonnull__))) @@ -56,7 +58,8 @@ char *libsimple_enabspath(int, const char *, const char *); /* TODO man */ * Version of `libsimple_abspath` that calls `libsimple_eprintf` on error * * @param path The path to transform - * @param relto The directory `path` is relative to if it is a relative path + * @param relto The directory `path` is relative to if it is a relative path, + * `NULL` for the current working directory * @return `path` as an absolute path */ LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__(1), __returns_nonnull__))) -- cgit v1.2.3-70-g09d2 From d33c5c0a18017ae658feb4a3344dd810cc87050b Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sun, 5 May 2024 10:28:31 +0200 Subject: m + add ascii.h and exec.h MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 24 ++ bindtemp_un.c | 6 +- common.h | 4 + config.mk | 2 +- execlat.c | 27 +++ execleat.c | 27 +++ execlpe.c | 27 +++ execvat.c | 22 ++ execveat.c | 56 +++++ execvpe.c | 22 ++ fexecl.c | 27 +++ fexecle.c | 27 +++ fexecv.c | 22 ++ libsimple.c | 2 +- libsimple.h | 2 + libsimple/ascii.h | 657 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ libsimple/env.h | 7 + libsimple/exec.h | 99 ++++++++ vexecl.c | 22 ++ vexeclat.c | 28 +++ vexecle.c | 22 ++ vexecleat.c | 30 +++ vexeclp.c | 22 ++ vexeclpe.c | 22 ++ vfexecl.c | 22 ++ vfexecle.c | 28 +++ vxexecl.c | 35 +++ vxexecle.c | 28 +++ which.c | 92 ++++++++ xexecl.c | 27 +++ xexecv.c | 31 +++ 31 files changed, 1464 insertions(+), 5 deletions(-) create mode 100644 execlat.c create mode 100644 execleat.c create mode 100644 execlpe.c create mode 100644 execvat.c create mode 100644 execveat.c create mode 100644 execvpe.c create mode 100644 fexecl.c create mode 100644 fexecle.c create mode 100644 fexecv.c create mode 100644 libsimple/ascii.h create mode 100644 libsimple/exec.h create mode 100644 vexecl.c create mode 100644 vexeclat.c create mode 100644 vexecle.c create mode 100644 vexecleat.c create mode 100644 vexeclp.c create mode 100644 vexeclpe.c create mode 100644 vfexecl.c create mode 100644 vfexecle.c create mode 100644 vxexecl.c create mode 100644 vxexecle.c create mode 100644 which.c create mode 100644 xexecl.c create mode 100644 xexecv.c diff --git a/Makefile b/Makefile index d9c2b5a..84fb58c 100644 --- a/Makefile +++ b/Makefile @@ -28,9 +28,11 @@ SUBHDR =\ libsimple/aligned_wcsndup.h\ libsimple/aligned_wmemdup.h\ libsimple/array.h\ + libsimple/ascii.h\ libsimple/calloc.h\ libsimple/definitions.h\ libsimple/env.h\ + libsimple/exec.h\ libsimple/malloc.h\ libsimple/mallocz.h\ libsimple/mem.h\ @@ -236,6 +238,15 @@ OBJ =\ ewcsdup.o\ ewcsndup.o\ ewmemdup.o\ + execlat.o\ + execleat.o\ + execlpe.o\ + execvat.o\ + execveat.o\ + execvpe.o\ + fexecl.o\ + fexecle.o\ + fexecv.o\ generate_seed.o\ getcwd.o\ getenv_e.o\ @@ -501,6 +512,14 @@ OBJ =\ vcallocn.o\ venprintf.o\ veprintf.o\ + vexecl.o\ + vexeclat.o\ + vexecle.o\ + vexecleat.o\ + vexeclp.o\ + vexeclpe.o\ + vfexecl.o\ + vfexecle.o\ vmallocn.o\ vmemalignn.o\ vmemalignzn.o\ @@ -513,9 +532,14 @@ OBJ =\ vvallocn.o\ vvalloczn.o\ vweprintf.o\ + vxexecl.o\ + vxexecle.o\ wcsndup.o\ weprintf.o\ + which.o\ wmemdup.o\ + xexecl.o\ + xexecv.o\ zabs.o\ zdiff.o\ libsimple.o diff --git a/bindtemp_un.c b/bindtemp_un.c index 0362e47..5f0de05 100644 --- a/bindtemp_un.c +++ b/bindtemp_un.c @@ -57,8 +57,8 @@ libsimple_bindtemp_un(int fd, int dir_fd, struct sockaddr_un *addr, socklen_t *a len = snprintf(addr->sun_path, sizeof(addr->sun_path), "/dev/fd/%i/tmp", dir_fd); if (len < 0 || (size_t)len >= sizeof(addr->sun_path) || sizeof(addr->sun_path) - (size_t)len < 6) abort(); - rem = sizeof(addr->sun_path) - 1 - len; - addr->sun_path[sizeof(addr->sun_path) - 1] = 0; + rem = sizeof(addr->sun_path) - 1U - (size_t)len; + addr->sun_path[sizeof(addr->sun_path) - 1U] = 0; while (try_limit--) { again: @@ -67,7 +67,7 @@ libsimple_bindtemp_un(int fd, int dir_fd, struct sockaddr_un *addr, socklen_t *a errno = saved_errno; return 0; } else if (errno == ENAMETOOLONG && rem > 5) { - addr->sun_path[len + --rem] = 0; + addr->sun_path[(size_t)len + --rem] = 0; goto again; } else if (errno != EEXIST && errno != EADDRINUSE) { return -1; diff --git a/common.h b/common.h index 7f84f59..81ad053 100644 --- a/common.h +++ b/common.h @@ -9,3 +9,7 @@ # pragma clang diagnostic ignored "-Wc++98-compat" # pragma clang diagnostic ignored "-Wcovered-switch-default" #endif + +#ifdef execveat +# undef execveat +#endif diff --git a/config.mk b/config.mk index 9bafe24..c7eb5ca 100644 --- a/config.mk +++ b/config.mk @@ -3,6 +3,6 @@ MANPREFIX = $(PREFIX)/share/man CC = cc -CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 +CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_GNU_SOURCE CFLAGS = -std=c11 -Wall -Wextra -O2 LDFLAGS = -s -lm diff --git a/execlat.c b/execlat.c new file mode 100644 index 0000000..37f7fbb --- /dev/null +++ b/execlat.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_execlat(int dirfd, const char *pathname, ... /* argv, NULL, int flags */) +{ + int ret; + va_list args; + va_start(args, pathname); + ret = libsimple_vexeclat(dirfd, pathname, args); + va_end(args); + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/execleat.c b/execleat.c new file mode 100644 index 0000000..c72e1de --- /dev/null +++ b/execleat.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_execleat(int dirfd, const char *pathname, ... /* argv, NULL, char *const envp[], int flags */) +{ + int ret; + va_list args; + va_start(args, pathname); + ret = libsimple_vexecleat(dirfd, pathname, args); + va_end(args); + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/execlpe.c b/execlpe.c new file mode 100644 index 0000000..034eb6e --- /dev/null +++ b/execlpe.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_execlpe(const char *file, ... /* argv, NULL, char *const envp[] */) +{ + int ret; + va_list args; + va_start(args, file); + ret = libsimple_vexeclpe(file, args); + va_end(args); + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/execvat.c b/execvat.c new file mode 100644 index 0000000..ea5bb75 --- /dev/null +++ b/execvat.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_execvat(int dirfd, const char *pathname, char *const argv[], int flags) +{ + return execveat(dirfd, pathname, argv, environ, flags); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/execveat.c b/execveat.c new file mode 100644 index 0000000..ed7b11e --- /dev/null +++ b/execveat.c @@ -0,0 +1,56 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_execveat(int dirfd, const char *pathname, char *const argv[], char *const envp[], int flags) +{ + struct stat st; + int fd, saved_errno; + +#if defined(__linux__) + execveat(dirfd, pathname, argv, envp, flags); + if (errno != ENOSYS) + return -1; +#endif + + if (flags & AT_EMPTY_PATH) + return fexecve(dirfd, argv, envp); + +#ifndef O_PATH +# define O_PATH O_RDONLY +#endif + + fd = openat(dirfd, pathname, O_PATH | ((flags & AT_SYMLINK_NOFOLLOW) ? O_NOFOLLOW : 0)); + if (fd < 0) + return -1; + + if (flags & AT_SYMLINK_NOFOLLOW) { + if (fstat(fd, &st)) { + saved_errno = errno; + close(fd); + errno = saved_errno; + return -1; + } + if (S_ISLNK(st.st_mode)) { + close(fd); + errno = ELOOP; + return -1; + } + } + + return fexecve(fd, argv, envp); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/execvpe.c b/execvpe.c new file mode 100644 index 0000000..fe117a9 --- /dev/null +++ b/execvpe.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_execvpe(const char *file, char *const argv[], char *const envp[]) +{ + return libsimple_xexecv(-1, file, -1, NULL, envp, argv); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/fexecl.c b/fexecl.c new file mode 100644 index 0000000..4767fa4 --- /dev/null +++ b/fexecl.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_fexecl(int fd, ... /* argv, NULL */) +{ + int ret; + va_list args; + va_start(args, fd); + ret = libsimple_vfexecl(fd, args); + va_end(args); + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/fexecle.c b/fexecle.c new file mode 100644 index 0000000..e70fbc2 --- /dev/null +++ b/fexecle.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_fexecle(int fd, ... /* argv, NULL, char *const envp[] */) +{ + int ret; + va_list args; + va_start(args, fd); + ret = libsimple_vfexecle(fd, args); + va_end(args); + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/fexecv.c b/fexecv.c new file mode 100644 index 0000000..955ae58 --- /dev/null +++ b/fexecv.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_fexecv(int fd, char *const argv[]) +{ + return fexecve(fd, argv, environ); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/libsimple.c b/libsimple.c index 2bb5139..100a22c 100644 --- a/libsimple.c +++ b/libsimple.c @@ -70,7 +70,7 @@ test_timeval(double d, time_t sec, long int usec, double rd, const char *s, cons } #ifdef libsimple_vasprintfa -LIBSIMPLE_GCC_ONLY__(__attribute__((__format__(__printf__, 2, 0)))) +LIBSIMPLE_GCC_ONLY__(__attribute__((__format__(__printf__, 2, 3)))) static int test_vasprintfa(const char *expected, const char *format, ...) { diff --git a/libsimple.h b/libsimple.h index 2b45dfa..f1e479c 100644 --- a/libsimple.h +++ b/libsimple.h @@ -169,6 +169,8 @@ #include "libsimple/abs.h" #include "libsimple/net.h" #include "libsimple/path.h" +#include "libsimple/ascii.h" +#include "libsimple/exec.h" /** diff --git a/libsimple/ascii.h b/libsimple/ascii.h new file mode 100644 index 0000000..faaa99e --- /dev/null +++ b/libsimple/ascii.h @@ -0,0 +1,657 @@ +/* See LICENSE file for copyright and license details. */ + +/* TODO man, doc, test */ + + +#define LIBSIMPLE_CHAR_NUL '\x00' +#ifndef CHAR_NUL +# define CHAR_NUL LIBSIMPLE_CHAR_NUL +#endif +#define LIBSIMPLE_CHAR_NULL LIBSIMPLE_CHAR_NUL +#ifndef CHAR_NULL +# define CHAR_NULL LIBSIMPLE_CHAR_NULL +#endif + +#define LIBSIMPLE_CHAR_SOH '\x01' +#ifndef CHAR_SOH +# define CHAR_SOH LIBSIMPLE_CHAR_SOH +#endif +#define LIBSIMPLE_CHAR_START_OF_HEADING LIBSIMPLE_CHAR_SOH +#ifndef CHAR_START_OF_HEADING +# define CHAR_START_OF_HEADING LIBSIMPLE_CHAR_START_OF_HEADING +#endif + +#define LIBSIMPLE_CHAR_STX '\x02' +#ifndef CHAR_STX +# define CHAR_STX LIBSIMPLE_CHAR_STX +#endif +#define LIBSIMPLE_CHAR_START_OF_TEXT LIBSIMPLE_CHAR_STX +#ifndef CHAR_START_OF_TEXT +# define CHAR_START_OF_TEXT LIBSIMPLE_CHAR_START_OF_TEXT +#endif + +#define LIBSIMPLE_CHAR_ETX '\x03' +#ifndef CHAR_ETX +# define CHAR_ETX LIBSIMPLE_CHAR_ETX +#endif +#define LIBSIMPLE_CHAR_END_OF_TEXT LIBSIMPLE_CHAR_ETX +#ifndef CHAR_END_OF_TEXT +# define CHAR_END_OF_TEXT LIBSIMPLE_CHAR_END_OF_TEXT +#endif + +#define LIBSIMPLE_CHAR_EOT '\x04' +#ifndef CHAR_EOT +# define CHAR_EOT LIBSIMPLE_CHAR_EOT +#endif +#define LIBSIMPLE_CHAR_END_OF_TRANSMISSION LIBSIMPLE_CHAR_EOT +#ifndef CHAR_END_OF_TRANSMISSION +# define CHAR_END_OF_TRANSMISSION LIBSIMPLE_CHAR_END_OF_TRANSMISSION +#endif + +#define LIBSIMPLE_CHAR_ENQ '\x05' +#ifndef CHAR_ENQ +# define CHAR_ENQ LIBSIMPLE_CHAR_ENQ +#endif +#define LIBSIMPLE_CHAR_ENQUIRY LIBSIMPLE_CHAR_ENQ +#ifndef CHAR_ENQUIRY +# define CHAR_ENQUIRY LIBSIMPLE_CHAR_ENQUIRY +#endif + +#define LIBSIMPLE_CHAR_ACK '\x06' +#ifndef CHAR_ACK +# define CHAR_ACK LIBSIMPLE_CHAR_ACK +#endif +#define LIBSIMPLE_CHAR_ACKNOWLEDGE LIBSIMPLE_CHAR_ACK +#ifndef CHAR_ACKNOWLEDGE +# define CHAR_ACKNOWLEDGE LIBSIMPLE_CHAR_ACKNOWLEDGE +#endif + +#define LIBSIMPLE_CHAR_BEL '\x07' +#ifndef CHAR_BEL +# define CHAR_BEL LIBSIMPLE_CHAR_BEL +#endif +#define LIBSIMPLE_CHAR_BELL LIBSIMPLE_CHAR_BEL +#ifndef CHAR_BELL +# define CHAR_BELL LIBSIMPLE_CHAR_BELL +#endif + +#define LIBSIMPLE_CHAR_BS '\x08' +#ifndef CHAR_BS +# define CHAR_BS LIBSIMPLE_CHAR_BS +#endif +#define LIBSIMPLE_CHAR_BACKSPACE LIBSIMPLE_CHAR_BS +#ifndef CHAR_BACKSPACE +# define CHAR_BACKSPACE LIBSIMPLE_CHAR_BACKSPACE +#endif + +#define LIBSIMPLE_CHAR_HT '\x09' +#ifndef CHAR_HT +# define CHAR_HT LIBSIMPLE_CHAR_HT +#endif +#define LIBSIMPLE_CHAR_HORIZONTAL_TABULATION LIBSIMPLE_CHAR_HT +#ifndef CHAR_HORIZONTAL_TABULATION +# define CHAR_HORIZONTAL_TABULATION LIBSIMPLE_CHAR_HORIZONTAL_TABULATION +#endif + +#define LIBSIMPLE_CHAR_LF '\x0A' +#ifndef CHAR_LF +# define CHAR_LF LIBSIMPLE_CHAR_LF +#endif +#define LIBSIMPLE_CHAR_LINE_FEED LIBSIMPLE_CHAR_LF +#ifndef CHAR_LINE_FEED +# define CHAR_LINE_FEED LIBSIMPLE_CHAR_LINE_FEED +#endif + +#define LIBSIMPLE_CHAR_VT '\x0B' +#ifndef CHAR_VT +# define CHAR_VT LIBSIMPLE_CHAR_VT +#endif +#define LIBSIMPLE_CHAR_VERTICAL_TABULATION LIBSIMPLE_CHAR_VT +#ifndef CHAR_VERTICAL_TABULATION +# define CHAR_VERTICAL_TABULATION LIBSIMPLE_CHAR_VERTICAL_TABULATION +#endif + +#define LIBSIMPLE_CHAR_FF '\x0C' +#ifndef CHAR_FF +# define CHAR_FF LIBSIMPLE_CHAR_FF +#endif +#define LIBSIMPLE_CHAR_FORM_FEED LIBSIMPLE_CHAR_FF +#ifndef CHAR_FORM_FEED +# define CHAR_FORM_FEED LIBSIMPLE_CHAR_FORM_FEED +#endif + +#define LIBSIMPLE_CHAR_CR '\x0D' +#ifndef CHAR_CR +# define CHAR_CR LIBSIMPLE_CHAR_CR +#endif +#define LIBSIMPLE_CHAR_CARRIAGE_RETURN LIBSIMPLE_CHAR_CR +#ifndef CHAR_CARRIAGE_RETURN +# define CHAR_CARRIAGE_RETURN LIBSIMPLE_CHAR_CARRIAGE_RETURN +#endif + +#define LIBSIMPLE_CHAR_SO '\x0E' +#ifndef CHAR_SO +# define CHAR_SO LIBSIMPLE_CHAR_SO +#endif +#define LIBSIMPLE_CHAR_SHIFT_OUT LIBSIMPLE_CHAR_SO +#ifndef CHAR_SHIFT_OUT +# define CHAR_SHIFT_OUT LIBSIMPLE_CHAR_SHIFT_OUT +#endif + +#define LIBSIMPLE_CHAR_SI '\x0F' +#ifndef CHAR_SI +# define CHAR_SI LIBSIMPLE_CHAR_SI +#endif +#define LIBSIMPLE_CHAR_SHIFT_IN LIBSIMPLE_CHAR_SI +#ifndef CHAR_SHIFT_IN +# define CHAR_SHIFT_IN LIBSIMPLE_CHAR_SHIFT_IN +#endif + +#define LIBSIMPLE_CHAR_DLE '\x10' +#ifndef CHAR_DLE +# define CHAR_DLE LIBSIMPLE_CHAR_DLE +#endif +#define LIBSIMPLE_CHAR_DATA_LINK_ESCAPE LIBSIMPLE_CHAR_DLE +#ifndef CHAR_DATA_LINK_ESCAPE +# define CHAR_DATA_LINK_ESCAPE LIBSIMPLE_CHAR_DATA_LINK_ESCAPE +#endif + +#define LIBSIMPLE_CHAR_DC1 '\x11' +#ifndef CHAR_DC1 +# define CHAR_DC1 LIBSIMPLE_CHAR_DC1 +#endif +#define LIBSIMPLE_CHAR_DEVICE_CONTROL_1 LIBSIMPLE_CHAR_DC1 +#ifndef CHAR_DEVICE_CONTROL_1 +# define CHAR_DEVICE_CONTROL_1 LIBSIMPLE_CHAR_DEVICE_CONTROL_1 +#endif + +#define LIBSIMPLE_CHAR_DC2 '\x12' +#ifndef CHAR_DC2 +# define CHAR_DC2 LIBSIMPLE_CHAR_DC2 +#endif +#define LIBSIMPLE_CHAR_DEVICE_CONTROL_2 LIBSIMPLE_CHAR_DC2 +#ifndef CHAR_DEVICE_CONTROL_2 +# define CHAR_DEVICE_CONTROL_2 LIBSIMPLE_CHAR_DEVICE_CONTROL_2 +#endif + +#define LIBSIMPLE_CHAR_DC3 '\x13' +#ifndef CHAR_DC3 +# define CHAR_DC3 LIBSIMPLE_CHAR_DC3 +#endif +#define LIBSIMPLE_CHAR_DEVICE_CONTROL_3 LIBSIMPLE_CHAR_DC3 +#ifndef CHAR_DEVICE_CONTROL_3 +# define CHAR_DEVICE_CONTROL_3 LIBSIMPLE_CHAR_DEVICE_CONTROL_3 +#endif + +#define LIBSIMPLE_CHAR_DC4 '\x14' +#ifndef CHAR_DC4 +# define CHAR_DC4 LIBSIMPLE_CHAR_DC4 +#endif +#define LIBSIMPLE_CHAR_DEVICE_CONTROL_4 LIBSIMPLE_CHAR_DC4 +#ifndef CHAR_DEVICE_CONTROL_4 +# define CHAR_DEVICE_CONTROL_4 LIBSIMPLE_CHAR_DEVICE_CONTROL_4 +#endif + +#define LIBSIMPLE_CHAR_NAK '\x15' +#ifndef CHAR_NAK +# define CHAR_NAK LIBSIMPLE_CHAR_NAK +#endif +#define LIBSIMPLE_CHAR_NEGATIVE_ACKNOWLEDGE LIBSIMPLE_CHAR_NAK +#ifndef CHAR_NEGATIVE_ACKNOWLEDGE +# define CHAR_NEGATIVE_ACKNOWLEDGE LIBSIMPLE_CHAR_NEGATIVE_ACKNOWLEDGE +#endif + +#define LIBSIMPLE_CHAR_SYN '\x16' +#ifndef CHAR_SYN +# define CHAR_SYN LIBSIMPLE_CHAR_SYN +#endif +#define LIBSIMPLE_CHAR_SYNCHRONOUS_IDLE LIBSIMPLE_CHAR_SYN +#ifndef CHAR_SYNCHRONOUS_IDLE +# define CHAR_SYNCHRONOUS_IDLE LIBSIMPLE_CHAR_SYNCHRONOUS_IDLE +#endif + +#define LIBSIMPLE_CHAR_ETB '\x17' +#ifndef CHAR_ETB +# define CHAR_ETB LIBSIMPLE_CHAR_ETB +#endif +#define LIBSIMPLE_CHAR_END_OF_TRANSMISSION_BLOCK LIBSIMPLE_CHAR_ETB +#ifndef CHAR_END_OF_TRANSMISSION_BLOCK +# define CHAR_END_OF_TRANSMISSION_BLOCK LIBSIMPLE_CHAR_END_OF_TRANSMISSION_BLOCK +#endif + +#define LIBSIMPLE_CHAR_CAN '\x18' +#ifndef CHAR_CAN +# define CHAR_CAN LIBSIMPLE_CHAR_CAN +#endif +#define LIBSIMPLE_CHAR_CANCEL LIBSIMPLE_CHAR_CAN +#ifndef CHAR_CANCEL +# define CHAR_CANCEL LIBSIMPLE_CHAR_CANCEL +#endif + +#define LIBSIMPLE_CHAR_EM '\x19' +#ifndef CHAR_EM +# define CHAR_EM LIBSIMPLE_CHAR_EM +#endif +#define LIBSIMPLE_CHAR_END_OF_MEDIUM LIBSIMPLE_CHAR_EM +#ifndef CHAR_END_OF_MEDIUM +# define CHAR_END_OF_MEDIUM LIBSIMPLE_CHAR_END_OF_MEDIUM +#endif + +#define LIBSIMPLE_CHAR_SUB '\x1A' +#ifndef CHAR_SUB +# define CHAR_SUB LIBSIMPLE_CHAR_SUB +#endif +#define LIBSIMPLE_CHAR_SUBSTITUTE LIBSIMPLE_CHAR_SUB +#ifndef CHAR_SUBSTITUTE +# define CHAR_SUBSTITUTE LIBSIMPLE_CHAR_SUBSTITUTE +#endif + +#define LIBSIMPLE_CHAR_ESC '\x1B' +#ifndef CHAR_ESC +# define CHAR_ESC LIBSIMPLE_CHAR_ESC +#endif +#define LIBSIMPLE_CHAR_ESCAPE LIBSIMPLE_CHAR_ESC +#ifndef CHAR_ESCAPE +# define CHAR_ESCAPE LIBSIMPLE_CHAR_ESCAPE +#endif + +#define LIBSIMPLE_CHAR_FS '\x1C' +#ifndef CHAR_FS +# define CHAR_FS LIBSIMPLE_CHAR_FS +#endif +#define LIBSIMPLE_CHAR_FILE_SEPARATOR LIBSIMPLE_CHAR_FS +#ifndef CHAR_FILE_SEPARATOR +# define CHAR_FILE_SEPARATOR LIBSIMPLE_CHAR_FILE_SEPARATOR +#endif + +#define LIBSIMPLE_CHAR_GS '\x1D' +#ifndef CHAR_GS +# define CHAR_GS LIBSIMPLE_CHAR_GS +#endif +#define LIBSIMPLE_CHAR_GROUP_SEPARATOR LIBSIMPLE_CHAR_GS +#ifndef CHAR_GROUP_SEPARATOR +# define CHAR_GROUP_SEPARATOR LIBSIMPLE_CHAR_GROUP_SEPARATOR +#endif + +#define LIBSIMPLE_CHAR_RS '\x1E' +#ifndef CHAR_RS +# define CHAR_RS LIBSIMPLE_CHAR_RS +#endif +#define LIBSIMPLE_CHAR_RECORD_SEPARATOR LIBSIMPLE_CHAR_RS +#ifndef CHAR_RECORD_SEPARATOR +# define CHAR_RECORD_SEPARATOR LIBSIMPLE_CHAR_RECORD_SEPARATOR +#endif + +#define LIBSIMPLE_CHAR_US '\x1F' +#ifndef CHAR_US +# define CHAR_US LIBSIMPLE_CHAR_US +#endif +#define LIBSIMPLE_CHAR_UNIT_SEPARATOR LIBSIMPLE_CHAR_US +#ifndef CHAR_UNIT_SEPARATOR +# define CHAR_UNIT_SEPARATOR LIBSIMPLE_CHAR_UNIT_SEPARATOR +#endif + +#define LIBSIMPLE_CHAR_SP '\x20' +#ifndef CHAR_SP +# define CHAR_SP LIBSIMPLE_CHAR_SP +#endif +#define LIBSIMPLE_CHAR_SPACE LIBSIMPLE_CHAR_SP +#ifndef CHAR_SPACE +# define CHAR_SPACE LIBSIMPLE_CHAR_SPACE +#endif + +#define LIBSIMPLE_CHAR_DEL '\x7F' +#ifndef CHAR_DEL +# define CHAR_DEL LIBSIMPLE_CHAR_DEL +#endif +#define LIBSIMPLE_CHAR_DELETE LIBSIMPLE_CHAR_DEL +#ifndef CHAR_DELETE +# define CHAR_DELETE LIBSIMPLE_CHAR_DELETE +#endif + + +#define LIBSIMPLE_STR_CHAR_NUL "\x00" +#ifndef STR_CHAR_NUL +# define STR_CHAR_NUL LIBSIMPLE_STR_CHAR_NUL +#endif +#define LIBSIMPLE_STR_CHAR_NULL LIBSIMPLE_STR_CHAR_NUL +#ifndef STR_CHAR_NULL +# define STR_CHAR_NULL LIBSIMPLE_STR_CHAR_NULL +#endif + +#define LIBSIMPLE_STR_CHAR_SOH "\x01" +#ifndef STR_CHAR_SOH +# define STR_CHAR_SOH LIBSIMPLE_STR_CHAR_SOH +#endif +#define LIBSIMPLE_STR_CHAR_START_OF_HEADING LIBSIMPLE_STR_CHAR_SOH +#ifndef STR_CHAR_START_OF_HEADING +# define STR_CHAR_START_OF_HEADING LIBSIMPLE_STR_CHAR_START_OF_HEADING +#endif + +#define LIBSIMPLE_STR_CHAR_STX "\x02" +#ifndef STR_CHAR_STX +# define STR_CHAR_STX LIBSIMPLE_STR_CHAR_STX +#endif +#define LIBSIMPLE_STR_CHAR_START_OF_TEXT LIBSIMPLE_STR_CHAR_STX +#ifndef STR_CHAR_START_OF_TEXT +# define STR_CHAR_START_OF_TEXT LIBSIMPLE_STR_CHAR_START_OF_TEXT +#endif + +#define LIBSIMPLE_STR_CHAR_ETX "\x03" +#ifndef STR_CHAR_ETX +# define STR_CHAR_ETX LIBSIMPLE_STR_CHAR_ETX +#endif +#define LIBSIMPLE_STR_CHAR_END_OF_TEXT LIBSIMPLE_STR_CHAR_ETX +#ifndef STR_CHAR_END_OF_TEXT +# define STR_CHAR_END_OF_TEXT LIBSIMPLE_STR_CHAR_END_OF_TEXT +#endif + +#define LIBSIMPLE_STR_CHAR_EOT "\x04" +#ifndef STR_CHAR_EOT +# define STR_CHAR_EOT LIBSIMPLE_STR_CHAR_EOT +#endif +#define LIBSIMPLE_STR_CHAR_END_OF_TRANSMISSION LIBSIMPLE_STR_CHAR_EOT +#ifndef STR_CHAR_END_OF_TRANSMISSION +# define STR_CHAR_END_OF_TRANSMISSION LIBSIMPLE_STR_CHAR_END_OF_TRANSMISSION +#endif + +#define LIBSIMPLE_STR_CHAR_ENQ "\x05" +#ifndef STR_CHAR_ENQ +# define STR_CHAR_ENQ LIBSIMPLE_STR_CHAR_ENQ +#endif +#define LIBSIMPLE_STR_CHAR_ENQUIRY LIBSIMPLE_STR_CHAR_ENQ +#ifndef STR_CHAR_ENQUIRY +# define STR_CHAR_ENQUIRY LIBSIMPLE_STR_CHAR_ENQUIRY +#endif + +#define LIBSIMPLE_STR_CHAR_ACK "\x06" +#ifndef STR_CHAR_ACK +# define STR_CHAR_ACK LIBSIMPLE_STR_CHAR_ACK +#endif +#define LIBSIMPLE_STR_CHAR_ACKNOWLEDGE LIBSIMPLE_STR_CHAR_ACK +#ifndef STR_CHAR_ACKNOWLEDGE +# define STR_CHAR_ACKNOWLEDGE LIBSIMPLE_STR_CHAR_ACKNOWLEDGE +#endif + +#define LIBSIMPLE_STR_CHAR_BEL "\x07" +#ifndef STR_CHAR_BEL +# define STR_CHAR_BEL LIBSIMPLE_STR_CHAR_BEL +#endif +#define LIBSIMPLE_STR_CHAR_BELL LIBSIMPLE_STR_CHAR_BEL +#ifndef STR_CHAR_BELL +# define STR_CHAR_BELL LIBSIMPLE_STR_CHAR_BELL +#endif + +#define LIBSIMPLE_STR_CHAR_BS "\x08" +#ifndef STR_CHAR_BS +# define STR_CHAR_BS LIBSIMPLE_STR_CHAR_BS +#endif +#define LIBSIMPLE_STR_CHAR_BACKSPACE LIBSIMPLE_STR_CHAR_BS +#ifndef STR_CHAR_BACKSPACE +# define STR_CHAR_BACKSPACE LIBSIMPLE_STR_CHAR_BACKSPACE +#endif + +#define LIBSIMPLE_STR_CHAR_HT "\x09" +#ifndef STR_CHAR_HT +# define STR_CHAR_HT LIBSIMPLE_STR_CHAR_HT +#endif +#define LIBSIMPLE_STR_CHAR_HORIZONTAL_TABULATION LIBSIMPLE_STR_CHAR_HT +#ifndef STR_CHAR_HORIZONTAL_TABULATION +# define STR_CHAR_HORIZONTAL_TABULATION LIBSIMPLE_STR_CHAR_HORIZONTAL_TABULATION +#endif + +#define LIBSIMPLE_STR_CHAR_LF "\x0A" +#ifndef STR_CHAR_LF +# define STR_CHAR_LF LIBSIMPLE_STR_CHAR_LF +#endif +#define LIBSIMPLE_STR_CHAR_LINE_FEED LIBSIMPLE_STR_CHAR_LF +#ifndef STR_CHAR_LINE_FEED +# define STR_CHAR_LINE_FEED LIBSIMPLE_STR_CHAR_LINE_FEED +#endif + +#define LIBSIMPLE_STR_CHAR_VT "\x0B" +#ifndef STR_CHAR_VT +# define STR_CHAR_VT LIBSIMPLE_STR_CHAR_VT +#endif +#define LIBSIMPLE_STR_CHAR_VERTICAL_TABULATION LIBSIMPLE_STR_CHAR_VT +#ifndef STR_CHAR_VERTICAL_TABULATION +# define STR_CHAR_VERTICAL_TABULATION LIBSIMPLE_STR_CHAR_VERTICAL_TABULATION +#endif + +#define LIBSIMPLE_STR_CHAR_FF "\x0C" +#ifndef STR_CHAR_FF +# define STR_CHAR_FF LIBSIMPLE_STR_CHAR_FF +#endif +#define LIBSIMPLE_STR_CHAR_FORM_FEED LIBSIMPLE_STR_CHAR_FF +#ifndef STR_CHAR_FORM_FEED +# define STR_CHAR_FORM_FEED LIBSIMPLE_STR_CHAR_FORM_FEED +#endif + +#define LIBSIMPLE_STR_CHAR_CR "\x0D" +#ifndef STR_CHAR_CR +# define STR_CHAR_CR LIBSIMPLE_STR_CHAR_CR +#endif +#define LIBSIMPLE_STR_CHAR_CARRIAGE_RETURN LIBSIMPLE_STR_CHAR_CR +#ifndef STR_CHAR_CARRIAGE_RETURN +# define STR_CHAR_CARRIAGE_RETURN LIBSIMPLE_STR_CHAR_CARRIAGE_RETURN +#endif + +#define LIBSIMPLE_STR_CHAR_SO "\x0E" +#ifndef STR_CHAR_SO +# define STR_CHAR_SO LIBSIMPLE_STR_CHAR_SO +#endif +#define LIBSIMPLE_STR_CHAR_SHIFT_OUT LIBSIMPLE_STR_CHAR_SO +#ifndef STR_CHAR_SHIFT_OUT +# define STR_CHAR_SHIFT_OUT LIBSIMPLE_STR_CHAR_SHIFT_OUT +#endif + +#define LIBSIMPLE_STR_CHAR_SI "\x0F" +#ifndef STR_CHAR_SI +# define STR_CHAR_SI LIBSIMPLE_STR_CHAR_SI +#endif +#define LIBSIMPLE_STR_CHAR_SHIFT_IN LIBSIMPLE_STR_CHAR_SI +#ifndef STR_CHAR_SHIFT_IN +# define STR_CHAR_SHIFT_IN LIBSIMPLE_STR_CHAR_SHIFT_IN +#endif + +#define LIBSIMPLE_STR_CHAR_DLE "\x10" +#ifndef STR_CHAR_DLE +# define STR_CHAR_DLE LIBSIMPLE_STR_CHAR_DLE +#endif +#define LIBSIMPLE_STR_CHAR_DATA_LINK_ESCAPE LIBSIMPLE_STR_CHAR_DLE +#ifndef STR_CHAR_DATA_LINK_ESCAPE +# define STR_CHAR_DATA_LINK_ESCAPE LIBSIMPLE_STR_CHAR_DATA_LINK_ESCAPE +#endif + +#define LIBSIMPLE_STR_CHAR_DC1 "\x11" +#ifndef STR_CHAR_DC1 +# define STR_CHAR_DC1 LIBSIMPLE_STR_CHAR_DC1 +#endif +#define LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_1 LIBSIMPLE_STR_CHAR_DC1 +#ifndef STR_CHAR_DEVICE_CONTROL_1 +# define STR_CHAR_DEVICE_CONTROL_1 LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_1 +#endif + +#define LIBSIMPLE_STR_CHAR_DC2 "\x12" +#ifndef STR_CHAR_DC2 +# define STR_CHAR_DC2 LIBSIMPLE_STR_CHAR_DC2 +#endif +#define LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_2 LIBSIMPLE_STR_CHAR_DC2 +#ifndef STR_CHAR_DEVICE_CONTROL_2 +# define STR_CHAR_DEVICE_CONTROL_2 LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_2 +#endif + +#define LIBSIMPLE_STR_CHAR_DC3 "\x13" +#ifndef STR_CHAR_DC3 +# define STR_CHAR_DC3 LIBSIMPLE_STR_CHAR_DC3 +#endif +#define LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_3 LIBSIMPLE_STR_CHAR_DC3 +#ifndef STR_CHAR_DEVICE_CONTROL_3 +# define STR_CHAR_DEVICE_CONTROL_3 LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_3 +#endif + +#define LIBSIMPLE_STR_CHAR_DC4 "\x14" +#ifndef STR_CHAR_DC4 +# define STR_CHAR_DC4 LIBSIMPLE_STR_CHAR_DC4 +#endif +#define LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_4 LIBSIMPLE_STR_CHAR_DC4 +#ifndef STR_CHAR_DEVICE_CONTROL_4 +# define STR_CHAR_DEVICE_CONTROL_4 LIBSIMPLE_STR_CHAR_DEVICE_CONTROL_4 +#endif + +#define LIBSIMPLE_STR_CHAR_NAK "\x15" +#ifndef STR_CHAR_NAK +# define STR_CHAR_NAK LIBSIMPLE_STR_CHAR_NAK +#endif +#define LIBSIMPLE_STR_CHAR_NEGATIVE_ACKNOWLEDGE LIBSIMPLE_STR_CHAR_NAK +#ifndef STR_CHAR_NEGATIVE_ACKNOWLEDGE +# define STR_CHAR_NEGATIVE_ACKNOWLEDGE LIBSIMPLE_STR_CHAR_NEGATIVE_ACKNOWLEDGE +#endif + +#define LIBSIMPLE_STR_CHAR_SYN "\x16" +#ifndef STR_CHAR_SYN +# define STR_CHAR_SYN LIBSIMPLE_STR_CHAR_SYN +#endif +#define LIBSIMPLE_STR_CHAR_SYNCHRONOUS_IDLE LIBSIMPLE_STR_CHAR_SYN +#ifndef STR_CHAR_SYNCHRONOUS_IDLE +# define STR_CHAR_SYNCHRONOUS_IDLE LIBSIMPLE_STR_CHAR_SYNCHRONOUS_IDLE +#endif + +#define LIBSIMPLE_STR_CHAR_ETB "\x17" +#ifndef STR_CHAR_ETB +# define STR_CHAR_ETB LIBSIMPLE_STR_CHAR_ETB +#endif +#define LIBSIMPLE_STR_CHAR_END_OF_TRANSMISSION_BLOCK LIBSIMPLE_STR_CHAR_ETB +#ifndef STR_CHAR_END_OF_TRANSMISSION_BLOCK +# define STR_CHAR_END_OF_TRANSMISSION_BLOCK LIBSIMPLE_STR_CHAR_END_OF_TRANSMISSION_BLOCK +#endif + +#define LIBSIMPLE_STR_CHAR_CAN "\x18" +#ifndef STR_CHAR_CAN +# define STR_CHAR_CAN LIBSIMPLE_STR_CHAR_CAN +#endif +#define LIBSIMPLE_STR_CHAR_CANCEL LIBSIMPLE_STR_CHAR_CAN +#ifndef STR_CHAR_CANCEL +# define STR_CHAR_CANCEL LIBSIMPLE_STR_CHAR_CANCEL +#endif + +#define LIBSIMPLE_STR_CHAR_EM "\x19" +#ifndef STR_CHAR_EM +# define STR_CHAR_EM LIBSIMPLE_STR_CHAR_EM +#endif +#define LIBSIMPLE_STR_CHAR_END_OF_MEDIUM LIBSIMPLE_STR_CHAR_EM +#ifndef STR_CHAR_END_OF_MEDIUM +# define STR_CHAR_END_OF_MEDIUM LIBSIMPLE_STR_CHAR_END_OF_MEDIUM +#endif + +#define LIBSIMPLE_STR_CHAR_SUB "\x1A" +#ifndef STR_CHAR_SUB +# define STR_CHAR_SUB LIBSIMPLE_STR_CHAR_SUB +#endif +#define LIBSIMPLE_STR_CHAR_SUBSTITUTE LIBSIMPLE_STR_CHAR_SUB +#ifndef STR_CHAR_SUBSTITUTE +# define STR_CHAR_SUBSTITUTE LIBSIMPLE_STR_CHAR_SUBSTITUTE +#endif + +#define LIBSIMPLE_STR_CHAR_ESC "\x1B" +#ifndef STR_CHAR_ESC +# define STR_CHAR_ESC LIBSIMPLE_STR_CHAR_ESC +#endif +#define LIBSIMPLE_STR_CHAR_ESCAPE LIBSIMPLE_STR_CHAR_ESC +#ifndef STR_CHAR_ESCAPE +# define STR_CHAR_ESCAPE LIBSIMPLE_STR_CHAR_ESCAPE +#endif + +#define LIBSIMPLE_STR_CHAR_FS "\x1C" +#ifndef STR_CHAR_FS +# define STR_CHAR_FS LIBSIMPLE_STR_CHAR_FS +#endif +#define LIBSIMPLE_STR_CHAR_FILE_SEPARATOR LIBSIMPLE_STR_CHAR_FS +#ifndef STR_CHAR_FILE_SEPARATOR +# define STR_CHAR_FILE_SEPARATOR LIBSIMPLE_STR_CHAR_FILE_SEPARATOR +#endif + +#define LIBSIMPLE_STR_CHAR_GS "\x1D" +#ifndef STR_CHAR_GS +# define STR_CHAR_GS LIBSIMPLE_STR_CHAR_GS +#endif +#define LIBSIMPLE_STR_CHAR_GROUP_SEPARATOR LIBSIMPLE_STR_CHAR_GS +#ifndef STR_CHAR_GROUP_SEPARATOR +# define STR_CHAR_GROUP_SEPARATOR LIBSIMPLE_STR_CHAR_GROUP_SEPARATOR +#endif + +#define LIBSIMPLE_STR_CHAR_RS "\x1E" +#ifndef STR_CHAR_RS +# define STR_CHAR_RS LIBSIMPLE_STR_CHAR_RS +#endif +#define LIBSIMPLE_STR_CHAR_RECORD_SEPARATOR LIBSIMPLE_STR_CHAR_RS +#ifndef STR_CHAR_RECORD_SEPARATOR +# define STR_CHAR_RECORD_SEPARATOR LIBSIMPLE_STR_CHAR_RECORD_SEPARATOR +#endif + +#define LIBSIMPLE_STR_CHAR_US "\x1F" +#ifndef STR_CHAR_US +# define STR_CHAR_US LIBSIMPLE_STR_CHAR_US +#endif +#define LIBSIMPLE_STR_CHAR_UNIT_SEPARATOR LIBSIMPLE_STR_CHAR_US +#ifndef STR_CHAR_UNIT_SEPARATOR +# define STR_CHAR_UNIT_SEPARATOR LIBSIMPLE_STR_CHAR_UNIT_SEPARATOR +#endif + +#define LIBSIMPLE_STR_CHAR_SP "\x20" +#ifndef STR_CHAR_SP +# define STR_CHAR_SP LIBSIMPLE_STR_CHAR_SP +#endif +#define LIBSIMPLE_STR_CHAR_SPACE LIBSIMPLE_STR_CHAR_SP +#ifndef STR_CHAR_SPACE +# define STR_CHAR_SPACE LIBSIMPLE_STR_CHAR_SPACE +#endif + +#define LIBSIMPLE_STR_CHAR_DEL "\x7F" +#ifndef STR_CHAR_DEL +# define STR_CHAR_DEL LIBSIMPLE_STR_CHAR_DEL +#endif +#define LIBSIMPLE_STR_CHAR_DELETE LIBSIMPLE_STR_CHAR_DEL +#ifndef STR_CHAR_DELETE +# define STR_CHAR_DELETE LIBSIMPLE_STR_CHAR_DELETE +#endif + + +#define LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, ABBR, FULL, NAME)\ + X(LIBSIMPLE_CHAR_##ABBR, LIBSIMPLE_STR_CHAR_##ABBR, #ABBR, ABBR, #FULL, FULL, NAME) + +#define LIBSIMPLE_LIST_ASCII_CONTROL_CHARS(X, D)\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, NUL, NULL, "null") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, SOH, START_OF_HEADING, "start of heading") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, STX, START_OF_TEXT, "start of text") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, ETX, END_OF_TEXT, "end of text") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, EOT, END_OF_TRANSMISSION, "end of transmission") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, ENQ, ENQUIRY, "enquiry") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, ACK, ACKNOWLEDGE, "acknowledge") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, BEL, BELL, "bell") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, BS, BACKSPACE, "backspace") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, HT, HORIZONTAL_TABULATION, "horizontal tabulation") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, LF, LINE_FEED, "line feed") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, VT, VERTICAL_TABULATION, "vertical tabulation") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, FF, FORM_FEED, "form feed") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, CR, CARRIAGE_RETURN, "carriage return") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, SO, SHIFT_OUT, "shift out") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, SI, SHIFT_IN, "shift in") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, DLE, DATA_LINK_ESCAPE, "data link escape") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, DC1, DEVICE_CONTROL_1, "device control 1") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, DC2, DEVICE_CONTROL_2, "device control 2") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, DC3, DEVICE_CONTROL_3, "device control 3") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, DC4, DEVICE_CONTROL_4, "device control 4") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, NAK, NEGATIVE_ACKNOWLEDGE, "negative acknowledge") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, SYN, SYNCHRONOUS_IDLE, "synchronous idle") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, ETB, END_OF_TRANSMISSION_BLOCK, "end of transmission block") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, CAN, CANCEL, "cancel") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, EM, END_OF_MEDIUM, "end of medium") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, SUB, SUBSTITUTE, "substitute") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, ESC, ESCAPE, "escape") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, FS, FILE_SEPARATOR, "file separator") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, GS, GROUP_SEPARATOR, "group separator") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, RS, RECORD_SEPARATOR, "record separator") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, US, UNIT_SEPARATOR, "unit separator") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, SP, SPACE, "space") D\ + LIBSIMPLE_LIST_ASCII_CONTROL_CHARS__(X, DEL, DELETE, "delete") diff --git a/libsimple/env.h b/libsimple/env.h index 98a3d9f..a39ae2a 100644 --- a/libsimple/env.h +++ b/libsimple/env.h @@ -194,3 +194,10 @@ libsimple_eputenvf(const char *fmt__, ...) #ifndef eputenvf # define eputenvf libsimple_eputenvf #endif + + +/* + * TODO add getenv_first, getenv_first_ne, getenv_first_e + * TODO add getenv_last, getenv_last_ne, getenv_last_e + * TODO add unsetenv_first, unsetenv_last, unsetenv_each + */ diff --git a/libsimple/exec.h b/libsimple/exec.h new file mode 100644 index 0000000..bc61628 --- /dev/null +++ b/libsimple/exec.h @@ -0,0 +1,99 @@ +/* See LICENSE file for copyright and license details. */ + +/* TODO man, doc, test */ + + +const char *libsimple_which(const char *file, int cwdfd, const char *path, char **free_this_out); + +int libsimple_xexecv(int dirfd, const char *file, int atflags, const char *path, char *const *envp, char *const *argv); + +int libsimple_vxexecl(int dirfd, const char *file, int atflags, const char *path, char *const *envp, va_list argv_null); + +int libsimple_xexecl(int dirfd, const char *file, int atflags, const char *path, char *const *envp, ... /* argv, NULL */); + +int libsimple_vxexecle(int dirfd, const char *file, int atflags, const char *path, va_list argv_null_envp); + +int libsimple_execlpe(const char *file, ... /* argv, NULL, char *const envp[] */); +#ifndef execlpe +# define execlpe libsimple_execlpe +#endif + +int libsimple_vexecl(const char *pathname, va_list argv_null); +#ifndef vexecl +# define vexecl libsimple_vexecl +#endif + +int libsimple_vexecle(const char *pathname, va_list argv_null_envp); +#ifndef vexecle +# define vexecle libsimple_vexecle +#endif + +int libsimple_vexeclp(const char *file, va_list argv_null); +#ifndef vexeclp +# define vexeclp libsimple_vexeclp +#endif + +int libsimple_vexeclpe(const char *file, va_list argv_null_envp); +#ifndef vexeclpe +# define vexeclpe libsimple_vexeclpe +#endif + +int libsimple_execvpe(const char *file, char *const argv[], char *const envp[]); +#ifndef execvpe +# define execvpe libsimple_execvpe +#endif + +int libsimple_vfexecl(int fd, va_list argv_null); +#ifndef vfexecl +# define vfexecl libsimple_vfexecl +#endif + +int libsimple_vfexecle(int fd, va_list argv_null_envp); +#ifndef vfexecle +# define vfexecle libsimple_vfexecle +#endif + +int libsimple_fexecl(int fd, ... /* argv, NULL */); +#ifndef fexecl +# define fexecl libsimple_fexecl +#endif + +int libsimple_fexecle(int fd, ... /* argv, NULL, char *const envp[] */); +#ifndef fexecle +# define fexecle libsimple_fexecle +#endif + +int libsimple_fexecv(int fd, char *const argv[]); +#ifndef fexecv +# define fexecv libsimple_fexecv +#endif + +int libsimple_execveat(int dirfd, const char *pathname, char *const argv[], char *const envp[], int flags); +#ifndef execveat +# define execveat libsimple_execveat +#endif + +int libsimple_execvat(int dirfd, const char *pathname, char *const argv[], int flags); +#ifndef execvat +# define execvat libsimple_execvat +#endif + +int libsimple_execleat(int dirfd, const char *pathname, ... /* argv, NULL, char *const envp[], int flags */); +#ifndef execleat +# define execleat libsimple_execleat +#endif + +int libsimple_execlat(int dirfd, const char *pathname, ... /* argv, NULL, int flags */); +#ifndef execlat +# define execlat libsimple_execlat +#endif + +int libsimple_vexecleat(int dirfd, const char *pathname, va_list argv_null_envp_flags); +#ifndef vexecleat +# define vexecleat libsimple_execlpe +#endif + +int libsimple_vexeclat(int dirfd, const char *pathname, va_list argv_null_flags); +#ifndef vexeclat +# define vexeclat libsimple_vexeclat +#endif diff --git a/vexecl.c b/vexecl.c new file mode 100644 index 0000000..50649ed --- /dev/null +++ b/vexecl.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vexecl(const char *pathname, va_list argv_null) +{ + return libsimple_vxexecl(-1, pathname, -1, "", environ, argv_null); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vexeclat.c b/vexeclat.c new file mode 100644 index 0000000..97983d1 --- /dev/null +++ b/vexeclat.c @@ -0,0 +1,28 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vexeclat(int dirfd, const char *pathname, va_list argv_null_flags) +{ + int flags; + va_list args; + va_copy(args, argv_null_flags); + while (va_arg(args, char *)); + flags = va_arg(args, int); + va_end(args); + return libsimple_vxexecl(dirfd, pathname, flags, NULL, environ, argv_null_flags); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vexecle.c b/vexecle.c new file mode 100644 index 0000000..2094bc1 --- /dev/null +++ b/vexecle.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vexecle(const char *pathname, va_list argv_null_envp) +{ + return libsimple_vxexecle(-1, pathname, -1, "", argv_null_envp); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vexecleat.c b/vexecleat.c new file mode 100644 index 0000000..f9bda0e --- /dev/null +++ b/vexecleat.c @@ -0,0 +1,30 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vexecleat(int dirfd, const char *pathname, va_list argv_null_envp_flags) +{ + char *const *envp; + int flags; + va_list args; + va_copy(args, argv_null_envp_flags); + while (va_arg(args, char *)); + envp = va_arg(args, char *const *); + flags = va_arg(args, int); + va_end(args); + return libsimple_vxexecl(dirfd, pathname, flags, NULL, envp, argv_null_envp_flags); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vexeclp.c b/vexeclp.c new file mode 100644 index 0000000..a1d6f1f --- /dev/null +++ b/vexeclp.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vexeclp(const char *file, va_list argv_null) +{ + return libsimple_vxexecl(-1, file, -1, NULL, environ, argv_null); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vexeclpe.c b/vexeclpe.c new file mode 100644 index 0000000..5951fc9 --- /dev/null +++ b/vexeclpe.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vexeclpe(const char *file, va_list argv_null_envp) +{ + return libsimple_vxexecle(-1, file, -1, NULL, argv_null_envp); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vfexecl.c b/vfexecl.c new file mode 100644 index 0000000..dd66b87 --- /dev/null +++ b/vfexecl.c @@ -0,0 +1,22 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vfexecl(int fd, va_list argv_null) +{ + return libsimple_vxexecl(fd, "", AT_EMPTY_PATH, "", environ, argv_null); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vfexecle.c b/vfexecle.c new file mode 100644 index 0000000..31ee602 --- /dev/null +++ b/vfexecle.c @@ -0,0 +1,28 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vfexecle(int fd, va_list argv_null_envp) +{ + char *const *envp; + va_list args; + va_copy(args, argv_null_envp); + while (va_arg(args, char *)); + envp = va_arg(args, char *const *); + va_end(args); + return libsimple_vxexecl(fd, "", AT_EMPTY_PATH, "", envp, argv_null_envp); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vxexecl.c b/vxexecl.c new file mode 100644 index 0000000..c8282a6 --- /dev/null +++ b/vxexecl.c @@ -0,0 +1,35 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vxexecl(int dirfd, const char *file, int atflags, const char *path, char *const *envp, va_list argv_null) +{ + char **argv; + size_t argc = 0; + va_list args; + va_copy(args, argv_null); + do { + argc += 1; + } while (va_arg(args, char *)); + va_end(args); + argv = alloca((argc + 1) * sizeof(*argv)); + argc = 0; + do { + argv[argc] = va_arg(args, char *); + } while (argv[argc++]); + return libsimple_xexecv(dirfd, file, atflags, path, envp, argv); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/vxexecle.c b/vxexecle.c new file mode 100644 index 0000000..61415ef --- /dev/null +++ b/vxexecle.c @@ -0,0 +1,28 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_vxexecle(int dirfd, const char *file, int atflags, const char *path, va_list argv_null_envp) +{ + char *const *envp; + va_list args; + va_copy(args, argv_null_envp); + while (va_arg(args, char *)); + envp = va_arg(args, char *const *); + va_end(args); + return libsimple_vxexecl(dirfd, file, atflags, path, envp, argv_null_envp); +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/which.c b/which.c new file mode 100644 index 0000000..96a3ece --- /dev/null +++ b/which.c @@ -0,0 +1,92 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +const char * +libsimple_which(const char *file, int cwdfd, const char *path, char **free_this_out) +{ + const char *p, *q; + char *buf = NULL; + size_t bufsize, len, filelen; + int got_eacces = 0, saved_errno = errno; + + free_this_out = NULL; + + if (!file || !free_this_out) { + errno = EINVAL; + return NULL; + } + + if (strchr(file, '/')) + return file; + + if (!path) { + path = getenv("PATH"); + if (!path) + path = ""; + } + if (!*path) { + errno = ENOENT; + return NULL; + } + + bufsize = 0; + for (p = path; p; p = q) { + q = strchr(p, ':'); + if (q) + len = (size_t)(q++ - p); + else + len = strlen(p); + if (len > bufsize) + bufsize = len; + } + if (bufsize) { + filelen = strlen(file) + 1U; + bufsize += 1U + filelen; + buf = malloc(bufsize); + if (!buf) + return NULL; + } + + for (p = path; p; p = q) { + q = strchr(p, ':'); + if (q) + len = (size_t)(q++ - p); + else + len = strlen(p); + if (len) { + memcpy(buf, p, len); + buf[len] = '/'; + memcpy(&buf[len + 1], file, filelen); + if (!faccessat(cwdfd, buf, X_OK, AT_EACCESS)) { + *free_this_out = buf; + errno = saved_errno; + return buf; + } + } else { + if (!faccessat(cwdfd, file, X_OK, AT_EACCESS)) { + errno = saved_errno; + return file; + } + } + if (errno == EACCES) + got_eacces = 1; + } + + free(buf); + errno = got_eacces ? EACCES : ENOENT; + return NULL; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/xexecl.c b/xexecl.c new file mode 100644 index 0000000..fa46725 --- /dev/null +++ b/xexecl.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_xexecl(int dirfd, const char *file, int atflags, const char *path, char *const *envp, ... /* argv, NULL */) +{ + int ret; + va_list args; + va_start(args, envp); + ret = libsimple_vxexecl(dirfd, file, atflags, path, envp, args); + va_end(args); + return ret; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/xexecv.c b/xexecv.c new file mode 100644 index 0000000..68fd264 --- /dev/null +++ b/xexecv.c @@ -0,0 +1,31 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +int +libsimple_xexecv(int dirfd, const char *file, int atflags, const char *path, char *const *envp, char *const *argv) +{ + char *free_this; + int ret; + if (dirfd == -1 && atflags == -1) { + file = libsimple_which(file, AT_FDCWD, path, &free_this); + ret = execve(file, argv, envp); + free(free_this); + return ret; + } else { + return execveat(dirfd, file, argv, envp, atflags); + } +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif -- cgit v1.2.3-70-g09d2 From b663b8ca0207d7e3b9bd84a69e6090133a8d0ce1 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sun, 5 May 2024 20:50:12 +0200 Subject: Add libsimple_{cmp,qsort}_* MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 577 +++++++++++++ cmp_doublep.c | 18 + cmp_doublepp.c | 18 + cmp_doublepp_nul.c | 18 + cmp_floatp.c | 18 + cmp_floatpp.c | 18 + cmp_floatpp_nul.c | 18 + cmp_int16p.c | 18 + cmp_int16pp.c | 18 + cmp_int16pp_nul.c | 18 + cmp_int32p.c | 18 + cmp_int32pp.c | 18 + cmp_int32pp_nul.c | 18 + cmp_int64p.c | 18 + cmp_int64pp.c | 18 + cmp_int64pp_nul.c | 18 + cmp_int8p.c | 18 + cmp_int8pp.c | 18 + cmp_int8pp_nul.c | 18 + cmp_int_least16p.c | 18 + cmp_int_least16pp.c | 18 + cmp_int_least16pp_nul.c | 18 + cmp_int_least32p.c | 18 + cmp_int_least32pp.c | 18 + cmp_int_least32pp_nul.c | 18 + cmp_int_least64p.c | 18 + cmp_int_least64pp.c | 18 + cmp_int_least64pp_nul.c | 18 + cmp_int_least8p.c | 18 + cmp_int_least8pp.c | 18 + cmp_int_least8pp_nul.c | 18 + cmp_intmaxp.c | 18 + cmp_intmaxpp.c | 18 + cmp_intmaxpp_nul.c | 18 + cmp_intp.c | 18 + cmp_intpp.c | 18 + cmp_intpp_nul.c | 18 + cmp_intptrp.c | 18 + cmp_intptrpp.c | 18 + cmp_intptrpp_nul.c | 18 + cmp_llongp.c | 18 + cmp_llongpp.c | 18 + cmp_llongpp_nul.c | 18 + cmp_longp.c | 18 + cmp_longpp.c | 18 + cmp_longpp_nul.c | 18 + cmp_nul_doublepp.c | 18 + cmp_nul_floatpp.c | 18 + cmp_nul_int16pp.c | 18 + cmp_nul_int32pp.c | 18 + cmp_nul_int64pp.c | 18 + cmp_nul_int8pp.c | 18 + cmp_nul_int_least16pp.c | 18 + cmp_nul_int_least32pp.c | 18 + cmp_nul_int_least64pp.c | 18 + cmp_nul_int_least8pp.c | 18 + cmp_nul_intmaxpp.c | 18 + cmp_nul_intpp.c | 18 + cmp_nul_intptrpp.c | 18 + cmp_nul_llongpp.c | 18 + cmp_nul_longpp.c | 18 + cmp_nul_ptrdiffpp.c | 18 + cmp_nul_rev_doublepp.c | 18 + cmp_nul_rev_floatpp.c | 18 + cmp_nul_rev_int16pp.c | 18 + cmp_nul_rev_int32pp.c | 18 + cmp_nul_rev_int64pp.c | 18 + cmp_nul_rev_int8pp.c | 18 + cmp_nul_rev_int_least16pp.c | 18 + cmp_nul_rev_int_least32pp.c | 18 + cmp_nul_rev_int_least64pp.c | 18 + cmp_nul_rev_int_least8pp.c | 18 + cmp_nul_rev_intmaxpp.c | 18 + cmp_nul_rev_intpp.c | 18 + cmp_nul_rev_intptrpp.c | 18 + cmp_nul_rev_llongpp.c | 18 + cmp_nul_rev_longpp.c | 18 + cmp_nul_rev_ptrdiffpp.c | 18 + cmp_nul_rev_scharpp.c | 18 + cmp_nul_rev_shortpp.c | 18 + cmp_nul_rev_sizepp.c | 18 + cmp_nul_rev_ssizepp.c | 18 + cmp_nul_rev_strpp.c | 18 + cmp_nul_rev_ucharpp.c | 18 + cmp_nul_rev_uint16pp.c | 18 + cmp_nul_rev_uint32pp.c | 18 + cmp_nul_rev_uint64pp.c | 18 + cmp_nul_rev_uint8pp.c | 18 + cmp_nul_rev_uint_least16pp.c | 18 + cmp_nul_rev_uint_least32pp.c | 18 + cmp_nul_rev_uint_least64pp.c | 18 + cmp_nul_rev_uint_least8pp.c | 18 + cmp_nul_rev_uintmaxpp.c | 18 + cmp_nul_rev_uintpp.c | 18 + cmp_nul_rev_uintptrpp.c | 18 + cmp_nul_rev_ullongpp.c | 18 + cmp_nul_rev_ulongpp.c | 18 + cmp_nul_rev_ushortpp.c | 18 + cmp_nul_scharpp.c | 18 + cmp_nul_shortpp.c | 18 + cmp_nul_sizepp.c | 18 + cmp_nul_ssizepp.c | 18 + cmp_nul_strpp.c | 18 + cmp_nul_ucharpp.c | 18 + cmp_nul_uint16pp.c | 18 + cmp_nul_uint32pp.c | 18 + cmp_nul_uint64pp.c | 18 + cmp_nul_uint8pp.c | 18 + cmp_nul_uint_least16pp.c | 18 + cmp_nul_uint_least32pp.c | 18 + cmp_nul_uint_least64pp.c | 18 + cmp_nul_uint_least8pp.c | 18 + cmp_nul_uintmaxpp.c | 18 + cmp_nul_uintpp.c | 18 + cmp_nul_uintptrpp.c | 18 + cmp_nul_ullongpp.c | 18 + cmp_nul_ulongpp.c | 18 + cmp_nul_ushortpp.c | 18 + cmp_ptrdiffp.c | 18 + cmp_ptrdiffpp.c | 18 + cmp_ptrdiffpp_nul.c | 18 + cmp_rev_doublep.c | 18 + cmp_rev_doublepp.c | 18 + cmp_rev_doublepp_nul.c | 18 + cmp_rev_floatp.c | 18 + cmp_rev_floatpp.c | 18 + cmp_rev_floatpp_nul.c | 18 + cmp_rev_int16p.c | 18 + cmp_rev_int16pp.c | 18 + cmp_rev_int16pp_nul.c | 18 + cmp_rev_int32p.c | 18 + cmp_rev_int32pp.c | 18 + cmp_rev_int32pp_nul.c | 18 + cmp_rev_int64p.c | 18 + cmp_rev_int64pp.c | 18 + cmp_rev_int64pp_nul.c | 18 + cmp_rev_int8p.c | 18 + cmp_rev_int8pp.c | 18 + cmp_rev_int8pp_nul.c | 18 + cmp_rev_int_least16p.c | 18 + cmp_rev_int_least16pp.c | 18 + cmp_rev_int_least16pp_nul.c | 18 + cmp_rev_int_least32p.c | 18 + cmp_rev_int_least32pp.c | 18 + cmp_rev_int_least32pp_nul.c | 18 + cmp_rev_int_least64p.c | 18 + cmp_rev_int_least64pp.c | 18 + cmp_rev_int_least64pp_nul.c | 18 + cmp_rev_int_least8p.c | 18 + cmp_rev_int_least8pp.c | 18 + cmp_rev_int_least8pp_nul.c | 18 + cmp_rev_intmaxp.c | 18 + cmp_rev_intmaxpp.c | 18 + cmp_rev_intmaxpp_nul.c | 18 + cmp_rev_intp.c | 18 + cmp_rev_intpp.c | 18 + cmp_rev_intpp_nul.c | 18 + cmp_rev_intptrp.c | 18 + cmp_rev_intptrpp.c | 18 + cmp_rev_intptrpp_nul.c | 18 + cmp_rev_llongp.c | 18 + cmp_rev_llongpp.c | 18 + cmp_rev_llongpp_nul.c | 18 + cmp_rev_longp.c | 18 + cmp_rev_longpp.c | 18 + cmp_rev_longpp_nul.c | 18 + cmp_rev_ptrdiffp.c | 18 + cmp_rev_ptrdiffpp.c | 18 + cmp_rev_ptrdiffpp_nul.c | 18 + cmp_rev_scharp.c | 18 + cmp_rev_scharpp.c | 18 + cmp_rev_scharpp_nul.c | 18 + cmp_rev_shortp.c | 18 + cmp_rev_shortpp.c | 18 + cmp_rev_shortpp_nul.c | 18 + cmp_rev_sizep.c | 18 + cmp_rev_sizepp.c | 18 + cmp_rev_sizepp_nul.c | 18 + cmp_rev_ssizep.c | 18 + cmp_rev_ssizepp.c | 18 + cmp_rev_ssizepp_nul.c | 18 + cmp_rev_strp.c | 18 + cmp_rev_strpp.c | 18 + cmp_rev_strpp_nul.c | 18 + cmp_rev_ucharp.c | 18 + cmp_rev_ucharpp.c | 18 + cmp_rev_ucharpp_nul.c | 18 + cmp_rev_uint16p.c | 18 + cmp_rev_uint16pp.c | 18 + cmp_rev_uint16pp_nul.c | 18 + cmp_rev_uint32p.c | 18 + cmp_rev_uint32pp.c | 18 + cmp_rev_uint32pp_nul.c | 18 + cmp_rev_uint64p.c | 18 + cmp_rev_uint64pp.c | 18 + cmp_rev_uint64pp_nul.c | 18 + cmp_rev_uint8p.c | 18 + cmp_rev_uint8pp.c | 18 + cmp_rev_uint8pp_nul.c | 18 + cmp_rev_uint_least16p.c | 18 + cmp_rev_uint_least16pp.c | 18 + cmp_rev_uint_least16pp_nul.c | 18 + cmp_rev_uint_least32p.c | 18 + cmp_rev_uint_least32pp.c | 18 + cmp_rev_uint_least32pp_nul.c | 18 + cmp_rev_uint_least64p.c | 18 + cmp_rev_uint_least64pp.c | 18 + cmp_rev_uint_least64pp_nul.c | 18 + cmp_rev_uint_least8p.c | 18 + cmp_rev_uint_least8pp.c | 18 + cmp_rev_uint_least8pp_nul.c | 18 + cmp_rev_uintmaxp.c | 18 + cmp_rev_uintmaxpp.c | 18 + cmp_rev_uintmaxpp_nul.c | 18 + cmp_rev_uintp.c | 18 + cmp_rev_uintpp.c | 18 + cmp_rev_uintpp_nul.c | 18 + cmp_rev_uintptrp.c | 18 + cmp_rev_uintptrpp.c | 18 + cmp_rev_uintptrpp_nul.c | 18 + cmp_rev_ullongp.c | 18 + cmp_rev_ullongpp.c | 18 + cmp_rev_ullongpp_nul.c | 18 + cmp_rev_ulongp.c | 18 + cmp_rev_ulongpp.c | 18 + cmp_rev_ulongpp_nul.c | 18 + cmp_rev_ushortp.c | 18 + cmp_rev_ushortpp.c | 18 + cmp_rev_ushortpp_nul.c | 18 + cmp_scharp.c | 18 + cmp_scharpp.c | 18 + cmp_scharpp_nul.c | 18 + cmp_shortp.c | 18 + cmp_shortpp.c | 18 + cmp_shortpp_nul.c | 18 + cmp_sizep.c | 18 + cmp_sizepp.c | 18 + cmp_sizepp_nul.c | 18 + cmp_ssizep.c | 18 + cmp_ssizepp.c | 18 + cmp_ssizepp_nul.c | 18 + cmp_strp.c | 18 + cmp_strpp.c | 18 + cmp_strpp_nul.c | 18 + cmp_ucharp.c | 18 + cmp_ucharpp.c | 18 + cmp_ucharpp_nul.c | 18 + cmp_uint16p.c | 18 + cmp_uint16pp.c | 18 + cmp_uint16pp_nul.c | 18 + cmp_uint32p.c | 18 + cmp_uint32pp.c | 18 + cmp_uint32pp_nul.c | 18 + cmp_uint64p.c | 18 + cmp_uint64pp.c | 18 + cmp_uint64pp_nul.c | 18 + cmp_uint8p.c | 18 + cmp_uint8pp.c | 18 + cmp_uint8pp_nul.c | 18 + cmp_uint_least16p.c | 18 + cmp_uint_least16pp.c | 18 + cmp_uint_least16pp_nul.c | 18 + cmp_uint_least32p.c | 18 + cmp_uint_least32pp.c | 18 + cmp_uint_least32pp_nul.c | 18 + cmp_uint_least64p.c | 18 + cmp_uint_least64pp.c | 18 + cmp_uint_least64pp_nul.c | 18 + cmp_uint_least8p.c | 18 + cmp_uint_least8pp.c | 18 + cmp_uint_least8pp_nul.c | 18 + cmp_uintmaxp.c | 18 + cmp_uintmaxpp.c | 18 + cmp_uintmaxpp_nul.c | 18 + cmp_uintp.c | 18 + cmp_uintpp.c | 18 + cmp_uintpp_nul.c | 18 + cmp_uintptrp.c | 18 + cmp_uintptrpp.c | 18 + cmp_uintptrpp_nul.c | 18 + cmp_ullongp.c | 18 + cmp_ullongpp.c | 18 + cmp_ullongpp_nul.c | 18 + cmp_ulongp.c | 18 + cmp_ulongpp.c | 18 + cmp_ulongpp_nul.c | 18 + cmp_ushortp.c | 18 + cmp_ushortpp.c | 18 + cmp_ushortpp_nul.c | 18 + libsimple.h | 1 + libsimple/sort.h | 1865 +++++++++++++++++++++++++++++++++++++++++ qsort_double.c | 18 + qsort_doublep.c | 18 + qsort_doublep_nul.c | 18 + qsort_float.c | 18 + qsort_floatp.c | 18 + qsort_floatp_nul.c | 18 + qsort_int.c | 18 + qsort_int16.c | 18 + qsort_int16p.c | 18 + qsort_int16p_nul.c | 18 + qsort_int32.c | 18 + qsort_int32p.c | 18 + qsort_int32p_nul.c | 18 + qsort_int64.c | 18 + qsort_int64p.c | 18 + qsort_int64p_nul.c | 18 + qsort_int8.c | 18 + qsort_int8p.c | 18 + qsort_int8p_nul.c | 18 + qsort_int_least16.c | 18 + qsort_int_least16p.c | 18 + qsort_int_least16p_nul.c | 18 + qsort_int_least32.c | 18 + qsort_int_least32p.c | 18 + qsort_int_least32p_nul.c | 18 + qsort_int_least64.c | 18 + qsort_int_least64p.c | 18 + qsort_int_least64p_nul.c | 18 + qsort_int_least8.c | 18 + qsort_int_least8p.c | 18 + qsort_int_least8p_nul.c | 18 + qsort_intmax.c | 18 + qsort_intmaxp.c | 18 + qsort_intmaxp_nul.c | 18 + qsort_intp.c | 18 + qsort_intp_nul.c | 18 + qsort_intptr.c | 18 + qsort_intptrp.c | 18 + qsort_intptrp_nul.c | 18 + qsort_llong.c | 18 + qsort_llongp.c | 18 + qsort_llongp_nul.c | 18 + qsort_long.c | 18 + qsort_longp.c | 18 + qsort_longp_nul.c | 18 + qsort_nul_doublep.c | 18 + qsort_nul_floatp.c | 18 + qsort_nul_int16p.c | 18 + qsort_nul_int32p.c | 18 + qsort_nul_int64p.c | 18 + qsort_nul_int8p.c | 18 + qsort_nul_int_least16p.c | 18 + qsort_nul_int_least32p.c | 18 + qsort_nul_int_least64p.c | 18 + qsort_nul_int_least8p.c | 18 + qsort_nul_intmaxp.c | 18 + qsort_nul_intp.c | 18 + qsort_nul_intptrp.c | 18 + qsort_nul_llongp.c | 18 + qsort_nul_longp.c | 18 + qsort_nul_ptrdiffp.c | 18 + qsort_nul_rev_doublep.c | 18 + qsort_nul_rev_floatp.c | 18 + qsort_nul_rev_int16p.c | 18 + qsort_nul_rev_int32p.c | 18 + qsort_nul_rev_int64p.c | 18 + qsort_nul_rev_int8p.c | 18 + qsort_nul_rev_int_least16p.c | 18 + qsort_nul_rev_int_least32p.c | 18 + qsort_nul_rev_int_least64p.c | 18 + qsort_nul_rev_int_least8p.c | 18 + qsort_nul_rev_intmaxp.c | 18 + qsort_nul_rev_intp.c | 18 + qsort_nul_rev_intptrp.c | 18 + qsort_nul_rev_llongp.c | 18 + qsort_nul_rev_longp.c | 18 + qsort_nul_rev_ptrdiffp.c | 18 + qsort_nul_rev_scharp.c | 18 + qsort_nul_rev_shortp.c | 18 + qsort_nul_rev_sizep.c | 18 + qsort_nul_rev_ssizep.c | 18 + qsort_nul_rev_strp.c | 18 + qsort_nul_rev_ucharp.c | 18 + qsort_nul_rev_uint16p.c | 18 + qsort_nul_rev_uint32p.c | 18 + qsort_nul_rev_uint64p.c | 18 + qsort_nul_rev_uint8p.c | 18 + qsort_nul_rev_uint_least16p.c | 18 + qsort_nul_rev_uint_least32p.c | 18 + qsort_nul_rev_uint_least64p.c | 18 + qsort_nul_rev_uint_least8p.c | 18 + qsort_nul_rev_uintmaxp.c | 18 + qsort_nul_rev_uintp.c | 18 + qsort_nul_rev_uintptrp.c | 18 + qsort_nul_rev_ullongp.c | 18 + qsort_nul_rev_ulongp.c | 18 + qsort_nul_rev_ushortp.c | 18 + qsort_nul_scharp.c | 18 + qsort_nul_shortp.c | 18 + qsort_nul_sizep.c | 18 + qsort_nul_ssizep.c | 18 + qsort_nul_strp.c | 18 + qsort_nul_ucharp.c | 18 + qsort_nul_uint16p.c | 18 + qsort_nul_uint32p.c | 18 + qsort_nul_uint64p.c | 18 + qsort_nul_uint8p.c | 18 + qsort_nul_uint_least16p.c | 18 + qsort_nul_uint_least32p.c | 18 + qsort_nul_uint_least64p.c | 18 + qsort_nul_uint_least8p.c | 18 + qsort_nul_uintmaxp.c | 18 + qsort_nul_uintp.c | 18 + qsort_nul_uintptrp.c | 18 + qsort_nul_ullongp.c | 18 + qsort_nul_ulongp.c | 18 + qsort_nul_ushortp.c | 18 + qsort_ptrdiff.c | 18 + qsort_ptrdiffp.c | 18 + qsort_ptrdiffp_nul.c | 18 + qsort_rev_double.c | 18 + qsort_rev_doublep.c | 18 + qsort_rev_doublep_nul.c | 18 + qsort_rev_float.c | 18 + qsort_rev_floatp.c | 18 + qsort_rev_floatp_nul.c | 18 + qsort_rev_int.c | 18 + qsort_rev_int16.c | 18 + qsort_rev_int16p.c | 18 + qsort_rev_int16p_nul.c | 18 + qsort_rev_int32.c | 18 + qsort_rev_int32p.c | 18 + qsort_rev_int32p_nul.c | 18 + qsort_rev_int64.c | 18 + qsort_rev_int64p.c | 18 + qsort_rev_int64p_nul.c | 18 + qsort_rev_int8.c | 18 + qsort_rev_int8p.c | 18 + qsort_rev_int8p_nul.c | 18 + qsort_rev_int_least16.c | 18 + qsort_rev_int_least16p.c | 18 + qsort_rev_int_least16p_nul.c | 18 + qsort_rev_int_least32.c | 18 + qsort_rev_int_least32p.c | 18 + qsort_rev_int_least32p_nul.c | 18 + qsort_rev_int_least64.c | 18 + qsort_rev_int_least64p.c | 18 + qsort_rev_int_least64p_nul.c | 18 + qsort_rev_int_least8.c | 18 + qsort_rev_int_least8p.c | 18 + qsort_rev_int_least8p_nul.c | 18 + qsort_rev_intmax.c | 18 + qsort_rev_intmaxp.c | 18 + qsort_rev_intmaxp_nul.c | 18 + qsort_rev_intp.c | 18 + qsort_rev_intp_nul.c | 18 + qsort_rev_intptr.c | 18 + qsort_rev_intptrp.c | 18 + qsort_rev_intptrp_nul.c | 18 + qsort_rev_llong.c | 18 + qsort_rev_llongp.c | 18 + qsort_rev_llongp_nul.c | 18 + qsort_rev_long.c | 18 + qsort_rev_longp.c | 18 + qsort_rev_longp_nul.c | 18 + qsort_rev_ptrdiff.c | 18 + qsort_rev_ptrdiffp.c | 18 + qsort_rev_ptrdiffp_nul.c | 18 + qsort_rev_schar.c | 18 + qsort_rev_scharp.c | 18 + qsort_rev_scharp_nul.c | 18 + qsort_rev_short.c | 18 + qsort_rev_shortp.c | 18 + qsort_rev_shortp_nul.c | 18 + qsort_rev_size.c | 18 + qsort_rev_sizep.c | 18 + qsort_rev_sizep_nul.c | 18 + qsort_rev_ssize.c | 18 + qsort_rev_ssizep.c | 18 + qsort_rev_ssizep_nul.c | 18 + qsort_rev_str.c | 18 + qsort_rev_strp.c | 18 + qsort_rev_strp_nul.c | 18 + qsort_rev_uchar.c | 18 + qsort_rev_ucharp.c | 18 + qsort_rev_ucharp_nul.c | 18 + qsort_rev_uint.c | 18 + qsort_rev_uint16.c | 18 + qsort_rev_uint16p.c | 18 + qsort_rev_uint16p_nul.c | 18 + qsort_rev_uint32.c | 18 + qsort_rev_uint32p.c | 18 + qsort_rev_uint32p_nul.c | 18 + qsort_rev_uint64.c | 18 + qsort_rev_uint64p.c | 18 + qsort_rev_uint64p_nul.c | 18 + qsort_rev_uint8.c | 18 + qsort_rev_uint8p.c | 18 + qsort_rev_uint8p_nul.c | 18 + qsort_rev_uint_least16.c | 18 + qsort_rev_uint_least16p.c | 18 + qsort_rev_uint_least16p_nul.c | 18 + qsort_rev_uint_least32.c | 18 + qsort_rev_uint_least32p.c | 18 + qsort_rev_uint_least32p_nul.c | 18 + qsort_rev_uint_least64.c | 18 + qsort_rev_uint_least64p.c | 18 + qsort_rev_uint_least64p_nul.c | 18 + qsort_rev_uint_least8.c | 18 + qsort_rev_uint_least8p.c | 18 + qsort_rev_uint_least8p_nul.c | 18 + qsort_rev_uintmax.c | 18 + qsort_rev_uintmaxp.c | 18 + qsort_rev_uintmaxp_nul.c | 18 + qsort_rev_uintp.c | 18 + qsort_rev_uintp_nul.c | 18 + qsort_rev_uintptr.c | 18 + qsort_rev_uintptrp.c | 18 + qsort_rev_uintptrp_nul.c | 18 + qsort_rev_ullong.c | 18 + qsort_rev_ullongp.c | 18 + qsort_rev_ullongp_nul.c | 18 + qsort_rev_ulong.c | 18 + qsort_rev_ulongp.c | 18 + qsort_rev_ulongp_nul.c | 18 + qsort_rev_ushort.c | 18 + qsort_rev_ushortp.c | 18 + qsort_rev_ushortp_nul.c | 18 + qsort_schar.c | 18 + qsort_scharp.c | 18 + qsort_scharp_nul.c | 18 + qsort_short.c | 18 + qsort_shortp.c | 18 + qsort_shortp_nul.c | 18 + qsort_size.c | 18 + qsort_sizep.c | 18 + qsort_sizep_nul.c | 18 + qsort_ssize.c | 18 + qsort_ssizep.c | 18 + qsort_ssizep_nul.c | 18 + qsort_str.c | 18 + qsort_strp.c | 18 + qsort_strp_nul.c | 18 + qsort_uchar.c | 18 + qsort_ucharp.c | 18 + qsort_ucharp_nul.c | 18 + qsort_uint.c | 18 + qsort_uint16.c | 18 + qsort_uint16p.c | 18 + qsort_uint16p_nul.c | 18 + qsort_uint32.c | 18 + qsort_uint32p.c | 18 + qsort_uint32p_nul.c | 18 + qsort_uint64.c | 18 + qsort_uint64p.c | 18 + qsort_uint64p_nul.c | 18 + qsort_uint8.c | 18 + qsort_uint8p.c | 18 + qsort_uint8p_nul.c | 18 + qsort_uint_least16.c | 18 + qsort_uint_least16p.c | 18 + qsort_uint_least16p_nul.c | 18 + qsort_uint_least32.c | 18 + qsort_uint_least32p.c | 18 + qsort_uint_least32p_nul.c | 18 + qsort_uint_least64.c | 18 + qsort_uint_least64p.c | 18 + qsort_uint_least64p_nul.c | 18 + qsort_uint_least8.c | 18 + qsort_uint_least8p.c | 18 + qsort_uint_least8p_nul.c | 18 + qsort_uintmax.c | 18 + qsort_uintmaxp.c | 18 + qsort_uintmaxp_nul.c | 18 + qsort_uintp.c | 18 + qsort_uintp_nul.c | 18 + qsort_uintptr.c | 18 + qsort_uintptrp.c | 18 + qsort_uintptrp_nul.c | 18 + qsort_ullong.c | 18 + qsort_ullongp.c | 18 + qsort_ullongp_nul.c | 18 + qsort_ulong.c | 18 + qsort_ulongp.c | 18 + qsort_ulongp_nul.c | 18 + qsort_ushort.c | 18 + qsort_ushortp.c | 18 + qsort_ushortp_nul.c | 18 + 579 files changed, 12811 insertions(+) create mode 100644 cmp_doublep.c create mode 100644 cmp_doublepp.c create mode 100644 cmp_doublepp_nul.c create mode 100644 cmp_floatp.c create mode 100644 cmp_floatpp.c create mode 100644 cmp_floatpp_nul.c create mode 100644 cmp_int16p.c create mode 100644 cmp_int16pp.c create mode 100644 cmp_int16pp_nul.c create mode 100644 cmp_int32p.c create mode 100644 cmp_int32pp.c create mode 100644 cmp_int32pp_nul.c create mode 100644 cmp_int64p.c create mode 100644 cmp_int64pp.c create mode 100644 cmp_int64pp_nul.c create mode 100644 cmp_int8p.c create mode 100644 cmp_int8pp.c create mode 100644 cmp_int8pp_nul.c create mode 100644 cmp_int_least16p.c create mode 100644 cmp_int_least16pp.c create mode 100644 cmp_int_least16pp_nul.c create mode 100644 cmp_int_least32p.c create mode 100644 cmp_int_least32pp.c create mode 100644 cmp_int_least32pp_nul.c create mode 100644 cmp_int_least64p.c create mode 100644 cmp_int_least64pp.c create mode 100644 cmp_int_least64pp_nul.c create mode 100644 cmp_int_least8p.c create mode 100644 cmp_int_least8pp.c create mode 100644 cmp_int_least8pp_nul.c create mode 100644 cmp_intmaxp.c create mode 100644 cmp_intmaxpp.c create mode 100644 cmp_intmaxpp_nul.c create mode 100644 cmp_intp.c create mode 100644 cmp_intpp.c create mode 100644 cmp_intpp_nul.c create mode 100644 cmp_intptrp.c create mode 100644 cmp_intptrpp.c create mode 100644 cmp_intptrpp_nul.c create mode 100644 cmp_llongp.c create mode 100644 cmp_llongpp.c create mode 100644 cmp_llongpp_nul.c create mode 100644 cmp_longp.c create mode 100644 cmp_longpp.c create mode 100644 cmp_longpp_nul.c create mode 100644 cmp_nul_doublepp.c create mode 100644 cmp_nul_floatpp.c create mode 100644 cmp_nul_int16pp.c create mode 100644 cmp_nul_int32pp.c create mode 100644 cmp_nul_int64pp.c create mode 100644 cmp_nul_int8pp.c create mode 100644 cmp_nul_int_least16pp.c create mode 100644 cmp_nul_int_least32pp.c create mode 100644 cmp_nul_int_least64pp.c create mode 100644 cmp_nul_int_least8pp.c create mode 100644 cmp_nul_intmaxpp.c create mode 100644 cmp_nul_intpp.c create mode 100644 cmp_nul_intptrpp.c create mode 100644 cmp_nul_llongpp.c create mode 100644 cmp_nul_longpp.c create mode 100644 cmp_nul_ptrdiffpp.c create mode 100644 cmp_nul_rev_doublepp.c create mode 100644 cmp_nul_rev_floatpp.c create mode 100644 cmp_nul_rev_int16pp.c create mode 100644 cmp_nul_rev_int32pp.c create mode 100644 cmp_nul_rev_int64pp.c create mode 100644 cmp_nul_rev_int8pp.c create mode 100644 cmp_nul_rev_int_least16pp.c create mode 100644 cmp_nul_rev_int_least32pp.c create mode 100644 cmp_nul_rev_int_least64pp.c create mode 100644 cmp_nul_rev_int_least8pp.c create mode 100644 cmp_nul_rev_intmaxpp.c create mode 100644 cmp_nul_rev_intpp.c create mode 100644 cmp_nul_rev_intptrpp.c create mode 100644 cmp_nul_rev_llongpp.c create mode 100644 cmp_nul_rev_longpp.c create mode 100644 cmp_nul_rev_ptrdiffpp.c create mode 100644 cmp_nul_rev_scharpp.c create mode 100644 cmp_nul_rev_shortpp.c create mode 100644 cmp_nul_rev_sizepp.c create mode 100644 cmp_nul_rev_ssizepp.c create mode 100644 cmp_nul_rev_strpp.c create mode 100644 cmp_nul_rev_ucharpp.c create mode 100644 cmp_nul_rev_uint16pp.c create mode 100644 cmp_nul_rev_uint32pp.c create mode 100644 cmp_nul_rev_uint64pp.c create mode 100644 cmp_nul_rev_uint8pp.c create mode 100644 cmp_nul_rev_uint_least16pp.c create mode 100644 cmp_nul_rev_uint_least32pp.c create mode 100644 cmp_nul_rev_uint_least64pp.c create mode 100644 cmp_nul_rev_uint_least8pp.c create mode 100644 cmp_nul_rev_uintmaxpp.c create mode 100644 cmp_nul_rev_uintpp.c create mode 100644 cmp_nul_rev_uintptrpp.c create mode 100644 cmp_nul_rev_ullongpp.c create mode 100644 cmp_nul_rev_ulongpp.c create mode 100644 cmp_nul_rev_ushortpp.c create mode 100644 cmp_nul_scharpp.c create mode 100644 cmp_nul_shortpp.c create mode 100644 cmp_nul_sizepp.c create mode 100644 cmp_nul_ssizepp.c create mode 100644 cmp_nul_strpp.c create mode 100644 cmp_nul_ucharpp.c create mode 100644 cmp_nul_uint16pp.c create mode 100644 cmp_nul_uint32pp.c create mode 100644 cmp_nul_uint64pp.c create mode 100644 cmp_nul_uint8pp.c create mode 100644 cmp_nul_uint_least16pp.c create mode 100644 cmp_nul_uint_least32pp.c create mode 100644 cmp_nul_uint_least64pp.c create mode 100644 cmp_nul_uint_least8pp.c create mode 100644 cmp_nul_uintmaxpp.c create mode 100644 cmp_nul_uintpp.c create mode 100644 cmp_nul_uintptrpp.c create mode 100644 cmp_nul_ullongpp.c create mode 100644 cmp_nul_ulongpp.c create mode 100644 cmp_nul_ushortpp.c create mode 100644 cmp_ptrdiffp.c create mode 100644 cmp_ptrdiffpp.c create mode 100644 cmp_ptrdiffpp_nul.c create mode 100644 cmp_rev_doublep.c create mode 100644 cmp_rev_doublepp.c create mode 100644 cmp_rev_doublepp_nul.c create mode 100644 cmp_rev_floatp.c create mode 100644 cmp_rev_floatpp.c create mode 100644 cmp_rev_floatpp_nul.c create mode 100644 cmp_rev_int16p.c create mode 100644 cmp_rev_int16pp.c create mode 100644 cmp_rev_int16pp_nul.c create mode 100644 cmp_rev_int32p.c create mode 100644 cmp_rev_int32pp.c create mode 100644 cmp_rev_int32pp_nul.c create mode 100644 cmp_rev_int64p.c create mode 100644 cmp_rev_int64pp.c create mode 100644 cmp_rev_int64pp_nul.c create mode 100644 cmp_rev_int8p.c create mode 100644 cmp_rev_int8pp.c create mode 100644 cmp_rev_int8pp_nul.c create mode 100644 cmp_rev_int_least16p.c create mode 100644 cmp_rev_int_least16pp.c create mode 100644 cmp_rev_int_least16pp_nul.c create mode 100644 cmp_rev_int_least32p.c create mode 100644 cmp_rev_int_least32pp.c create mode 100644 cmp_rev_int_least32pp_nul.c create mode 100644 cmp_rev_int_least64p.c create mode 100644 cmp_rev_int_least64pp.c create mode 100644 cmp_rev_int_least64pp_nul.c create mode 100644 cmp_rev_int_least8p.c create mode 100644 cmp_rev_int_least8pp.c create mode 100644 cmp_rev_int_least8pp_nul.c create mode 100644 cmp_rev_intmaxp.c create mode 100644 cmp_rev_intmaxpp.c create mode 100644 cmp_rev_intmaxpp_nul.c create mode 100644 cmp_rev_intp.c create mode 100644 cmp_rev_intpp.c create mode 100644 cmp_rev_intpp_nul.c create mode 100644 cmp_rev_intptrp.c create mode 100644 cmp_rev_intptrpp.c create mode 100644 cmp_rev_intptrpp_nul.c create mode 100644 cmp_rev_llongp.c create mode 100644 cmp_rev_llongpp.c create mode 100644 cmp_rev_llongpp_nul.c create mode 100644 cmp_rev_longp.c create mode 100644 cmp_rev_longpp.c create mode 100644 cmp_rev_longpp_nul.c create mode 100644 cmp_rev_ptrdiffp.c create mode 100644 cmp_rev_ptrdiffpp.c create mode 100644 cmp_rev_ptrdiffpp_nul.c create mode 100644 cmp_rev_scharp.c create mode 100644 cmp_rev_scharpp.c create mode 100644 cmp_rev_scharpp_nul.c create mode 100644 cmp_rev_shortp.c create mode 100644 cmp_rev_shortpp.c create mode 100644 cmp_rev_shortpp_nul.c create mode 100644 cmp_rev_sizep.c create mode 100644 cmp_rev_sizepp.c create mode 100644 cmp_rev_sizepp_nul.c create mode 100644 cmp_rev_ssizep.c create mode 100644 cmp_rev_ssizepp.c create mode 100644 cmp_rev_ssizepp_nul.c create mode 100644 cmp_rev_strp.c create mode 100644 cmp_rev_strpp.c create mode 100644 cmp_rev_strpp_nul.c create mode 100644 cmp_rev_ucharp.c create mode 100644 cmp_rev_ucharpp.c create mode 100644 cmp_rev_ucharpp_nul.c create mode 100644 cmp_rev_uint16p.c create mode 100644 cmp_rev_uint16pp.c create mode 100644 cmp_rev_uint16pp_nul.c create mode 100644 cmp_rev_uint32p.c create mode 100644 cmp_rev_uint32pp.c create mode 100644 cmp_rev_uint32pp_nul.c create mode 100644 cmp_rev_uint64p.c create mode 100644 cmp_rev_uint64pp.c create mode 100644 cmp_rev_uint64pp_nul.c create mode 100644 cmp_rev_uint8p.c create mode 100644 cmp_rev_uint8pp.c create mode 100644 cmp_rev_uint8pp_nul.c create mode 100644 cmp_rev_uint_least16p.c create mode 100644 cmp_rev_uint_least16pp.c create mode 100644 cmp_rev_uint_least16pp_nul.c create mode 100644 cmp_rev_uint_least32p.c create mode 100644 cmp_rev_uint_least32pp.c create mode 100644 cmp_rev_uint_least32pp_nul.c create mode 100644 cmp_rev_uint_least64p.c create mode 100644 cmp_rev_uint_least64pp.c create mode 100644 cmp_rev_uint_least64pp_nul.c create mode 100644 cmp_rev_uint_least8p.c create mode 100644 cmp_rev_uint_least8pp.c create mode 100644 cmp_rev_uint_least8pp_nul.c create mode 100644 cmp_rev_uintmaxp.c create mode 100644 cmp_rev_uintmaxpp.c create mode 100644 cmp_rev_uintmaxpp_nul.c create mode 100644 cmp_rev_uintp.c create mode 100644 cmp_rev_uintpp.c create mode 100644 cmp_rev_uintpp_nul.c create mode 100644 cmp_rev_uintptrp.c create mode 100644 cmp_rev_uintptrpp.c create mode 100644 cmp_rev_uintptrpp_nul.c create mode 100644 cmp_rev_ullongp.c create mode 100644 cmp_rev_ullongpp.c create mode 100644 cmp_rev_ullongpp_nul.c create mode 100644 cmp_rev_ulongp.c create mode 100644 cmp_rev_ulongpp.c create mode 100644 cmp_rev_ulongpp_nul.c create mode 100644 cmp_rev_ushortp.c create mode 100644 cmp_rev_ushortpp.c create mode 100644 cmp_rev_ushortpp_nul.c create mode 100644 cmp_scharp.c create mode 100644 cmp_scharpp.c create mode 100644 cmp_scharpp_nul.c create mode 100644 cmp_shortp.c create mode 100644 cmp_shortpp.c create mode 100644 cmp_shortpp_nul.c create mode 100644 cmp_sizep.c create mode 100644 cmp_sizepp.c create mode 100644 cmp_sizepp_nul.c create mode 100644 cmp_ssizep.c create mode 100644 cmp_ssizepp.c create mode 100644 cmp_ssizepp_nul.c create mode 100644 cmp_strp.c create mode 100644 cmp_strpp.c create mode 100644 cmp_strpp_nul.c create mode 100644 cmp_ucharp.c create mode 100644 cmp_ucharpp.c create mode 100644 cmp_ucharpp_nul.c create mode 100644 cmp_uint16p.c create mode 100644 cmp_uint16pp.c create mode 100644 cmp_uint16pp_nul.c create mode 100644 cmp_uint32p.c create mode 100644 cmp_uint32pp.c create mode 100644 cmp_uint32pp_nul.c create mode 100644 cmp_uint64p.c create mode 100644 cmp_uint64pp.c create mode 100644 cmp_uint64pp_nul.c create mode 100644 cmp_uint8p.c create mode 100644 cmp_uint8pp.c create mode 100644 cmp_uint8pp_nul.c create mode 100644 cmp_uint_least16p.c create mode 100644 cmp_uint_least16pp.c create mode 100644 cmp_uint_least16pp_nul.c create mode 100644 cmp_uint_least32p.c create mode 100644 cmp_uint_least32pp.c create mode 100644 cmp_uint_least32pp_nul.c create mode 100644 cmp_uint_least64p.c create mode 100644 cmp_uint_least64pp.c create mode 100644 cmp_uint_least64pp_nul.c create mode 100644 cmp_uint_least8p.c create mode 100644 cmp_uint_least8pp.c create mode 100644 cmp_uint_least8pp_nul.c create mode 100644 cmp_uintmaxp.c create mode 100644 cmp_uintmaxpp.c create mode 100644 cmp_uintmaxpp_nul.c create mode 100644 cmp_uintp.c create mode 100644 cmp_uintpp.c create mode 100644 cmp_uintpp_nul.c create mode 100644 cmp_uintptrp.c create mode 100644 cmp_uintptrpp.c create mode 100644 cmp_uintptrpp_nul.c create mode 100644 cmp_ullongp.c create mode 100644 cmp_ullongpp.c create mode 100644 cmp_ullongpp_nul.c create mode 100644 cmp_ulongp.c create mode 100644 cmp_ulongpp.c create mode 100644 cmp_ulongpp_nul.c create mode 100644 cmp_ushortp.c create mode 100644 cmp_ushortpp.c create mode 100644 cmp_ushortpp_nul.c create mode 100644 libsimple/sort.h create mode 100644 qsort_double.c create mode 100644 qsort_doublep.c create mode 100644 qsort_doublep_nul.c create mode 100644 qsort_float.c create mode 100644 qsort_floatp.c create mode 100644 qsort_floatp_nul.c create mode 100644 qsort_int.c create mode 100644 qsort_int16.c create mode 100644 qsort_int16p.c create mode 100644 qsort_int16p_nul.c create mode 100644 qsort_int32.c create mode 100644 qsort_int32p.c create mode 100644 qsort_int32p_nul.c create mode 100644 qsort_int64.c create mode 100644 qsort_int64p.c create mode 100644 qsort_int64p_nul.c create mode 100644 qsort_int8.c create mode 100644 qsort_int8p.c create mode 100644 qsort_int8p_nul.c create mode 100644 qsort_int_least16.c create mode 100644 qsort_int_least16p.c create mode 100644 qsort_int_least16p_nul.c create mode 100644 qsort_int_least32.c create mode 100644 qsort_int_least32p.c create mode 100644 qsort_int_least32p_nul.c create mode 100644 qsort_int_least64.c create mode 100644 qsort_int_least64p.c create mode 100644 qsort_int_least64p_nul.c create mode 100644 qsort_int_least8.c create mode 100644 qsort_int_least8p.c create mode 100644 qsort_int_least8p_nul.c create mode 100644 qsort_intmax.c create mode 100644 qsort_intmaxp.c create mode 100644 qsort_intmaxp_nul.c create mode 100644 qsort_intp.c create mode 100644 qsort_intp_nul.c create mode 100644 qsort_intptr.c create mode 100644 qsort_intptrp.c create mode 100644 qsort_intptrp_nul.c create mode 100644 qsort_llong.c create mode 100644 qsort_llongp.c create mode 100644 qsort_llongp_nul.c create mode 100644 qsort_long.c create mode 100644 qsort_longp.c create mode 100644 qsort_longp_nul.c create mode 100644 qsort_nul_doublep.c create mode 100644 qsort_nul_floatp.c create mode 100644 qsort_nul_int16p.c create mode 100644 qsort_nul_int32p.c create mode 100644 qsort_nul_int64p.c create mode 100644 qsort_nul_int8p.c create mode 100644 qsort_nul_int_least16p.c create mode 100644 qsort_nul_int_least32p.c create mode 100644 qsort_nul_int_least64p.c create mode 100644 qsort_nul_int_least8p.c create mode 100644 qsort_nul_intmaxp.c create mode 100644 qsort_nul_intp.c create mode 100644 qsort_nul_intptrp.c create mode 100644 qsort_nul_llongp.c create mode 100644 qsort_nul_longp.c create mode 100644 qsort_nul_ptrdiffp.c create mode 100644 qsort_nul_rev_doublep.c create mode 100644 qsort_nul_rev_floatp.c create mode 100644 qsort_nul_rev_int16p.c create mode 100644 qsort_nul_rev_int32p.c create mode 100644 qsort_nul_rev_int64p.c create mode 100644 qsort_nul_rev_int8p.c create mode 100644 qsort_nul_rev_int_least16p.c create mode 100644 qsort_nul_rev_int_least32p.c create mode 100644 qsort_nul_rev_int_least64p.c create mode 100644 qsort_nul_rev_int_least8p.c create mode 100644 qsort_nul_rev_intmaxp.c create mode 100644 qsort_nul_rev_intp.c create mode 100644 qsort_nul_rev_intptrp.c create mode 100644 qsort_nul_rev_llongp.c create mode 100644 qsort_nul_rev_longp.c create mode 100644 qsort_nul_rev_ptrdiffp.c create mode 100644 qsort_nul_rev_scharp.c create mode 100644 qsort_nul_rev_shortp.c create mode 100644 qsort_nul_rev_sizep.c create mode 100644 qsort_nul_rev_ssizep.c create mode 100644 qsort_nul_rev_strp.c create mode 100644 qsort_nul_rev_ucharp.c create mode 100644 qsort_nul_rev_uint16p.c create mode 100644 qsort_nul_rev_uint32p.c create mode 100644 qsort_nul_rev_uint64p.c create mode 100644 qsort_nul_rev_uint8p.c create mode 100644 qsort_nul_rev_uint_least16p.c create mode 100644 qsort_nul_rev_uint_least32p.c create mode 100644 qsort_nul_rev_uint_least64p.c create mode 100644 qsort_nul_rev_uint_least8p.c create mode 100644 qsort_nul_rev_uintmaxp.c create mode 100644 qsort_nul_rev_uintp.c create mode 100644 qsort_nul_rev_uintptrp.c create mode 100644 qsort_nul_rev_ullongp.c create mode 100644 qsort_nul_rev_ulongp.c create mode 100644 qsort_nul_rev_ushortp.c create mode 100644 qsort_nul_scharp.c create mode 100644 qsort_nul_shortp.c create mode 100644 qsort_nul_sizep.c create mode 100644 qsort_nul_ssizep.c create mode 100644 qsort_nul_strp.c create mode 100644 qsort_nul_ucharp.c create mode 100644 qsort_nul_uint16p.c create mode 100644 qsort_nul_uint32p.c create mode 100644 qsort_nul_uint64p.c create mode 100644 qsort_nul_uint8p.c create mode 100644 qsort_nul_uint_least16p.c create mode 100644 qsort_nul_uint_least32p.c create mode 100644 qsort_nul_uint_least64p.c create mode 100644 qsort_nul_uint_least8p.c create mode 100644 qsort_nul_uintmaxp.c create mode 100644 qsort_nul_uintp.c create mode 100644 qsort_nul_uintptrp.c create mode 100644 qsort_nul_ullongp.c create mode 100644 qsort_nul_ulongp.c create mode 100644 qsort_nul_ushortp.c create mode 100644 qsort_ptrdiff.c create mode 100644 qsort_ptrdiffp.c create mode 100644 qsort_ptrdiffp_nul.c create mode 100644 qsort_rev_double.c create mode 100644 qsort_rev_doublep.c create mode 100644 qsort_rev_doublep_nul.c create mode 100644 qsort_rev_float.c create mode 100644 qsort_rev_floatp.c create mode 100644 qsort_rev_floatp_nul.c create mode 100644 qsort_rev_int.c create mode 100644 qsort_rev_int16.c create mode 100644 qsort_rev_int16p.c create mode 100644 qsort_rev_int16p_nul.c create mode 100644 qsort_rev_int32.c create mode 100644 qsort_rev_int32p.c create mode 100644 qsort_rev_int32p_nul.c create mode 100644 qsort_rev_int64.c create mode 100644 qsort_rev_int64p.c create mode 100644 qsort_rev_int64p_nul.c create mode 100644 qsort_rev_int8.c create mode 100644 qsort_rev_int8p.c create mode 100644 qsort_rev_int8p_nul.c create mode 100644 qsort_rev_int_least16.c create mode 100644 qsort_rev_int_least16p.c create mode 100644 qsort_rev_int_least16p_nul.c create mode 100644 qsort_rev_int_least32.c create mode 100644 qsort_rev_int_least32p.c create mode 100644 qsort_rev_int_least32p_nul.c create mode 100644 qsort_rev_int_least64.c create mode 100644 qsort_rev_int_least64p.c create mode 100644 qsort_rev_int_least64p_nul.c create mode 100644 qsort_rev_int_least8.c create mode 100644 qsort_rev_int_least8p.c create mode 100644 qsort_rev_int_least8p_nul.c create mode 100644 qsort_rev_intmax.c create mode 100644 qsort_rev_intmaxp.c create mode 100644 qsort_rev_intmaxp_nul.c create mode 100644 qsort_rev_intp.c create mode 100644 qsort_rev_intp_nul.c create mode 100644 qsort_rev_intptr.c create mode 100644 qsort_rev_intptrp.c create mode 100644 qsort_rev_intptrp_nul.c create mode 100644 qsort_rev_llong.c create mode 100644 qsort_rev_llongp.c create mode 100644 qsort_rev_llongp_nul.c create mode 100644 qsort_rev_long.c create mode 100644 qsort_rev_longp.c create mode 100644 qsort_rev_longp_nul.c create mode 100644 qsort_rev_ptrdiff.c create mode 100644 qsort_rev_ptrdiffp.c create mode 100644 qsort_rev_ptrdiffp_nul.c create mode 100644 qsort_rev_schar.c create mode 100644 qsort_rev_scharp.c create mode 100644 qsort_rev_scharp_nul.c create mode 100644 qsort_rev_short.c create mode 100644 qsort_rev_shortp.c create mode 100644 qsort_rev_shortp_nul.c create mode 100644 qsort_rev_size.c create mode 100644 qsort_rev_sizep.c create mode 100644 qsort_rev_sizep_nul.c create mode 100644 qsort_rev_ssize.c create mode 100644 qsort_rev_ssizep.c create mode 100644 qsort_rev_ssizep_nul.c create mode 100644 qsort_rev_str.c create mode 100644 qsort_rev_strp.c create mode 100644 qsort_rev_strp_nul.c create mode 100644 qsort_rev_uchar.c create mode 100644 qsort_rev_ucharp.c create mode 100644 qsort_rev_ucharp_nul.c create mode 100644 qsort_rev_uint.c create mode 100644 qsort_rev_uint16.c create mode 100644 qsort_rev_uint16p.c create mode 100644 qsort_rev_uint16p_nul.c create mode 100644 qsort_rev_uint32.c create mode 100644 qsort_rev_uint32p.c create mode 100644 qsort_rev_uint32p_nul.c create mode 100644 qsort_rev_uint64.c create mode 100644 qsort_rev_uint64p.c create mode 100644 qsort_rev_uint64p_nul.c create mode 100644 qsort_rev_uint8.c create mode 100644 qsort_rev_uint8p.c create mode 100644 qsort_rev_uint8p_nul.c create mode 100644 qsort_rev_uint_least16.c create mode 100644 qsort_rev_uint_least16p.c create mode 100644 qsort_rev_uint_least16p_nul.c create mode 100644 qsort_rev_uint_least32.c create mode 100644 qsort_rev_uint_least32p.c create mode 100644 qsort_rev_uint_least32p_nul.c create mode 100644 qsort_rev_uint_least64.c create mode 100644 qsort_rev_uint_least64p.c create mode 100644 qsort_rev_uint_least64p_nul.c create mode 100644 qsort_rev_uint_least8.c create mode 100644 qsort_rev_uint_least8p.c create mode 100644 qsort_rev_uint_least8p_nul.c create mode 100644 qsort_rev_uintmax.c create mode 100644 qsort_rev_uintmaxp.c create mode 100644 qsort_rev_uintmaxp_nul.c create mode 100644 qsort_rev_uintp.c create mode 100644 qsort_rev_uintp_nul.c create mode 100644 qsort_rev_uintptr.c create mode 100644 qsort_rev_uintptrp.c create mode 100644 qsort_rev_uintptrp_nul.c create mode 100644 qsort_rev_ullong.c create mode 100644 qsort_rev_ullongp.c create mode 100644 qsort_rev_ullongp_nul.c create mode 100644 qsort_rev_ulong.c create mode 100644 qsort_rev_ulongp.c create mode 100644 qsort_rev_ulongp_nul.c create mode 100644 qsort_rev_ushort.c create mode 100644 qsort_rev_ushortp.c create mode 100644 qsort_rev_ushortp_nul.c create mode 100644 qsort_schar.c create mode 100644 qsort_scharp.c create mode 100644 qsort_scharp_nul.c create mode 100644 qsort_short.c create mode 100644 qsort_shortp.c create mode 100644 qsort_shortp_nul.c create mode 100644 qsort_size.c create mode 100644 qsort_sizep.c create mode 100644 qsort_sizep_nul.c create mode 100644 qsort_ssize.c create mode 100644 qsort_ssizep.c create mode 100644 qsort_ssizep_nul.c create mode 100644 qsort_str.c create mode 100644 qsort_strp.c create mode 100644 qsort_strp_nul.c create mode 100644 qsort_uchar.c create mode 100644 qsort_ucharp.c create mode 100644 qsort_ucharp_nul.c create mode 100644 qsort_uint.c create mode 100644 qsort_uint16.c create mode 100644 qsort_uint16p.c create mode 100644 qsort_uint16p_nul.c create mode 100644 qsort_uint32.c create mode 100644 qsort_uint32p.c create mode 100644 qsort_uint32p_nul.c create mode 100644 qsort_uint64.c create mode 100644 qsort_uint64p.c create mode 100644 qsort_uint64p_nul.c create mode 100644 qsort_uint8.c create mode 100644 qsort_uint8p.c create mode 100644 qsort_uint8p_nul.c create mode 100644 qsort_uint_least16.c create mode 100644 qsort_uint_least16p.c create mode 100644 qsort_uint_least16p_nul.c create mode 100644 qsort_uint_least32.c create mode 100644 qsort_uint_least32p.c create mode 100644 qsort_uint_least32p_nul.c create mode 100644 qsort_uint_least64.c create mode 100644 qsort_uint_least64p.c create mode 100644 qsort_uint_least64p_nul.c create mode 100644 qsort_uint_least8.c create mode 100644 qsort_uint_least8p.c create mode 100644 qsort_uint_least8p_nul.c create mode 100644 qsort_uintmax.c create mode 100644 qsort_uintmaxp.c create mode 100644 qsort_uintmaxp_nul.c create mode 100644 qsort_uintp.c create mode 100644 qsort_uintp_nul.c create mode 100644 qsort_uintptr.c create mode 100644 qsort_uintptrp.c create mode 100644 qsort_uintptrp_nul.c create mode 100644 qsort_ullong.c create mode 100644 qsort_ullongp.c create mode 100644 qsort_ullongp_nul.c create mode 100644 qsort_ulong.c create mode 100644 qsort_ulongp.c create mode 100644 qsort_ulongp_nul.c create mode 100644 qsort_ushort.c create mode 100644 qsort_ushortp.c create mode 100644 qsort_ushortp_nul.c diff --git a/Makefile b/Makefile index 84fb58c..c1f2dbc 100644 --- a/Makefile +++ b/Makefile @@ -52,6 +52,7 @@ SUBHDR =\ libsimple/random.h\ libsimple/realloc.h\ libsimple/search.h\ + libsimple/sort.h\ libsimple/str.h\ libsimple/strdup.h\ libsimple/strn.h\ @@ -95,6 +96,294 @@ OBJ =\ callocn.o\ close.o\ close_range.o\ + cmp_doublep.o\ + cmp_doublepp.o\ + cmp_doublepp_nul.o\ + cmp_floatp.o\ + cmp_floatpp.o\ + cmp_floatpp_nul.o\ + cmp_int16p.o\ + cmp_int16pp.o\ + cmp_int16pp_nul.o\ + cmp_int32p.o\ + cmp_int32pp.o\ + cmp_int32pp_nul.o\ + cmp_int64p.o\ + cmp_int64pp.o\ + cmp_int64pp_nul.o\ + cmp_int8p.o\ + cmp_int8pp.o\ + cmp_int8pp_nul.o\ + cmp_int_least16p.o\ + cmp_int_least16pp.o\ + cmp_int_least16pp_nul.o\ + cmp_int_least32p.o\ + cmp_int_least32pp.o\ + cmp_int_least32pp_nul.o\ + cmp_int_least64p.o\ + cmp_int_least64pp.o\ + cmp_int_least64pp_nul.o\ + cmp_int_least8p.o\ + cmp_int_least8pp.o\ + cmp_int_least8pp_nul.o\ + cmp_intmaxp.o\ + cmp_intmaxpp.o\ + cmp_intmaxpp_nul.o\ + cmp_intp.o\ + cmp_intpp.o\ + cmp_intpp_nul.o\ + cmp_intptrp.o\ + cmp_intptrpp.o\ + cmp_intptrpp_nul.o\ + cmp_llongp.o\ + cmp_llongpp.o\ + cmp_llongpp_nul.o\ + cmp_longp.o\ + cmp_longpp.o\ + cmp_longpp_nul.o\ + cmp_nul_doublepp.o\ + cmp_nul_floatpp.o\ + cmp_nul_int16pp.o\ + cmp_nul_int32pp.o\ + cmp_nul_int64pp.o\ + cmp_nul_int8pp.o\ + cmp_nul_int_least16pp.o\ + cmp_nul_int_least32pp.o\ + cmp_nul_int_least64pp.o\ + cmp_nul_int_least8pp.o\ + cmp_nul_intmaxpp.o\ + cmp_nul_intpp.o\ + cmp_nul_intptrpp.o\ + cmp_nul_llongpp.o\ + cmp_nul_longpp.o\ + cmp_nul_ptrdiffpp.o\ + cmp_nul_rev_doublepp.o\ + cmp_nul_rev_floatpp.o\ + cmp_nul_rev_int16pp.o\ + cmp_nul_rev_int32pp.o\ + cmp_nul_rev_int64pp.o\ + cmp_nul_rev_int8pp.o\ + cmp_nul_rev_int_least16pp.o\ + cmp_nul_rev_int_least32pp.o\ + cmp_nul_rev_int_least64pp.o\ + cmp_nul_rev_int_least8pp.o\ + cmp_nul_rev_intmaxpp.o\ + cmp_nul_rev_intpp.o\ + cmp_nul_rev_intptrpp.o\ + cmp_nul_rev_llongpp.o\ + cmp_nul_rev_longpp.o\ + cmp_nul_rev_ptrdiffpp.o\ + cmp_nul_rev_scharpp.o\ + cmp_nul_rev_shortpp.o\ + cmp_nul_rev_sizepp.o\ + cmp_nul_rev_ssizepp.o\ + cmp_nul_rev_strpp.o\ + cmp_nul_rev_ucharpp.o\ + cmp_nul_rev_uint16pp.o\ + cmp_nul_rev_uint32pp.o\ + cmp_nul_rev_uint64pp.o\ + cmp_nul_rev_uint8pp.o\ + cmp_nul_rev_uint_least16pp.o\ + cmp_nul_rev_uint_least32pp.o\ + cmp_nul_rev_uint_least64pp.o\ + cmp_nul_rev_uint_least8pp.o\ + cmp_nul_rev_uintmaxpp.o\ + cmp_nul_rev_uintpp.o\ + cmp_nul_rev_uintptrpp.o\ + cmp_nul_rev_ullongpp.o\ + cmp_nul_rev_ulongpp.o\ + cmp_nul_rev_ushortpp.o\ + cmp_nul_scharpp.o\ + cmp_nul_shortpp.o\ + cmp_nul_sizepp.o\ + cmp_nul_ssizepp.o\ + cmp_nul_strpp.o\ + cmp_nul_ucharpp.o\ + cmp_nul_uint16pp.o\ + cmp_nul_uint32pp.o\ + cmp_nul_uint64pp.o\ + cmp_nul_uint8pp.o\ + cmp_nul_uint_least16pp.o\ + cmp_nul_uint_least32pp.o\ + cmp_nul_uint_least64pp.o\ + cmp_nul_uint_least8pp.o\ + cmp_nul_uintmaxpp.o\ + cmp_nul_uintpp.o\ + cmp_nul_uintptrpp.o\ + cmp_nul_ullongpp.o\ + cmp_nul_ulongpp.o\ + cmp_nul_ushortpp.o\ + cmp_ptrdiffp.o\ + cmp_ptrdiffpp.o\ + cmp_ptrdiffpp_nul.o\ + cmp_rev_doublep.o\ + cmp_rev_doublepp.o\ + cmp_rev_doublepp_nul.o\ + cmp_rev_floatp.o\ + cmp_rev_floatpp.o\ + cmp_rev_floatpp_nul.o\ + cmp_rev_int16p.o\ + cmp_rev_int16pp.o\ + cmp_rev_int16pp_nul.o\ + cmp_rev_int32p.o\ + cmp_rev_int32pp.o\ + cmp_rev_int32pp_nul.o\ + cmp_rev_int64p.o\ + cmp_rev_int64pp.o\ + cmp_rev_int64pp_nul.o\ + cmp_rev_int8p.o\ + cmp_rev_int8pp.o\ + cmp_rev_int8pp_nul.o\ + cmp_rev_int_least16p.o\ + cmp_rev_int_least16pp.o\ + cmp_rev_int_least16pp_nul.o\ + cmp_rev_int_least32p.o\ + cmp_rev_int_least32pp.o\ + cmp_rev_int_least32pp_nul.o\ + cmp_rev_int_least64p.o\ + cmp_rev_int_least64pp.o\ + cmp_rev_int_least64pp_nul.o\ + cmp_rev_int_least8p.o\ + cmp_rev_int_least8pp.o\ + cmp_rev_int_least8pp_nul.o\ + cmp_rev_intmaxp.o\ + cmp_rev_intmaxpp.o\ + cmp_rev_intmaxpp_nul.o\ + cmp_rev_intp.o\ + cmp_rev_intpp.o\ + cmp_rev_intpp_nul.o\ + cmp_rev_intptrp.o\ + cmp_rev_intptrpp.o\ + cmp_rev_intptrpp_nul.o\ + cmp_rev_llongp.o\ + cmp_rev_llongpp.o\ + cmp_rev_llongpp_nul.o\ + cmp_rev_longp.o\ + cmp_rev_longpp.o\ + cmp_rev_longpp_nul.o\ + cmp_rev_ptrdiffp.o\ + cmp_rev_ptrdiffpp.o\ + cmp_rev_ptrdiffpp_nul.o\ + cmp_rev_scharp.o\ + cmp_rev_scharpp.o\ + cmp_rev_scharpp_nul.o\ + cmp_rev_shortp.o\ + cmp_rev_shortpp.o\ + cmp_rev_shortpp_nul.o\ + cmp_rev_sizep.o\ + cmp_rev_sizepp.o\ + cmp_rev_sizepp_nul.o\ + cmp_rev_ssizep.o\ + cmp_rev_ssizepp.o\ + cmp_rev_ssizepp_nul.o\ + cmp_rev_strp.o\ + cmp_rev_strpp.o\ + cmp_rev_strpp_nul.o\ + cmp_rev_ucharp.o\ + cmp_rev_ucharpp.o\ + cmp_rev_ucharpp_nul.o\ + cmp_rev_uint16p.o\ + cmp_rev_uint16pp.o\ + cmp_rev_uint16pp_nul.o\ + cmp_rev_uint32p.o\ + cmp_rev_uint32pp.o\ + cmp_rev_uint32pp_nul.o\ + cmp_rev_uint64p.o\ + cmp_rev_uint64pp.o\ + cmp_rev_uint64pp_nul.o\ + cmp_rev_uint8p.o\ + cmp_rev_uint8pp.o\ + cmp_rev_uint8pp_nul.o\ + cmp_rev_uint_least16p.o\ + cmp_rev_uint_least16pp.o\ + cmp_rev_uint_least16pp_nul.o\ + cmp_rev_uint_least32p.o\ + cmp_rev_uint_least32pp.o\ + cmp_rev_uint_least32pp_nul.o\ + cmp_rev_uint_least64p.o\ + cmp_rev_uint_least64pp.o\ + cmp_rev_uint_least64pp_nul.o\ + cmp_rev_uint_least8p.o\ + cmp_rev_uint_least8pp.o\ + cmp_rev_uint_least8pp_nul.o\ + cmp_rev_uintmaxp.o\ + cmp_rev_uintmaxpp.o\ + cmp_rev_uintmaxpp_nul.o\ + cmp_rev_uintp.o\ + cmp_rev_uintpp.o\ + cmp_rev_uintpp_nul.o\ + cmp_rev_uintptrp.o\ + cmp_rev_uintptrpp.o\ + cmp_rev_uintptrpp_nul.o\ + cmp_rev_ullongp.o\ + cmp_rev_ullongpp.o\ + cmp_rev_ullongpp_nul.o\ + cmp_rev_ulongp.o\ + cmp_rev_ulongpp.o\ + cmp_rev_ulongpp_nul.o\ + cmp_rev_ushortp.o\ + cmp_rev_ushortpp.o\ + cmp_rev_ushortpp_nul.o\ + cmp_scharp.o\ + cmp_scharpp.o\ + cmp_scharpp_nul.o\ + cmp_shortp.o\ + cmp_shortpp.o\ + cmp_shortpp_nul.o\ + cmp_sizep.o\ + cmp_sizepp.o\ + cmp_sizepp_nul.o\ + cmp_ssizep.o\ + cmp_ssizepp.o\ + cmp_ssizepp_nul.o\ + cmp_strp.o\ + cmp_strpp.o\ + cmp_strpp_nul.o\ + cmp_ucharp.o\ + cmp_ucharpp.o\ + cmp_ucharpp_nul.o\ + cmp_uint16p.o\ + cmp_uint16pp.o\ + cmp_uint16pp_nul.o\ + cmp_uint32p.o\ + cmp_uint32pp.o\ + cmp_uint32pp_nul.o\ + cmp_uint64p.o\ + cmp_uint64pp.o\ + cmp_uint64pp_nul.o\ + cmp_uint8p.o\ + cmp_uint8pp.o\ + cmp_uint8pp_nul.o\ + cmp_uint_least16p.o\ + cmp_uint_least16pp.o\ + cmp_uint_least16pp_nul.o\ + cmp_uint_least32p.o\ + cmp_uint_least32pp.o\ + cmp_uint_least32pp_nul.o\ + cmp_uint_least64p.o\ + cmp_uint_least64pp.o\ + cmp_uint_least64pp_nul.o\ + cmp_uint_least8p.o\ + cmp_uint_least8pp.o\ + cmp_uint_least8pp_nul.o\ + cmp_uintmaxp.o\ + cmp_uintmaxpp.o\ + cmp_uintmaxpp_nul.o\ + cmp_uintp.o\ + cmp_uintpp.o\ + cmp_uintpp_nul.o\ + cmp_uintptrp.o\ + cmp_uintptrpp.o\ + cmp_uintptrpp_nul.o\ + cmp_ullongp.o\ + cmp_ullongpp.o\ + cmp_ullongpp_nul.o\ + cmp_ulongp.o\ + cmp_ulongpp.o\ + cmp_ulongpp_nul.o\ + cmp_ushortp.o\ + cmp_ushortpp.o\ + cmp_ushortpp_nul.o\ cmptimespec.o\ cmptimeval.o\ diff.o\ @@ -342,6 +631,294 @@ OBJ =\ pvallocn.o\ pvallocz.o\ pvalloczn.o\ + qsort_double.o\ + qsort_doublep.o\ + qsort_doublep_nul.o\ + qsort_float.o\ + qsort_floatp.o\ + qsort_floatp_nul.o\ + qsort_int.o\ + qsort_int16.o\ + qsort_int16p.o\ + qsort_int16p_nul.o\ + qsort_int32.o\ + qsort_int32p.o\ + qsort_int32p_nul.o\ + qsort_int64.o\ + qsort_int64p.o\ + qsort_int64p_nul.o\ + qsort_int8.o\ + qsort_int8p.o\ + qsort_int8p_nul.o\ + qsort_int_least16.o\ + qsort_int_least16p.o\ + qsort_int_least16p_nul.o\ + qsort_int_least32.o\ + qsort_int_least32p.o\ + qsort_int_least32p_nul.o\ + qsort_int_least64.o\ + qsort_int_least64p.o\ + qsort_int_least64p_nul.o\ + qsort_int_least8.o\ + qsort_int_least8p.o\ + qsort_int_least8p_nul.o\ + qsort_intmax.o\ + qsort_intmaxp.o\ + qsort_intmaxp_nul.o\ + qsort_intp.o\ + qsort_intp_nul.o\ + qsort_intptr.o\ + qsort_intptrp.o\ + qsort_intptrp_nul.o\ + qsort_llong.o\ + qsort_llongp.o\ + qsort_llongp_nul.o\ + qsort_long.o\ + qsort_longp.o\ + qsort_longp_nul.o\ + qsort_nul_doublep.o\ + qsort_nul_floatp.o\ + qsort_nul_int16p.o\ + qsort_nul_int32p.o\ + qsort_nul_int64p.o\ + qsort_nul_int8p.o\ + qsort_nul_int_least16p.o\ + qsort_nul_int_least32p.o\ + qsort_nul_int_least64p.o\ + qsort_nul_int_least8p.o\ + qsort_nul_intmaxp.o\ + qsort_nul_intp.o\ + qsort_nul_intptrp.o\ + qsort_nul_llongp.o\ + qsort_nul_longp.o\ + qsort_nul_ptrdiffp.o\ + qsort_nul_rev_doublep.o\ + qsort_nul_rev_floatp.o\ + qsort_nul_rev_int16p.o\ + qsort_nul_rev_int32p.o\ + qsort_nul_rev_int64p.o\ + qsort_nul_rev_int8p.o\ + qsort_nul_rev_int_least16p.o\ + qsort_nul_rev_int_least32p.o\ + qsort_nul_rev_int_least64p.o\ + qsort_nul_rev_int_least8p.o\ + qsort_nul_rev_intmaxp.o\ + qsort_nul_rev_intp.o\ + qsort_nul_rev_intptrp.o\ + qsort_nul_rev_llongp.o\ + qsort_nul_rev_longp.o\ + qsort_nul_rev_ptrdiffp.o\ + qsort_nul_rev_scharp.o\ + qsort_nul_rev_shortp.o\ + qsort_nul_rev_sizep.o\ + qsort_nul_rev_ssizep.o\ + qsort_nul_rev_strp.o\ + qsort_nul_rev_ucharp.o\ + qsort_nul_rev_uint16p.o\ + qsort_nul_rev_uint32p.o\ + qsort_nul_rev_uint64p.o\ + qsort_nul_rev_uint8p.o\ + qsort_nul_rev_uint_least16p.o\ + qsort_nul_rev_uint_least32p.o\ + qsort_nul_rev_uint_least64p.o\ + qsort_nul_rev_uint_least8p.o\ + qsort_nul_rev_uintmaxp.o\ + qsort_nul_rev_uintp.o\ + qsort_nul_rev_uintptrp.o\ + qsort_nul_rev_ullongp.o\ + qsort_nul_rev_ulongp.o\ + qsort_nul_rev_ushortp.o\ + qsort_nul_scharp.o\ + qsort_nul_shortp.o\ + qsort_nul_sizep.o\ + qsort_nul_ssizep.o\ + qsort_nul_strp.o\ + qsort_nul_ucharp.o\ + qsort_nul_uint16p.o\ + qsort_nul_uint32p.o\ + qsort_nul_uint64p.o\ + qsort_nul_uint8p.o\ + qsort_nul_uint_least16p.o\ + qsort_nul_uint_least32p.o\ + qsort_nul_uint_least64p.o\ + qsort_nul_uint_least8p.o\ + qsort_nul_uintmaxp.o\ + qsort_nul_uintp.o\ + qsort_nul_uintptrp.o\ + qsort_nul_ullongp.o\ + qsort_nul_ulongp.o\ + qsort_nul_ushortp.o\ + qsort_ptrdiff.o\ + qsort_ptrdiffp.o\ + qsort_ptrdiffp_nul.o\ + qsort_rev_double.o\ + qsort_rev_doublep.o\ + qsort_rev_doublep_nul.o\ + qsort_rev_float.o\ + qsort_rev_floatp.o\ + qsort_rev_floatp_nul.o\ + qsort_rev_int.o\ + qsort_rev_int16.o\ + qsort_rev_int16p.o\ + qsort_rev_int16p_nul.o\ + qsort_rev_int32.o\ + qsort_rev_int32p.o\ + qsort_rev_int32p_nul.o\ + qsort_rev_int64.o\ + qsort_rev_int64p.o\ + qsort_rev_int64p_nul.o\ + qsort_rev_int8.o\ + qsort_rev_int8p.o\ + qsort_rev_int8p_nul.o\ + qsort_rev_int_least16.o\ + qsort_rev_int_least16p.o\ + qsort_rev_int_least16p_nul.o\ + qsort_rev_int_least32.o\ + qsort_rev_int_least32p.o\ + qsort_rev_int_least32p_nul.o\ + qsort_rev_int_least64.o\ + qsort_rev_int_least64p.o\ + qsort_rev_int_least64p_nul.o\ + qsort_rev_int_least8.o\ + qsort_rev_int_least8p.o\ + qsort_rev_int_least8p_nul.o\ + qsort_rev_intmax.o\ + qsort_rev_intmaxp.o\ + qsort_rev_intmaxp_nul.o\ + qsort_rev_intp.o\ + qsort_rev_intp_nul.o\ + qsort_rev_intptr.o\ + qsort_rev_intptrp.o\ + qsort_rev_intptrp_nul.o\ + qsort_rev_llong.o\ + qsort_rev_llongp.o\ + qsort_rev_llongp_nul.o\ + qsort_rev_long.o\ + qsort_rev_longp.o\ + qsort_rev_longp_nul.o\ + qsort_rev_ptrdiff.o\ + qsort_rev_ptrdiffp.o\ + qsort_rev_ptrdiffp_nul.o\ + qsort_rev_schar.o\ + qsort_rev_scharp.o\ + qsort_rev_scharp_nul.o\ + qsort_rev_short.o\ + qsort_rev_shortp.o\ + qsort_rev_shortp_nul.o\ + qsort_rev_size.o\ + qsort_rev_sizep.o\ + qsort_rev_sizep_nul.o\ + qsort_rev_ssize.o\ + qsort_rev_ssizep.o\ + qsort_rev_ssizep_nul.o\ + qsort_rev_str.o\ + qsort_rev_strp.o\ + qsort_rev_strp_nul.o\ + qsort_rev_uchar.o\ + qsort_rev_ucharp.o\ + qsort_rev_ucharp_nul.o\ + qsort_rev_uint.o\ + qsort_rev_uint16.o\ + qsort_rev_uint16p.o\ + qsort_rev_uint16p_nul.o\ + qsort_rev_uint32.o\ + qsort_rev_uint32p.o\ + qsort_rev_uint32p_nul.o\ + qsort_rev_uint64.o\ + qsort_rev_uint64p.o\ + qsort_rev_uint64p_nul.o\ + qsort_rev_uint8.o\ + qsort_rev_uint8p.o\ + qsort_rev_uint8p_nul.o\ + qsort_rev_uint_least16.o\ + qsort_rev_uint_least16p.o\ + qsort_rev_uint_least16p_nul.o\ + qsort_rev_uint_least32.o\ + qsort_rev_uint_least32p.o\ + qsort_rev_uint_least32p_nul.o\ + qsort_rev_uint_least64.o\ + qsort_rev_uint_least64p.o\ + qsort_rev_uint_least64p_nul.o\ + qsort_rev_uint_least8.o\ + qsort_rev_uint_least8p.o\ + qsort_rev_uint_least8p_nul.o\ + qsort_rev_uintmax.o\ + qsort_rev_uintmaxp.o\ + qsort_rev_uintmaxp_nul.o\ + qsort_rev_uintp.o\ + qsort_rev_uintp_nul.o\ + qsort_rev_uintptr.o\ + qsort_rev_uintptrp.o\ + qsort_rev_uintptrp_nul.o\ + qsort_rev_ullong.o\ + qsort_rev_ullongp.o\ + qsort_rev_ullongp_nul.o\ + qsort_rev_ulong.o\ + qsort_rev_ulongp.o\ + qsort_rev_ulongp_nul.o\ + qsort_rev_ushort.o\ + qsort_rev_ushortp.o\ + qsort_rev_ushortp_nul.o\ + qsort_schar.o\ + qsort_scharp.o\ + qsort_scharp_nul.o\ + qsort_short.o\ + qsort_shortp.o\ + qsort_shortp_nul.o\ + qsort_size.o\ + qsort_sizep.o\ + qsort_sizep_nul.o\ + qsort_ssize.o\ + qsort_ssizep.o\ + qsort_ssizep_nul.o\ + qsort_str.o\ + qsort_strp.o\ + qsort_strp_nul.o\ + qsort_uchar.o\ + qsort_ucharp.o\ + qsort_ucharp_nul.o\ + qsort_uint.o\ + qsort_uint16.o\ + qsort_uint16p.o\ + qsort_uint16p_nul.o\ + qsort_uint32.o\ + qsort_uint32p.o\ + qsort_uint32p_nul.o\ + qsort_uint64.o\ + qsort_uint64p.o\ + qsort_uint64p_nul.o\ + qsort_uint8.o\ + qsort_uint8p.o\ + qsort_uint8p_nul.o\ + qsort_uint_least16.o\ + qsort_uint_least16p.o\ + qsort_uint_least16p_nul.o\ + qsort_uint_least32.o\ + qsort_uint_least32p.o\ + qsort_uint_least32p_nul.o\ + qsort_uint_least64.o\ + qsort_uint_least64p.o\ + qsort_uint_least64p_nul.o\ + qsort_uint_least8.o\ + qsort_uint_least8p.o\ + qsort_uint_least8p_nul.o\ + qsort_uintmax.o\ + qsort_uintmaxp.o\ + qsort_uintmaxp_nul.o\ + qsort_uintp.o\ + qsort_uintp_nul.o\ + qsort_uintptr.o\ + qsort_uintptrp.o\ + qsort_uintptrp_nul.o\ + qsort_ullong.o\ + qsort_ullongp.o\ + qsort_ullongp_nul.o\ + qsort_ulong.o\ + qsort_ulongp.o\ + qsort_ulongp_nul.o\ + qsort_ushort.o\ + qsort_ushortp.o\ + qsort_ushortp_nul.o\ random_bits.o\ random_float.o\ random_signed.o\ diff --git a/cmp_doublep.c b/cmp_doublep.c new file mode 100644 index 0000000..d030e5e --- /dev/null +++ b/cmp_doublep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_doublep(const double *, const double *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_doublepp.c b/cmp_doublepp.c new file mode 100644 index 0000000..66fcc91 --- /dev/null +++ b/cmp_doublepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_doublepp(double *const *, double *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_doublepp_nul.c b/cmp_doublepp_nul.c new file mode 100644 index 0000000..06e9805 --- /dev/null +++ b/cmp_doublepp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_doublepp_nul(double *const *, double *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_floatp.c b/cmp_floatp.c new file mode 100644 index 0000000..31c68ba --- /dev/null +++ b/cmp_floatp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_floatp(const float *, const float *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_floatpp.c b/cmp_floatpp.c new file mode 100644 index 0000000..d6477ad --- /dev/null +++ b/cmp_floatpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_floatpp(float *const *, float *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_floatpp_nul.c b/cmp_floatpp_nul.c new file mode 100644 index 0000000..6976f14 --- /dev/null +++ b/cmp_floatpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_floatpp_nul(float *const *, float *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int16p.c b/cmp_int16p.c new file mode 100644 index 0000000..99842e9 --- /dev/null +++ b/cmp_int16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int16p(const int16_t *, const int16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int16pp.c b/cmp_int16pp.c new file mode 100644 index 0000000..21b8404 --- /dev/null +++ b/cmp_int16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int16pp(int16_t *const *, int16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int16pp_nul.c b/cmp_int16pp_nul.c new file mode 100644 index 0000000..19b2000 --- /dev/null +++ b/cmp_int16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int16pp_nul(int16_t *const *, int16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int32p.c b/cmp_int32p.c new file mode 100644 index 0000000..4f293c8 --- /dev/null +++ b/cmp_int32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int32p(const int32_t *, const int32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int32pp.c b/cmp_int32pp.c new file mode 100644 index 0000000..d61da1c --- /dev/null +++ b/cmp_int32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int32pp(int32_t *const *, int32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int32pp_nul.c b/cmp_int32pp_nul.c new file mode 100644 index 0000000..1bfa3e7 --- /dev/null +++ b/cmp_int32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int32pp_nul(int32_t *const *, int32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int64p.c b/cmp_int64p.c new file mode 100644 index 0000000..ccd6371 --- /dev/null +++ b/cmp_int64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int64p(const int64_t *, const int64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int64pp.c b/cmp_int64pp.c new file mode 100644 index 0000000..2b5e774 --- /dev/null +++ b/cmp_int64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int64pp(int64_t *const *, int64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int64pp_nul.c b/cmp_int64pp_nul.c new file mode 100644 index 0000000..bad0a25 --- /dev/null +++ b/cmp_int64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int64pp_nul(int64_t *const *, int64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int8p.c b/cmp_int8p.c new file mode 100644 index 0000000..703b2ac --- /dev/null +++ b/cmp_int8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int8p(const int8_t *, const int8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int8pp.c b/cmp_int8pp.c new file mode 100644 index 0000000..ae1b389 --- /dev/null +++ b/cmp_int8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int8pp(int8_t *const *, int8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int8pp_nul.c b/cmp_int8pp_nul.c new file mode 100644 index 0000000..73cc13c --- /dev/null +++ b/cmp_int8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int8pp_nul(int8_t *const *, int8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least16p.c b/cmp_int_least16p.c new file mode 100644 index 0000000..1b84a2a --- /dev/null +++ b/cmp_int_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least16p(const int_least16_t *, const int_least16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least16pp.c b/cmp_int_least16pp.c new file mode 100644 index 0000000..df174a3 --- /dev/null +++ b/cmp_int_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least16pp(int_least16_t *const *, int_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least16pp_nul.c b/cmp_int_least16pp_nul.c new file mode 100644 index 0000000..ab173cf --- /dev/null +++ b/cmp_int_least16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least16pp_nul(int_least16_t *const *, int_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least32p.c b/cmp_int_least32p.c new file mode 100644 index 0000000..f7a4d36 --- /dev/null +++ b/cmp_int_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least32p(const int_least32_t *, const int_least32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least32pp.c b/cmp_int_least32pp.c new file mode 100644 index 0000000..bc38830 --- /dev/null +++ b/cmp_int_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least32pp(int_least32_t *const *, int_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least32pp_nul.c b/cmp_int_least32pp_nul.c new file mode 100644 index 0000000..02b27f4 --- /dev/null +++ b/cmp_int_least32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least32pp_nul(int_least32_t *const *, int_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least64p.c b/cmp_int_least64p.c new file mode 100644 index 0000000..ccc9792 --- /dev/null +++ b/cmp_int_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least64p(const int_least64_t *, const int_least64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least64pp.c b/cmp_int_least64pp.c new file mode 100644 index 0000000..09c0488 --- /dev/null +++ b/cmp_int_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least64pp(int_least64_t *const *, int_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least64pp_nul.c b/cmp_int_least64pp_nul.c new file mode 100644 index 0000000..01712b1 --- /dev/null +++ b/cmp_int_least64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least64pp_nul(int_least64_t *const *, int_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least8p.c b/cmp_int_least8p.c new file mode 100644 index 0000000..f2543c3 --- /dev/null +++ b/cmp_int_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least8p(const int_least8_t *, const int_least8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least8pp.c b/cmp_int_least8pp.c new file mode 100644 index 0000000..d10a046 --- /dev/null +++ b/cmp_int_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least8pp(int_least8_t *const *, int_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_int_least8pp_nul.c b/cmp_int_least8pp_nul.c new file mode 100644 index 0000000..e4555ea --- /dev/null +++ b/cmp_int_least8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_int_least8pp_nul(int_least8_t *const *, int_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intmaxp.c b/cmp_intmaxp.c new file mode 100644 index 0000000..f169d63 --- /dev/null +++ b/cmp_intmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intmaxp(const intmax_t *, const intmax_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intmaxpp.c b/cmp_intmaxpp.c new file mode 100644 index 0000000..95b2b01 --- /dev/null +++ b/cmp_intmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intmaxpp(intmax_t *const *, intmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intmaxpp_nul.c b/cmp_intmaxpp_nul.c new file mode 100644 index 0000000..8d3e13f --- /dev/null +++ b/cmp_intmaxpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intmaxpp_nul(intmax_t *const *, intmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intp.c b/cmp_intp.c new file mode 100644 index 0000000..694417e --- /dev/null +++ b/cmp_intp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intp(const int *, const int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intpp.c b/cmp_intpp.c new file mode 100644 index 0000000..414d199 --- /dev/null +++ b/cmp_intpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intpp(int *const *, int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intpp_nul.c b/cmp_intpp_nul.c new file mode 100644 index 0000000..7767b1e --- /dev/null +++ b/cmp_intpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intpp_nul(int *const *, int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intptrp.c b/cmp_intptrp.c new file mode 100644 index 0000000..0990d95 --- /dev/null +++ b/cmp_intptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intptrp(const intptr_t *, const intptr_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intptrpp.c b/cmp_intptrpp.c new file mode 100644 index 0000000..96cd1de --- /dev/null +++ b/cmp_intptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intptrpp(intptr_t *const *, intptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_intptrpp_nul.c b/cmp_intptrpp_nul.c new file mode 100644 index 0000000..e3aadeb --- /dev/null +++ b/cmp_intptrpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_intptrpp_nul(intptr_t *const *, intptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_llongp.c b/cmp_llongp.c new file mode 100644 index 0000000..c7d39ab --- /dev/null +++ b/cmp_llongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_llongp(const long long int *, const long long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_llongpp.c b/cmp_llongpp.c new file mode 100644 index 0000000..693884b --- /dev/null +++ b/cmp_llongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_llongpp(long long int *const *, long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_llongpp_nul.c b/cmp_llongpp_nul.c new file mode 100644 index 0000000..9c78f40 --- /dev/null +++ b/cmp_llongpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_llongpp_nul(long long int *const *, long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_longp.c b/cmp_longp.c new file mode 100644 index 0000000..ea2b709 --- /dev/null +++ b/cmp_longp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_longp(const long int *, const long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_longpp.c b/cmp_longpp.c new file mode 100644 index 0000000..8bd4f2c --- /dev/null +++ b/cmp_longpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_longpp(long int *const *, long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_longpp_nul.c b/cmp_longpp_nul.c new file mode 100644 index 0000000..b1ad78a --- /dev/null +++ b/cmp_longpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_longpp_nul(long int *const *, long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_doublepp.c b/cmp_nul_doublepp.c new file mode 100644 index 0000000..33eb9b4 --- /dev/null +++ b/cmp_nul_doublepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_doublepp(double *const *, double *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_floatpp.c b/cmp_nul_floatpp.c new file mode 100644 index 0000000..d381726 --- /dev/null +++ b/cmp_nul_floatpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_floatpp(float *const *, float *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int16pp.c b/cmp_nul_int16pp.c new file mode 100644 index 0000000..47e1e7b --- /dev/null +++ b/cmp_nul_int16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int16pp(int16_t *const *, int16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int32pp.c b/cmp_nul_int32pp.c new file mode 100644 index 0000000..589dea0 --- /dev/null +++ b/cmp_nul_int32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int32pp(int32_t *const *, int32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int64pp.c b/cmp_nul_int64pp.c new file mode 100644 index 0000000..619ed36 --- /dev/null +++ b/cmp_nul_int64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int64pp(int64_t *const *, int64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int8pp.c b/cmp_nul_int8pp.c new file mode 100644 index 0000000..1c73a5c --- /dev/null +++ b/cmp_nul_int8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int8pp(int8_t *const *, int8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int_least16pp.c b/cmp_nul_int_least16pp.c new file mode 100644 index 0000000..c9caf86 --- /dev/null +++ b/cmp_nul_int_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int_least16pp(int_least16_t *const *, int_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int_least32pp.c b/cmp_nul_int_least32pp.c new file mode 100644 index 0000000..b0ec450 --- /dev/null +++ b/cmp_nul_int_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int_least32pp(int_least32_t *const *, int_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int_least64pp.c b/cmp_nul_int_least64pp.c new file mode 100644 index 0000000..95456e2 --- /dev/null +++ b/cmp_nul_int_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int_least64pp(int_least64_t *const *, int_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_int_least8pp.c b/cmp_nul_int_least8pp.c new file mode 100644 index 0000000..3941b4b --- /dev/null +++ b/cmp_nul_int_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_int_least8pp(int_least8_t *const *, int_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_intmaxpp.c b/cmp_nul_intmaxpp.c new file mode 100644 index 0000000..d7f9706 --- /dev/null +++ b/cmp_nul_intmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_intmaxpp(intmax_t *const *, intmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_intpp.c b/cmp_nul_intpp.c new file mode 100644 index 0000000..5a23115 --- /dev/null +++ b/cmp_nul_intpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_intpp(int *const *, int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_intptrpp.c b/cmp_nul_intptrpp.c new file mode 100644 index 0000000..027efbc --- /dev/null +++ b/cmp_nul_intptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_intptrpp(intptr_t *const *, intptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_llongpp.c b/cmp_nul_llongpp.c new file mode 100644 index 0000000..521c085 --- /dev/null +++ b/cmp_nul_llongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_llongpp(long long int *const *, long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_longpp.c b/cmp_nul_longpp.c new file mode 100644 index 0000000..2415d4b --- /dev/null +++ b/cmp_nul_longpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_longpp(long int *const *, long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_ptrdiffpp.c b/cmp_nul_ptrdiffpp.c new file mode 100644 index 0000000..e142217 --- /dev/null +++ b/cmp_nul_ptrdiffpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_ptrdiffpp(ptrdiff_t *const *, ptrdiff_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_doublepp.c b/cmp_nul_rev_doublepp.c new file mode 100644 index 0000000..c302861 --- /dev/null +++ b/cmp_nul_rev_doublepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_doublepp(double *const *, double *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_floatpp.c b/cmp_nul_rev_floatpp.c new file mode 100644 index 0000000..f60143d --- /dev/null +++ b/cmp_nul_rev_floatpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_floatpp(float *const *, float *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int16pp.c b/cmp_nul_rev_int16pp.c new file mode 100644 index 0000000..20c5163 --- /dev/null +++ b/cmp_nul_rev_int16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int16pp(int16_t *const *, int16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int32pp.c b/cmp_nul_rev_int32pp.c new file mode 100644 index 0000000..e85d640 --- /dev/null +++ b/cmp_nul_rev_int32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int32pp(int32_t *const *, int32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int64pp.c b/cmp_nul_rev_int64pp.c new file mode 100644 index 0000000..b0365bc --- /dev/null +++ b/cmp_nul_rev_int64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int64pp(int64_t *const *, int64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int8pp.c b/cmp_nul_rev_int8pp.c new file mode 100644 index 0000000..69fe45c --- /dev/null +++ b/cmp_nul_rev_int8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int8pp(int8_t *const *, int8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int_least16pp.c b/cmp_nul_rev_int_least16pp.c new file mode 100644 index 0000000..2d3d876 --- /dev/null +++ b/cmp_nul_rev_int_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int_least16pp(int_least16_t *const *, int_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int_least32pp.c b/cmp_nul_rev_int_least32pp.c new file mode 100644 index 0000000..b8c5e91 --- /dev/null +++ b/cmp_nul_rev_int_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int_least32pp(int_least32_t *const *, int_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int_least64pp.c b/cmp_nul_rev_int_least64pp.c new file mode 100644 index 0000000..6e5963a --- /dev/null +++ b/cmp_nul_rev_int_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int_least64pp(int_least64_t *const *, int_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_int_least8pp.c b/cmp_nul_rev_int_least8pp.c new file mode 100644 index 0000000..2ed94a6 --- /dev/null +++ b/cmp_nul_rev_int_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_int_least8pp(int_least8_t *const *, int_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_intmaxpp.c b/cmp_nul_rev_intmaxpp.c new file mode 100644 index 0000000..61a77f1 --- /dev/null +++ b/cmp_nul_rev_intmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_intmaxpp(intmax_t *const *, intmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_intpp.c b/cmp_nul_rev_intpp.c new file mode 100644 index 0000000..61a0c07 --- /dev/null +++ b/cmp_nul_rev_intpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_intpp(int *const *, int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_intptrpp.c b/cmp_nul_rev_intptrpp.c new file mode 100644 index 0000000..f4ece79 --- /dev/null +++ b/cmp_nul_rev_intptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_intptrpp(intptr_t *const *, intptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_llongpp.c b/cmp_nul_rev_llongpp.c new file mode 100644 index 0000000..0840839 --- /dev/null +++ b/cmp_nul_rev_llongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_llongpp(long long int *const *, long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_longpp.c b/cmp_nul_rev_longpp.c new file mode 100644 index 0000000..caa36eb --- /dev/null +++ b/cmp_nul_rev_longpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_longpp(long int *const *, long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_ptrdiffpp.c b/cmp_nul_rev_ptrdiffpp.c new file mode 100644 index 0000000..4545fc8 --- /dev/null +++ b/cmp_nul_rev_ptrdiffpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_ptrdiffpp(ptrdiff_t *const *, ptrdiff_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_scharpp.c b/cmp_nul_rev_scharpp.c new file mode 100644 index 0000000..8a07ce1 --- /dev/null +++ b/cmp_nul_rev_scharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_scharpp(signed char *const *, signed char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_shortpp.c b/cmp_nul_rev_shortpp.c new file mode 100644 index 0000000..dc4ad29 --- /dev/null +++ b/cmp_nul_rev_shortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_shortpp(short int *const *, short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_sizepp.c b/cmp_nul_rev_sizepp.c new file mode 100644 index 0000000..fd6c572 --- /dev/null +++ b/cmp_nul_rev_sizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_sizepp(size_t *const *, size_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_ssizepp.c b/cmp_nul_rev_ssizepp.c new file mode 100644 index 0000000..9a89134 --- /dev/null +++ b/cmp_nul_rev_ssizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_ssizepp(ssize_t *const *, ssize_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_strpp.c b/cmp_nul_rev_strpp.c new file mode 100644 index 0000000..50d971d --- /dev/null +++ b/cmp_nul_rev_strpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_strpp(const char **const *, const char **const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_ucharpp.c b/cmp_nul_rev_ucharpp.c new file mode 100644 index 0000000..dd5340b --- /dev/null +++ b/cmp_nul_rev_ucharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_ucharpp(unsigned char *const *, unsigned char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint16pp.c b/cmp_nul_rev_uint16pp.c new file mode 100644 index 0000000..6d539f8 --- /dev/null +++ b/cmp_nul_rev_uint16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint16pp(uint16_t *const *, uint16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint32pp.c b/cmp_nul_rev_uint32pp.c new file mode 100644 index 0000000..a949f5b --- /dev/null +++ b/cmp_nul_rev_uint32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint32pp(uint32_t *const *, uint32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint64pp.c b/cmp_nul_rev_uint64pp.c new file mode 100644 index 0000000..ac25b59 --- /dev/null +++ b/cmp_nul_rev_uint64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint64pp(uint64_t *const *, uint64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint8pp.c b/cmp_nul_rev_uint8pp.c new file mode 100644 index 0000000..7033c77 --- /dev/null +++ b/cmp_nul_rev_uint8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint8pp(uint8_t *const *, uint8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint_least16pp.c b/cmp_nul_rev_uint_least16pp.c new file mode 100644 index 0000000..4e6124e --- /dev/null +++ b/cmp_nul_rev_uint_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint_least16pp(uint_least16_t *const *, uint_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint_least32pp.c b/cmp_nul_rev_uint_least32pp.c new file mode 100644 index 0000000..68d9a30 --- /dev/null +++ b/cmp_nul_rev_uint_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint_least32pp(uint_least32_t *const *, uint_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint_least64pp.c b/cmp_nul_rev_uint_least64pp.c new file mode 100644 index 0000000..74a01be --- /dev/null +++ b/cmp_nul_rev_uint_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint_least64pp(uint_least64_t *const *, uint_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uint_least8pp.c b/cmp_nul_rev_uint_least8pp.c new file mode 100644 index 0000000..c05a64a --- /dev/null +++ b/cmp_nul_rev_uint_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uint_least8pp(uint_least8_t *const *, uint_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uintmaxpp.c b/cmp_nul_rev_uintmaxpp.c new file mode 100644 index 0000000..4da16ce --- /dev/null +++ b/cmp_nul_rev_uintmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uintmaxpp(uintmax_t *const *, uintmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uintpp.c b/cmp_nul_rev_uintpp.c new file mode 100644 index 0000000..4749b32 --- /dev/null +++ b/cmp_nul_rev_uintpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uintpp(unsigned int *const *, unsigned int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_uintptrpp.c b/cmp_nul_rev_uintptrpp.c new file mode 100644 index 0000000..3e37da3 --- /dev/null +++ b/cmp_nul_rev_uintptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_uintptrpp(uintptr_t *const *, uintptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_ullongpp.c b/cmp_nul_rev_ullongpp.c new file mode 100644 index 0000000..0814afb --- /dev/null +++ b/cmp_nul_rev_ullongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_ullongpp(unsigned long long int *const *, unsigned long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_ulongpp.c b/cmp_nul_rev_ulongpp.c new file mode 100644 index 0000000..15bac47 --- /dev/null +++ b/cmp_nul_rev_ulongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_ulongpp(unsigned long int *const *, unsigned long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_rev_ushortpp.c b/cmp_nul_rev_ushortpp.c new file mode 100644 index 0000000..24af8ad --- /dev/null +++ b/cmp_nul_rev_ushortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_rev_ushortpp(unsigned short int *const *, unsigned short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_scharpp.c b/cmp_nul_scharpp.c new file mode 100644 index 0000000..473dc7f --- /dev/null +++ b/cmp_nul_scharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_scharpp(signed char *const *, signed char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_shortpp.c b/cmp_nul_shortpp.c new file mode 100644 index 0000000..bcb88ec --- /dev/null +++ b/cmp_nul_shortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_shortpp(short int *const *, short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_sizepp.c b/cmp_nul_sizepp.c new file mode 100644 index 0000000..33d5dce --- /dev/null +++ b/cmp_nul_sizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_sizepp(size_t *const *, size_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_ssizepp.c b/cmp_nul_ssizepp.c new file mode 100644 index 0000000..b3fd7d1 --- /dev/null +++ b/cmp_nul_ssizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_ssizepp(ssize_t *const *, ssize_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_strpp.c b/cmp_nul_strpp.c new file mode 100644 index 0000000..36c330a --- /dev/null +++ b/cmp_nul_strpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_strpp(const char **const *, const char **const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_ucharpp.c b/cmp_nul_ucharpp.c new file mode 100644 index 0000000..c55c595 --- /dev/null +++ b/cmp_nul_ucharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_ucharpp(unsigned char *const *, unsigned char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint16pp.c b/cmp_nul_uint16pp.c new file mode 100644 index 0000000..6fddf2a --- /dev/null +++ b/cmp_nul_uint16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint16pp(uint16_t *const *, uint16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint32pp.c b/cmp_nul_uint32pp.c new file mode 100644 index 0000000..2337322 --- /dev/null +++ b/cmp_nul_uint32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint32pp(uint32_t *const *, uint32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint64pp.c b/cmp_nul_uint64pp.c new file mode 100644 index 0000000..3676996 --- /dev/null +++ b/cmp_nul_uint64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint64pp(uint64_t *const *, uint64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint8pp.c b/cmp_nul_uint8pp.c new file mode 100644 index 0000000..7777887 --- /dev/null +++ b/cmp_nul_uint8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint8pp(uint8_t *const *, uint8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint_least16pp.c b/cmp_nul_uint_least16pp.c new file mode 100644 index 0000000..36008fe --- /dev/null +++ b/cmp_nul_uint_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint_least16pp(uint_least16_t *const *, uint_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint_least32pp.c b/cmp_nul_uint_least32pp.c new file mode 100644 index 0000000..26f14f5 --- /dev/null +++ b/cmp_nul_uint_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint_least32pp(uint_least32_t *const *, uint_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint_least64pp.c b/cmp_nul_uint_least64pp.c new file mode 100644 index 0000000..35179e0 --- /dev/null +++ b/cmp_nul_uint_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint_least64pp(uint_least64_t *const *, uint_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uint_least8pp.c b/cmp_nul_uint_least8pp.c new file mode 100644 index 0000000..3c2f59d --- /dev/null +++ b/cmp_nul_uint_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uint_least8pp(uint_least8_t *const *, uint_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uintmaxpp.c b/cmp_nul_uintmaxpp.c new file mode 100644 index 0000000..21fa717 --- /dev/null +++ b/cmp_nul_uintmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uintmaxpp(uintmax_t *const *, uintmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uintpp.c b/cmp_nul_uintpp.c new file mode 100644 index 0000000..6aa50a4 --- /dev/null +++ b/cmp_nul_uintpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uintpp(unsigned int *const *, unsigned int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_uintptrpp.c b/cmp_nul_uintptrpp.c new file mode 100644 index 0000000..39acfeb --- /dev/null +++ b/cmp_nul_uintptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_uintptrpp(uintptr_t *const *, uintptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_ullongpp.c b/cmp_nul_ullongpp.c new file mode 100644 index 0000000..45995d2 --- /dev/null +++ b/cmp_nul_ullongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_ullongpp(unsigned long long int *const *, unsigned long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_ulongpp.c b/cmp_nul_ulongpp.c new file mode 100644 index 0000000..f9d54ed --- /dev/null +++ b/cmp_nul_ulongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_ulongpp(unsigned long int *const *, unsigned long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_nul_ushortpp.c b/cmp_nul_ushortpp.c new file mode 100644 index 0000000..0e09c95 --- /dev/null +++ b/cmp_nul_ushortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_nul_ushortpp(unsigned short int *const *, unsigned short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ptrdiffp.c b/cmp_ptrdiffp.c new file mode 100644 index 0000000..a1a5a9a --- /dev/null +++ b/cmp_ptrdiffp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ptrdiffp(const ptrdiff_t *, const ptrdiff_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ptrdiffpp.c b/cmp_ptrdiffpp.c new file mode 100644 index 0000000..045b0d3 --- /dev/null +++ b/cmp_ptrdiffpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ptrdiffpp(ptrdiff_t *const *, ptrdiff_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ptrdiffpp_nul.c b/cmp_ptrdiffpp_nul.c new file mode 100644 index 0000000..e6a7645 --- /dev/null +++ b/cmp_ptrdiffpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ptrdiffpp_nul(ptrdiff_t *const *, ptrdiff_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_doublep.c b/cmp_rev_doublep.c new file mode 100644 index 0000000..b70ed4a --- /dev/null +++ b/cmp_rev_doublep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_doublep(const double *, const double *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_doublepp.c b/cmp_rev_doublepp.c new file mode 100644 index 0000000..ab16d7e --- /dev/null +++ b/cmp_rev_doublepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_doublepp(double *const *, double *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_doublepp_nul.c b/cmp_rev_doublepp_nul.c new file mode 100644 index 0000000..8729f5d --- /dev/null +++ b/cmp_rev_doublepp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_doublepp_nul(double *const *, double *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_floatp.c b/cmp_rev_floatp.c new file mode 100644 index 0000000..1d272f9 --- /dev/null +++ b/cmp_rev_floatp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_floatp(const float *, const float *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_floatpp.c b/cmp_rev_floatpp.c new file mode 100644 index 0000000..4179709 --- /dev/null +++ b/cmp_rev_floatpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_floatpp(float *const *, float *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_floatpp_nul.c b/cmp_rev_floatpp_nul.c new file mode 100644 index 0000000..c1728c8 --- /dev/null +++ b/cmp_rev_floatpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_floatpp_nul(float *const *, float *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int16p.c b/cmp_rev_int16p.c new file mode 100644 index 0000000..f97ba2c --- /dev/null +++ b/cmp_rev_int16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int16p(const int16_t *, const int16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int16pp.c b/cmp_rev_int16pp.c new file mode 100644 index 0000000..6bd6566 --- /dev/null +++ b/cmp_rev_int16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int16pp(int16_t *const *, int16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int16pp_nul.c b/cmp_rev_int16pp_nul.c new file mode 100644 index 0000000..9127d2a --- /dev/null +++ b/cmp_rev_int16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int16pp_nul(int16_t *const *, int16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int32p.c b/cmp_rev_int32p.c new file mode 100644 index 0000000..f358da5 --- /dev/null +++ b/cmp_rev_int32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int32p(const int32_t *, const int32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int32pp.c b/cmp_rev_int32pp.c new file mode 100644 index 0000000..c7a4695 --- /dev/null +++ b/cmp_rev_int32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int32pp(int32_t *const *, int32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int32pp_nul.c b/cmp_rev_int32pp_nul.c new file mode 100644 index 0000000..7556092 --- /dev/null +++ b/cmp_rev_int32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int32pp_nul(int32_t *const *, int32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int64p.c b/cmp_rev_int64p.c new file mode 100644 index 0000000..ccc9e7a --- /dev/null +++ b/cmp_rev_int64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int64p(const int64_t *, const int64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int64pp.c b/cmp_rev_int64pp.c new file mode 100644 index 0000000..8b38360 --- /dev/null +++ b/cmp_rev_int64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int64pp(int64_t *const *, int64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int64pp_nul.c b/cmp_rev_int64pp_nul.c new file mode 100644 index 0000000..b1211c8 --- /dev/null +++ b/cmp_rev_int64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int64pp_nul(int64_t *const *, int64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int8p.c b/cmp_rev_int8p.c new file mode 100644 index 0000000..b24fb94 --- /dev/null +++ b/cmp_rev_int8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int8p(const int8_t *, const int8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int8pp.c b/cmp_rev_int8pp.c new file mode 100644 index 0000000..7636136 --- /dev/null +++ b/cmp_rev_int8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int8pp(int8_t *const *, int8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int8pp_nul.c b/cmp_rev_int8pp_nul.c new file mode 100644 index 0000000..912dc7c --- /dev/null +++ b/cmp_rev_int8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int8pp_nul(int8_t *const *, int8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least16p.c b/cmp_rev_int_least16p.c new file mode 100644 index 0000000..e01a421 --- /dev/null +++ b/cmp_rev_int_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least16p(const int_least16_t *, const int_least16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least16pp.c b/cmp_rev_int_least16pp.c new file mode 100644 index 0000000..d717fe5 --- /dev/null +++ b/cmp_rev_int_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least16pp(int_least16_t *const *, int_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least16pp_nul.c b/cmp_rev_int_least16pp_nul.c new file mode 100644 index 0000000..c8f4a0c --- /dev/null +++ b/cmp_rev_int_least16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least16pp_nul(int_least16_t *const *, int_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least32p.c b/cmp_rev_int_least32p.c new file mode 100644 index 0000000..69d0d78 --- /dev/null +++ b/cmp_rev_int_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least32p(const int_least32_t *, const int_least32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least32pp.c b/cmp_rev_int_least32pp.c new file mode 100644 index 0000000..0f91f78 --- /dev/null +++ b/cmp_rev_int_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least32pp(int_least32_t *const *, int_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least32pp_nul.c b/cmp_rev_int_least32pp_nul.c new file mode 100644 index 0000000..1c48979 --- /dev/null +++ b/cmp_rev_int_least32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least32pp_nul(int_least32_t *const *, int_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least64p.c b/cmp_rev_int_least64p.c new file mode 100644 index 0000000..7eeb6e4 --- /dev/null +++ b/cmp_rev_int_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least64p(const int_least64_t *, const int_least64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least64pp.c b/cmp_rev_int_least64pp.c new file mode 100644 index 0000000..19cd8bb --- /dev/null +++ b/cmp_rev_int_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least64pp(int_least64_t *const *, int_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least64pp_nul.c b/cmp_rev_int_least64pp_nul.c new file mode 100644 index 0000000..c9e5002 --- /dev/null +++ b/cmp_rev_int_least64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least64pp_nul(int_least64_t *const *, int_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least8p.c b/cmp_rev_int_least8p.c new file mode 100644 index 0000000..2e53c19 --- /dev/null +++ b/cmp_rev_int_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least8p(const int_least8_t *, const int_least8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least8pp.c b/cmp_rev_int_least8pp.c new file mode 100644 index 0000000..44ed1d3 --- /dev/null +++ b/cmp_rev_int_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least8pp(int_least8_t *const *, int_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_int_least8pp_nul.c b/cmp_rev_int_least8pp_nul.c new file mode 100644 index 0000000..9030bea --- /dev/null +++ b/cmp_rev_int_least8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_int_least8pp_nul(int_least8_t *const *, int_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intmaxp.c b/cmp_rev_intmaxp.c new file mode 100644 index 0000000..8da025f --- /dev/null +++ b/cmp_rev_intmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intmaxp(const intmax_t *, const intmax_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intmaxpp.c b/cmp_rev_intmaxpp.c new file mode 100644 index 0000000..1bf256b --- /dev/null +++ b/cmp_rev_intmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intmaxpp(intmax_t *const *, intmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intmaxpp_nul.c b/cmp_rev_intmaxpp_nul.c new file mode 100644 index 0000000..a3daf78 --- /dev/null +++ b/cmp_rev_intmaxpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intmaxpp_nul(intmax_t *const *, intmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intp.c b/cmp_rev_intp.c new file mode 100644 index 0000000..fc40da2 --- /dev/null +++ b/cmp_rev_intp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intp(const int *, const int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intpp.c b/cmp_rev_intpp.c new file mode 100644 index 0000000..3cdd0f4 --- /dev/null +++ b/cmp_rev_intpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intpp(int *const *, int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intpp_nul.c b/cmp_rev_intpp_nul.c new file mode 100644 index 0000000..2ddb7c3 --- /dev/null +++ b/cmp_rev_intpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intpp_nul(int *const *, int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intptrp.c b/cmp_rev_intptrp.c new file mode 100644 index 0000000..6dcd8af --- /dev/null +++ b/cmp_rev_intptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intptrp(const intptr_t *, const intptr_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intptrpp.c b/cmp_rev_intptrpp.c new file mode 100644 index 0000000..fe7b7df --- /dev/null +++ b/cmp_rev_intptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intptrpp(intptr_t *const *, intptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_intptrpp_nul.c b/cmp_rev_intptrpp_nul.c new file mode 100644 index 0000000..07947da --- /dev/null +++ b/cmp_rev_intptrpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_intptrpp_nul(intptr_t *const *, intptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_llongp.c b/cmp_rev_llongp.c new file mode 100644 index 0000000..11d0f17 --- /dev/null +++ b/cmp_rev_llongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_llongp(const long long int *, const long long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_llongpp.c b/cmp_rev_llongpp.c new file mode 100644 index 0000000..f4c33ae --- /dev/null +++ b/cmp_rev_llongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_llongpp(long long int *const *, long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_llongpp_nul.c b/cmp_rev_llongpp_nul.c new file mode 100644 index 0000000..f33f316 --- /dev/null +++ b/cmp_rev_llongpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_llongpp_nul(long long int *const *, long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_longp.c b/cmp_rev_longp.c new file mode 100644 index 0000000..b825d87 --- /dev/null +++ b/cmp_rev_longp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_longp(const long int *, const long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_longpp.c b/cmp_rev_longpp.c new file mode 100644 index 0000000..4f98c1e --- /dev/null +++ b/cmp_rev_longpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_longpp(long int *const *, long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_longpp_nul.c b/cmp_rev_longpp_nul.c new file mode 100644 index 0000000..4452f2b --- /dev/null +++ b/cmp_rev_longpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_longpp_nul(long int *const *, long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ptrdiffp.c b/cmp_rev_ptrdiffp.c new file mode 100644 index 0000000..4c284f5 --- /dev/null +++ b/cmp_rev_ptrdiffp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ptrdiffp(const ptrdiff_t *, const ptrdiff_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ptrdiffpp.c b/cmp_rev_ptrdiffpp.c new file mode 100644 index 0000000..3fb541e --- /dev/null +++ b/cmp_rev_ptrdiffpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ptrdiffpp(ptrdiff_t *const *, ptrdiff_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ptrdiffpp_nul.c b/cmp_rev_ptrdiffpp_nul.c new file mode 100644 index 0000000..1da28e9 --- /dev/null +++ b/cmp_rev_ptrdiffpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ptrdiffpp_nul(ptrdiff_t *const *, ptrdiff_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_scharp.c b/cmp_rev_scharp.c new file mode 100644 index 0000000..627eb25 --- /dev/null +++ b/cmp_rev_scharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_scharp(const signed char *, const signed char *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_scharpp.c b/cmp_rev_scharpp.c new file mode 100644 index 0000000..37586e7 --- /dev/null +++ b/cmp_rev_scharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_scharpp(signed char *const *, signed char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_scharpp_nul.c b/cmp_rev_scharpp_nul.c new file mode 100644 index 0000000..153cdce --- /dev/null +++ b/cmp_rev_scharpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_scharpp_nul(signed char *const *, signed char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_shortp.c b/cmp_rev_shortp.c new file mode 100644 index 0000000..85cbae6 --- /dev/null +++ b/cmp_rev_shortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_shortp(const short int *, const short int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_shortpp.c b/cmp_rev_shortpp.c new file mode 100644 index 0000000..0bae722 --- /dev/null +++ b/cmp_rev_shortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_shortpp(short int *const *, short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_shortpp_nul.c b/cmp_rev_shortpp_nul.c new file mode 100644 index 0000000..d11caa8 --- /dev/null +++ b/cmp_rev_shortpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_shortpp_nul(short int *const *, short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_sizep.c b/cmp_rev_sizep.c new file mode 100644 index 0000000..e9582ff --- /dev/null +++ b/cmp_rev_sizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_sizep(const size_t *, const size_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_sizepp.c b/cmp_rev_sizepp.c new file mode 100644 index 0000000..c78bbf2 --- /dev/null +++ b/cmp_rev_sizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_sizepp(size_t *const *, size_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_sizepp_nul.c b/cmp_rev_sizepp_nul.c new file mode 100644 index 0000000..b9485f6 --- /dev/null +++ b/cmp_rev_sizepp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_sizepp_nul(size_t *const *, size_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ssizep.c b/cmp_rev_ssizep.c new file mode 100644 index 0000000..49eb262 --- /dev/null +++ b/cmp_rev_ssizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ssizep(const ssize_t *, const ssize_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ssizepp.c b/cmp_rev_ssizepp.c new file mode 100644 index 0000000..d221585 --- /dev/null +++ b/cmp_rev_ssizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ssizepp(ssize_t *const *, ssize_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ssizepp_nul.c b/cmp_rev_ssizepp_nul.c new file mode 100644 index 0000000..f11b0d6 --- /dev/null +++ b/cmp_rev_ssizepp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ssizepp_nul(ssize_t *const *, ssize_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_strp.c b/cmp_rev_strp.c new file mode 100644 index 0000000..33581b0 --- /dev/null +++ b/cmp_rev_strp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_strp(const char *const *, const char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_strpp.c b/cmp_rev_strpp.c new file mode 100644 index 0000000..ad0aa19 --- /dev/null +++ b/cmp_rev_strpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_strpp(const char **const *, const char **const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_strpp_nul.c b/cmp_rev_strpp_nul.c new file mode 100644 index 0000000..64785d5 --- /dev/null +++ b/cmp_rev_strpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_strpp_nul(const char **const *, const char **const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ucharp.c b/cmp_rev_ucharp.c new file mode 100644 index 0000000..9c53015 --- /dev/null +++ b/cmp_rev_ucharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ucharp(const unsigned char *, const unsigned char *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ucharpp.c b/cmp_rev_ucharpp.c new file mode 100644 index 0000000..1b5a84b --- /dev/null +++ b/cmp_rev_ucharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ucharpp(unsigned char *const *, unsigned char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ucharpp_nul.c b/cmp_rev_ucharpp_nul.c new file mode 100644 index 0000000..1f45a98 --- /dev/null +++ b/cmp_rev_ucharpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ucharpp_nul(unsigned char *const *, unsigned char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint16p.c b/cmp_rev_uint16p.c new file mode 100644 index 0000000..a7ffee0 --- /dev/null +++ b/cmp_rev_uint16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint16p(const uint16_t *, const uint16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint16pp.c b/cmp_rev_uint16pp.c new file mode 100644 index 0000000..00b86b1 --- /dev/null +++ b/cmp_rev_uint16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint16pp(uint16_t *const *, uint16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint16pp_nul.c b/cmp_rev_uint16pp_nul.c new file mode 100644 index 0000000..dcbb051 --- /dev/null +++ b/cmp_rev_uint16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint16pp_nul(uint16_t *const *, uint16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint32p.c b/cmp_rev_uint32p.c new file mode 100644 index 0000000..6d67b6b --- /dev/null +++ b/cmp_rev_uint32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint32p(const uint32_t *, const uint32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint32pp.c b/cmp_rev_uint32pp.c new file mode 100644 index 0000000..7783be6 --- /dev/null +++ b/cmp_rev_uint32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint32pp(uint32_t *const *, uint32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint32pp_nul.c b/cmp_rev_uint32pp_nul.c new file mode 100644 index 0000000..e7e42ce --- /dev/null +++ b/cmp_rev_uint32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint32pp_nul(uint32_t *const *, uint32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint64p.c b/cmp_rev_uint64p.c new file mode 100644 index 0000000..9d904b0 --- /dev/null +++ b/cmp_rev_uint64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint64p(const uint64_t *, const uint64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint64pp.c b/cmp_rev_uint64pp.c new file mode 100644 index 0000000..e1bd381 --- /dev/null +++ b/cmp_rev_uint64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint64pp(uint64_t *const *, uint64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint64pp_nul.c b/cmp_rev_uint64pp_nul.c new file mode 100644 index 0000000..b9b93ae --- /dev/null +++ b/cmp_rev_uint64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint64pp_nul(uint64_t *const *, uint64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint8p.c b/cmp_rev_uint8p.c new file mode 100644 index 0000000..eb946c5 --- /dev/null +++ b/cmp_rev_uint8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint8p(const uint8_t *, const uint8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint8pp.c b/cmp_rev_uint8pp.c new file mode 100644 index 0000000..fe0f0e4 --- /dev/null +++ b/cmp_rev_uint8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint8pp(uint8_t *const *, uint8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint8pp_nul.c b/cmp_rev_uint8pp_nul.c new file mode 100644 index 0000000..68f2ec2 --- /dev/null +++ b/cmp_rev_uint8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint8pp_nul(uint8_t *const *, uint8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least16p.c b/cmp_rev_uint_least16p.c new file mode 100644 index 0000000..4596c92 --- /dev/null +++ b/cmp_rev_uint_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least16p(const uint_least16_t *, const uint_least16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least16pp.c b/cmp_rev_uint_least16pp.c new file mode 100644 index 0000000..0c6811c --- /dev/null +++ b/cmp_rev_uint_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least16pp(uint_least16_t *const *, uint_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least16pp_nul.c b/cmp_rev_uint_least16pp_nul.c new file mode 100644 index 0000000..aff77a1 --- /dev/null +++ b/cmp_rev_uint_least16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least16pp_nul(uint_least16_t *const *, uint_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least32p.c b/cmp_rev_uint_least32p.c new file mode 100644 index 0000000..a93425b --- /dev/null +++ b/cmp_rev_uint_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least32p(const uint_least32_t *, const uint_least32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least32pp.c b/cmp_rev_uint_least32pp.c new file mode 100644 index 0000000..adab72a --- /dev/null +++ b/cmp_rev_uint_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least32pp(uint_least32_t *const *, uint_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least32pp_nul.c b/cmp_rev_uint_least32pp_nul.c new file mode 100644 index 0000000..c171749 --- /dev/null +++ b/cmp_rev_uint_least32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least32pp_nul(uint_least32_t *const *, uint_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least64p.c b/cmp_rev_uint_least64p.c new file mode 100644 index 0000000..92470bf --- /dev/null +++ b/cmp_rev_uint_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least64p(const uint_least64_t *, const uint_least64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least64pp.c b/cmp_rev_uint_least64pp.c new file mode 100644 index 0000000..2bae149 --- /dev/null +++ b/cmp_rev_uint_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least64pp(uint_least64_t *const *, uint_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least64pp_nul.c b/cmp_rev_uint_least64pp_nul.c new file mode 100644 index 0000000..59cee30 --- /dev/null +++ b/cmp_rev_uint_least64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least64pp_nul(uint_least64_t *const *, uint_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least8p.c b/cmp_rev_uint_least8p.c new file mode 100644 index 0000000..b4914e1 --- /dev/null +++ b/cmp_rev_uint_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least8p(const uint_least8_t *, const uint_least8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least8pp.c b/cmp_rev_uint_least8pp.c new file mode 100644 index 0000000..16c4824 --- /dev/null +++ b/cmp_rev_uint_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least8pp(uint_least8_t *const *, uint_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uint_least8pp_nul.c b/cmp_rev_uint_least8pp_nul.c new file mode 100644 index 0000000..2c582b7 --- /dev/null +++ b/cmp_rev_uint_least8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uint_least8pp_nul(uint_least8_t *const *, uint_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintmaxp.c b/cmp_rev_uintmaxp.c new file mode 100644 index 0000000..18973e3 --- /dev/null +++ b/cmp_rev_uintmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintmaxp(const uintmax_t *, const uintmax_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintmaxpp.c b/cmp_rev_uintmaxpp.c new file mode 100644 index 0000000..228c6ec --- /dev/null +++ b/cmp_rev_uintmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintmaxpp(uintmax_t *const *, uintmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintmaxpp_nul.c b/cmp_rev_uintmaxpp_nul.c new file mode 100644 index 0000000..3801749 --- /dev/null +++ b/cmp_rev_uintmaxpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintmaxpp_nul(uintmax_t *const *, uintmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintp.c b/cmp_rev_uintp.c new file mode 100644 index 0000000..5076144 --- /dev/null +++ b/cmp_rev_uintp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintp(const unsigned int *, const unsigned int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintpp.c b/cmp_rev_uintpp.c new file mode 100644 index 0000000..903a823 --- /dev/null +++ b/cmp_rev_uintpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintpp(unsigned int *const *, unsigned int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintpp_nul.c b/cmp_rev_uintpp_nul.c new file mode 100644 index 0000000..1092bda --- /dev/null +++ b/cmp_rev_uintpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintpp_nul(unsigned int *const *, unsigned int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintptrp.c b/cmp_rev_uintptrp.c new file mode 100644 index 0000000..543fc4c --- /dev/null +++ b/cmp_rev_uintptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintptrp(const uintptr_t *, const uintptr_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintptrpp.c b/cmp_rev_uintptrpp.c new file mode 100644 index 0000000..4313975 --- /dev/null +++ b/cmp_rev_uintptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintptrpp(uintptr_t *const *, uintptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_uintptrpp_nul.c b/cmp_rev_uintptrpp_nul.c new file mode 100644 index 0000000..36068ca --- /dev/null +++ b/cmp_rev_uintptrpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_uintptrpp_nul(uintptr_t *const *, uintptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ullongp.c b/cmp_rev_ullongp.c new file mode 100644 index 0000000..405a871 --- /dev/null +++ b/cmp_rev_ullongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ullongp(const unsigned long long int *, const unsigned long long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ullongpp.c b/cmp_rev_ullongpp.c new file mode 100644 index 0000000..624b726 --- /dev/null +++ b/cmp_rev_ullongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ullongpp(unsigned long long int *const *, unsigned long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ullongpp_nul.c b/cmp_rev_ullongpp_nul.c new file mode 100644 index 0000000..f48b88e --- /dev/null +++ b/cmp_rev_ullongpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ullongpp_nul(unsigned long long int *const *, unsigned long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ulongp.c b/cmp_rev_ulongp.c new file mode 100644 index 0000000..50605b7 --- /dev/null +++ b/cmp_rev_ulongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ulongp(const unsigned long int *, const unsigned long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ulongpp.c b/cmp_rev_ulongpp.c new file mode 100644 index 0000000..81fb3f9 --- /dev/null +++ b/cmp_rev_ulongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ulongpp(unsigned long int *const *, unsigned long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ulongpp_nul.c b/cmp_rev_ulongpp_nul.c new file mode 100644 index 0000000..00e98a5 --- /dev/null +++ b/cmp_rev_ulongpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ulongpp_nul(unsigned long int *const *, unsigned long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ushortp.c b/cmp_rev_ushortp.c new file mode 100644 index 0000000..19bf7cb --- /dev/null +++ b/cmp_rev_ushortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ushortp(const unsigned short int *, const unsigned short int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ushortpp.c b/cmp_rev_ushortpp.c new file mode 100644 index 0000000..9f9365c --- /dev/null +++ b/cmp_rev_ushortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ushortpp(unsigned short int *const *, unsigned short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_rev_ushortpp_nul.c b/cmp_rev_ushortpp_nul.c new file mode 100644 index 0000000..5e6bfc1 --- /dev/null +++ b/cmp_rev_ushortpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_rev_ushortpp_nul(unsigned short int *const *, unsigned short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_scharp.c b/cmp_scharp.c new file mode 100644 index 0000000..68ab678 --- /dev/null +++ b/cmp_scharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_scharp(const signed char *, const signed char *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_scharpp.c b/cmp_scharpp.c new file mode 100644 index 0000000..0cc6da8 --- /dev/null +++ b/cmp_scharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_scharpp(signed char *const *, signed char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_scharpp_nul.c b/cmp_scharpp_nul.c new file mode 100644 index 0000000..8cc6984 --- /dev/null +++ b/cmp_scharpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_scharpp_nul(signed char *const *, signed char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_shortp.c b/cmp_shortp.c new file mode 100644 index 0000000..cae9856 --- /dev/null +++ b/cmp_shortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_shortp(const short int *, const short int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_shortpp.c b/cmp_shortpp.c new file mode 100644 index 0000000..520d997 --- /dev/null +++ b/cmp_shortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_shortpp(short int *const *, short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_shortpp_nul.c b/cmp_shortpp_nul.c new file mode 100644 index 0000000..5a42ae8 --- /dev/null +++ b/cmp_shortpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_shortpp_nul(short int *const *, short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_sizep.c b/cmp_sizep.c new file mode 100644 index 0000000..ea2aae7 --- /dev/null +++ b/cmp_sizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_sizep(const size_t *, const size_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_sizepp.c b/cmp_sizepp.c new file mode 100644 index 0000000..90e0447 --- /dev/null +++ b/cmp_sizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_sizepp(size_t *const *, size_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_sizepp_nul.c b/cmp_sizepp_nul.c new file mode 100644 index 0000000..d33830b --- /dev/null +++ b/cmp_sizepp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_sizepp_nul(size_t *const *, size_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ssizep.c b/cmp_ssizep.c new file mode 100644 index 0000000..924b99a --- /dev/null +++ b/cmp_ssizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ssizep(const ssize_t *, const ssize_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ssizepp.c b/cmp_ssizepp.c new file mode 100644 index 0000000..e7decfe --- /dev/null +++ b/cmp_ssizepp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ssizepp(ssize_t *const *, ssize_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ssizepp_nul.c b/cmp_ssizepp_nul.c new file mode 100644 index 0000000..0bf0501 --- /dev/null +++ b/cmp_ssizepp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ssizepp_nul(ssize_t *const *, ssize_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_strp.c b/cmp_strp.c new file mode 100644 index 0000000..7cb1ab6 --- /dev/null +++ b/cmp_strp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_strp(const char *const *, const char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_strpp.c b/cmp_strpp.c new file mode 100644 index 0000000..1d0088b --- /dev/null +++ b/cmp_strpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_strpp(const char **const *, const char **const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_strpp_nul.c b/cmp_strpp_nul.c new file mode 100644 index 0000000..be2c64d --- /dev/null +++ b/cmp_strpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_strpp_nul(const char **const *, const char **const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ucharp.c b/cmp_ucharp.c new file mode 100644 index 0000000..c30f8d5 --- /dev/null +++ b/cmp_ucharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ucharp(const unsigned char *, const unsigned char *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ucharpp.c b/cmp_ucharpp.c new file mode 100644 index 0000000..b256ddb --- /dev/null +++ b/cmp_ucharpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ucharpp(unsigned char *const *, unsigned char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ucharpp_nul.c b/cmp_ucharpp_nul.c new file mode 100644 index 0000000..23e8d61 --- /dev/null +++ b/cmp_ucharpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ucharpp_nul(unsigned char *const *, unsigned char *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint16p.c b/cmp_uint16p.c new file mode 100644 index 0000000..a3794d2 --- /dev/null +++ b/cmp_uint16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint16p(const uint16_t *, const uint16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint16pp.c b/cmp_uint16pp.c new file mode 100644 index 0000000..eda7ad6 --- /dev/null +++ b/cmp_uint16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint16pp(uint16_t *const *, uint16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint16pp_nul.c b/cmp_uint16pp_nul.c new file mode 100644 index 0000000..8e3278f --- /dev/null +++ b/cmp_uint16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint16pp_nul(uint16_t *const *, uint16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint32p.c b/cmp_uint32p.c new file mode 100644 index 0000000..7d6f401 --- /dev/null +++ b/cmp_uint32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint32p(const uint32_t *, const uint32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint32pp.c b/cmp_uint32pp.c new file mode 100644 index 0000000..61a80f5 --- /dev/null +++ b/cmp_uint32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint32pp(uint32_t *const *, uint32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint32pp_nul.c b/cmp_uint32pp_nul.c new file mode 100644 index 0000000..a0517f1 --- /dev/null +++ b/cmp_uint32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint32pp_nul(uint32_t *const *, uint32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint64p.c b/cmp_uint64p.c new file mode 100644 index 0000000..f31b213 --- /dev/null +++ b/cmp_uint64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint64p(const uint64_t *, const uint64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint64pp.c b/cmp_uint64pp.c new file mode 100644 index 0000000..d525637 --- /dev/null +++ b/cmp_uint64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint64pp(uint64_t *const *, uint64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint64pp_nul.c b/cmp_uint64pp_nul.c new file mode 100644 index 0000000..08e4067 --- /dev/null +++ b/cmp_uint64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint64pp_nul(uint64_t *const *, uint64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint8p.c b/cmp_uint8p.c new file mode 100644 index 0000000..e5c2e05 --- /dev/null +++ b/cmp_uint8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint8p(const uint8_t *, const uint8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint8pp.c b/cmp_uint8pp.c new file mode 100644 index 0000000..c044966 --- /dev/null +++ b/cmp_uint8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint8pp(uint8_t *const *, uint8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint8pp_nul.c b/cmp_uint8pp_nul.c new file mode 100644 index 0000000..ecc7b17 --- /dev/null +++ b/cmp_uint8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint8pp_nul(uint8_t *const *, uint8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least16p.c b/cmp_uint_least16p.c new file mode 100644 index 0000000..54abb0e --- /dev/null +++ b/cmp_uint_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least16p(const uint_least16_t *, const uint_least16_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least16pp.c b/cmp_uint_least16pp.c new file mode 100644 index 0000000..84bb06f --- /dev/null +++ b/cmp_uint_least16pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least16pp(uint_least16_t *const *, uint_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least16pp_nul.c b/cmp_uint_least16pp_nul.c new file mode 100644 index 0000000..bed23bb --- /dev/null +++ b/cmp_uint_least16pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least16pp_nul(uint_least16_t *const *, uint_least16_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least32p.c b/cmp_uint_least32p.c new file mode 100644 index 0000000..f2a3d24 --- /dev/null +++ b/cmp_uint_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least32p(const uint_least32_t *, const uint_least32_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least32pp.c b/cmp_uint_least32pp.c new file mode 100644 index 0000000..9a6bee0 --- /dev/null +++ b/cmp_uint_least32pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least32pp(uint_least32_t *const *, uint_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least32pp_nul.c b/cmp_uint_least32pp_nul.c new file mode 100644 index 0000000..55d1e7c --- /dev/null +++ b/cmp_uint_least32pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least32pp_nul(uint_least32_t *const *, uint_least32_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least64p.c b/cmp_uint_least64p.c new file mode 100644 index 0000000..2cf9ff5 --- /dev/null +++ b/cmp_uint_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least64p(const uint_least64_t *, const uint_least64_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least64pp.c b/cmp_uint_least64pp.c new file mode 100644 index 0000000..ed92231 --- /dev/null +++ b/cmp_uint_least64pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least64pp(uint_least64_t *const *, uint_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least64pp_nul.c b/cmp_uint_least64pp_nul.c new file mode 100644 index 0000000..78f8256 --- /dev/null +++ b/cmp_uint_least64pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least64pp_nul(uint_least64_t *const *, uint_least64_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least8p.c b/cmp_uint_least8p.c new file mode 100644 index 0000000..a6b3cae --- /dev/null +++ b/cmp_uint_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least8p(const uint_least8_t *, const uint_least8_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least8pp.c b/cmp_uint_least8pp.c new file mode 100644 index 0000000..5432bbd --- /dev/null +++ b/cmp_uint_least8pp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least8pp(uint_least8_t *const *, uint_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uint_least8pp_nul.c b/cmp_uint_least8pp_nul.c new file mode 100644 index 0000000..06355a2 --- /dev/null +++ b/cmp_uint_least8pp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uint_least8pp_nul(uint_least8_t *const *, uint_least8_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintmaxp.c b/cmp_uintmaxp.c new file mode 100644 index 0000000..540cfab --- /dev/null +++ b/cmp_uintmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintmaxp(const uintmax_t *, const uintmax_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintmaxpp.c b/cmp_uintmaxpp.c new file mode 100644 index 0000000..bf321cc --- /dev/null +++ b/cmp_uintmaxpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintmaxpp(uintmax_t *const *, uintmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintmaxpp_nul.c b/cmp_uintmaxpp_nul.c new file mode 100644 index 0000000..a0efda5 --- /dev/null +++ b/cmp_uintmaxpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintmaxpp_nul(uintmax_t *const *, uintmax_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintp.c b/cmp_uintp.c new file mode 100644 index 0000000..e6063ee --- /dev/null +++ b/cmp_uintp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintp(const unsigned int *, const unsigned int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintpp.c b/cmp_uintpp.c new file mode 100644 index 0000000..0e21ea3 --- /dev/null +++ b/cmp_uintpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintpp(unsigned int *const *, unsigned int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintpp_nul.c b/cmp_uintpp_nul.c new file mode 100644 index 0000000..837f1e4 --- /dev/null +++ b/cmp_uintpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintpp_nul(unsigned int *const *, unsigned int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintptrp.c b/cmp_uintptrp.c new file mode 100644 index 0000000..078fb82 --- /dev/null +++ b/cmp_uintptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintptrp(const uintptr_t *, const uintptr_t *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintptrpp.c b/cmp_uintptrpp.c new file mode 100644 index 0000000..88b2a91 --- /dev/null +++ b/cmp_uintptrpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintptrpp(uintptr_t *const *, uintptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_uintptrpp_nul.c b/cmp_uintptrpp_nul.c new file mode 100644 index 0000000..371176a --- /dev/null +++ b/cmp_uintptrpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_uintptrpp_nul(uintptr_t *const *, uintptr_t *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ullongp.c b/cmp_ullongp.c new file mode 100644 index 0000000..b6e2da5 --- /dev/null +++ b/cmp_ullongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ullongp(const unsigned long long int *, const unsigned long long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ullongpp.c b/cmp_ullongpp.c new file mode 100644 index 0000000..c1d1b32 --- /dev/null +++ b/cmp_ullongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ullongpp(unsigned long long int *const *, unsigned long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ullongpp_nul.c b/cmp_ullongpp_nul.c new file mode 100644 index 0000000..f271c78 --- /dev/null +++ b/cmp_ullongpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ullongpp_nul(unsigned long long int *const *, unsigned long long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ulongp.c b/cmp_ulongp.c new file mode 100644 index 0000000..022b2bc --- /dev/null +++ b/cmp_ulongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ulongp(const unsigned long int *, const unsigned long int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ulongpp.c b/cmp_ulongpp.c new file mode 100644 index 0000000..c663e3c --- /dev/null +++ b/cmp_ulongpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ulongpp(unsigned long int *const *, unsigned long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ulongpp_nul.c b/cmp_ulongpp_nul.c new file mode 100644 index 0000000..78b13db --- /dev/null +++ b/cmp_ulongpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ulongpp_nul(unsigned long int *const *, unsigned long int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ushortp.c b/cmp_ushortp.c new file mode 100644 index 0000000..98c9c9f --- /dev/null +++ b/cmp_ushortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ushortp(const unsigned short int *, const unsigned short int *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ushortpp.c b/cmp_ushortpp.c new file mode 100644 index 0000000..4e89062 --- /dev/null +++ b/cmp_ushortpp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ushortpp(unsigned short int *const *, unsigned short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/cmp_ushortpp_nul.c b/cmp_ushortpp_nul.c new file mode 100644 index 0000000..d4ead40 --- /dev/null +++ b/cmp_ushortpp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline int libsimple_cmp_ushortpp_nul(unsigned short int *const *, unsigned short int *const *); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/libsimple.h b/libsimple.h index f1e479c..1b22653 100644 --- a/libsimple.h +++ b/libsimple.h @@ -171,6 +171,7 @@ #include "libsimple/path.h" #include "libsimple/ascii.h" #include "libsimple/exec.h" +#include "libsimple/sort.h" /** diff --git a/libsimple/sort.h b/libsimple/sort.h new file mode 100644 index 0000000..77929d1 --- /dev/null +++ b/libsimple/sort.h @@ -0,0 +1,1865 @@ +/* See LICENSE file for copyright and license details. */ + +/* TODO man, doc, test */ + + +#define LIBSIMPLE_CMP_NUMP__(TYPE, L, R)\ + const TYPE *L##_typed = L;\ + const TYPE *R##_typed = R;\ + return *L##_typed < *R##_typed ? -1 : *L##_typed > *R##_typed + +#define LIBSIMPLE_CMP_NUMPP__(TYPE, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + return **L##_typed < **R##_typed ? -1 : **L##_typed > **R##_typed + +#define LIBSIMPLE_CMP_NUL_NUMPP__(TYPE, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : -1;\ + if (!*R##_typed)\ + return +1;\ + return **L##_typed < **R##_typed ? -1 : **L##_typed > **R##_typed + +#define LIBSIMPLE_CMP_NUMPP_NUL__(TYPE, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : +1;\ + if (!*R##_typed)\ + return -1;\ + return **L##_typed < **R##_typed ? -1 : **L##_typed > **R##_typed + +#define LIBSIMPLE_CMP_REV_NUMP__(TYPE, L, R)\ + const TYPE *L##_typed = L;\ + const TYPE *R##_typed = R;\ + return *L##_typed > *R##_typed ? -1 : *L##_typed < *R##_typed + +#define LIBSIMPLE_CMP_REV_NUMPP__(TYPE, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + return **L##_typed > **R##_typed ? -1 : **L##_typed < **R##_typed + +#define LIBSIMPLE_CMP_NUL_REV_NUMPP__(TYPE, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : -1;\ + if (!*R##_typed)\ + return +1;\ + return **L##_typed > **R##_typed ? -1 : **L##_typed < **R##_typed + +#define LIBSIMPLE_CMP_REV_NUMPP_NUL__(TYPE, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : +1;\ + if (!*R##_typed)\ + return -1;\ + return **L##_typed > **R##_typed ? -1 : **L##_typed < **R##_typed + + +#define LIBSIMPLE_CMP_FUNP__(TYPE, FUNC, L, R)\ + TYPE const *L##_typed = L;\ + TYPE const *R##_typed = R;\ + return FUNC(*L##_typed, *R##_typed) + +#define LIBSIMPLE_CMP_FUNPP__(TYPE, FUNC, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + return FUNC(**L##_typed, **R##_typed) + +#define LIBSIMPLE_CMP_NUL_FUNPP__(TYPE, FUNC, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : -1;\ + if (!*R##_typed)\ + return +1;\ + return FUNC(**L##_typed, **R##_typed) + +#define LIBSIMPLE_CMP_FUNPP_NUL__(TYPE, FUNC, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : +1;\ + if (!*R##_typed)\ + return -1;\ + return FUNC(**L##_typed, **R##_typed) + +#define LIBSIMPLE_CMP_REV_FUNP__(TYPE, FUNC, L, R)\ + TYPE const *L##_typed = L;\ + TYPE const *R##_typed = R;\ + return -FUNC(*L##_typed, *R##_typed) + +#define LIBSIMPLE_CMP_REV_FUNPP__(TYPE, FUNC, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + return -FUNC(**L##_typed, **R##_typed) + +#define LIBSIMPLE_CMP_NUL_REV_FUNPP__(TYPE, FUNC, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : -1;\ + if (!*R##_typed)\ + return +1;\ + return -FUNC(**L##_typed, **R##_typed) + +#define LIBSIMPLE_CMP_REV_FUNPP_NUL__(TYPE, FUNC, L, R)\ + TYPE *const *L##_typed = L;\ + TYPE *const *R##_typed = R;\ + if (!*L##_typed)\ + return !*R##_typed ? 0 : +1;\ + if (!*R##_typed)\ + return -1;\ + return -FUNC(**L##_typed, **R##_typed) + + +inline int libsimple_cmp_ucharp(const unsigned char *a, const unsigned char *b) +{ LIBSIMPLE_CMP_NUMP__(unsigned char, a, b); } + +inline void libsimple_qsort_uchar(unsigned char base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ucharp); } + +inline int libsimple_cmp_ucharpp(unsigned char *const *a, unsigned char *const *b) +{ LIBSIMPLE_CMP_NUMPP__(unsigned char, a, b); } + +inline void libsimple_qsort_ucharp(unsigned char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ucharpp); } + +inline int libsimple_cmp_nul_ucharpp(unsigned char *const *a, unsigned char *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(unsigned char, a, b); } + +inline void libsimple_qsort_nul_ucharp(unsigned char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_ucharpp); } + +inline int libsimple_cmp_ucharpp_nul(unsigned char *const *a, unsigned char *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(unsigned char, a, b); } + +inline void libsimple_qsort_ucharp_nul(unsigned char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ucharpp_nul); } + +inline int libsimple_cmp_rev_ucharp(const unsigned char *a, const unsigned char *b) +{ LIBSIMPLE_CMP_REV_NUMP__(unsigned char, a, b); } + +inline void libsimple_qsort_rev_uchar(unsigned char base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ucharp); } + +inline int libsimple_cmp_rev_ucharpp(unsigned char *const *a, unsigned char *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(unsigned char, a, b); } + +inline void libsimple_qsort_rev_ucharp(unsigned char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ucharpp); } + +inline int libsimple_cmp_nul_rev_ucharpp(unsigned char *const *a, unsigned char *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(unsigned char, a, b); } + +inline void libsimple_qsort_nul_rev_ucharp(unsigned char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_ucharpp); } + +inline int libsimple_cmp_rev_ucharpp_nul(unsigned char *const *a, unsigned char *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(unsigned char, a, b); } + +inline void libsimple_qsort_rev_ucharp_nul(unsigned char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ucharpp_nul); } + +inline int libsimple_cmp_scharp(const signed char *a, const signed char *b) +{ LIBSIMPLE_CMP_NUMP__(signed char, a, b); } + +inline void libsimple_qsort_schar(signed char base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_scharp); } + +inline int libsimple_cmp_scharpp(signed char *const *a, signed char *const *b) +{ LIBSIMPLE_CMP_NUMPP__(signed char, a, b); } + +inline void libsimple_qsort_scharp(signed char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_scharpp); } + +inline int libsimple_cmp_nul_scharpp(signed char *const *a, signed char *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(signed char, a, b); } + +inline void libsimple_qsort_nul_scharp(signed char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_scharpp); } + +inline int libsimple_cmp_scharpp_nul(signed char *const *a, signed char *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(signed char, a, b); } + +inline void libsimple_qsort_scharp_nul(signed char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_scharpp_nul); } + +inline int libsimple_cmp_rev_scharp(const signed char *a, const signed char *b) +{ LIBSIMPLE_CMP_REV_NUMP__(signed char, a, b); } + +inline void libsimple_qsort_rev_schar(signed char base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_scharp); } + +inline int libsimple_cmp_rev_scharpp(signed char *const *a, signed char *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(signed char, a, b); } + +inline void libsimple_qsort_rev_scharp(signed char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_scharpp); } + +inline int libsimple_cmp_nul_rev_scharpp(signed char *const *a, signed char *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(signed char, a, b); } + +inline void libsimple_qsort_nul_rev_scharp(signed char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_scharpp); } + +inline int libsimple_cmp_rev_scharpp_nul(signed char *const *a, signed char *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(signed char, a, b); } + +inline void libsimple_qsort_rev_scharp_nul(signed char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_scharpp_nul); } + +inline int libsimple_cmp_shortp(const short int *a, const short int *b) +{ LIBSIMPLE_CMP_NUMP__(short int, a, b); } + +inline void libsimple_qsort_short(short int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_shortp); } + +inline int libsimple_cmp_shortpp(short int *const *a, short int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(short int, a, b); } + +inline void libsimple_qsort_shortp(short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_shortpp); } + +inline int libsimple_cmp_nul_shortpp(short int *const *a, short int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(short int, a, b); } + +inline void libsimple_qsort_nul_shortp(short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_shortpp); } + +inline int libsimple_cmp_shortpp_nul(short int *const *a, short int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(short int, a, b); } + +inline void libsimple_qsort_shortp_nul(short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_shortpp_nul); } + +inline int libsimple_cmp_rev_shortp(const short int *a, const short int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(short int, a, b); } + +inline void libsimple_qsort_rev_short(short int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_shortp); } + +inline int libsimple_cmp_rev_shortpp(short int *const *a, short int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(short int, a, b); } + +inline void libsimple_qsort_rev_shortp(short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_shortpp); } + +inline int libsimple_cmp_nul_rev_shortpp(short int *const *a, short int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(short int, a, b); } + +inline void libsimple_qsort_nul_rev_shortp(short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_shortpp); } + +inline int libsimple_cmp_rev_shortpp_nul(short int *const *a, short int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(short int, a, b); } + +inline void libsimple_qsort_rev_shortp_nul(short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_shortpp_nul); } + +inline int libsimple_cmp_ushortp(const unsigned short int *a, const unsigned short int *b) +{ LIBSIMPLE_CMP_NUMP__(unsigned short int, a, b); } + +inline void libsimple_qsort_ushort(unsigned short int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ushortp); } + +inline int libsimple_cmp_ushortpp(unsigned short int *const *a, unsigned short int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(unsigned short int, a, b); } + +inline void libsimple_qsort_ushortp(unsigned short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ushortpp); } + +inline int libsimple_cmp_nul_ushortpp(unsigned short int *const *a, unsigned short int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(unsigned short int, a, b); } + +inline void libsimple_qsort_nul_ushortp(unsigned short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_ushortpp); } + +inline int libsimple_cmp_ushortpp_nul(unsigned short int *const *a, unsigned short int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(unsigned short int, a, b); } + +inline void libsimple_qsort_ushortp_nul(unsigned short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ushortpp_nul); } + +inline int libsimple_cmp_rev_ushortp(const unsigned short int *a, const unsigned short int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(unsigned short int, a, b); } + +inline void libsimple_qsort_rev_ushort(unsigned short int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ushortp); } + +inline int libsimple_cmp_rev_ushortpp(unsigned short int *const *a, unsigned short int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(unsigned short int, a, b); } + +inline void libsimple_qsort_rev_ushortp(unsigned short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ushortpp); } + +inline int libsimple_cmp_nul_rev_ushortpp(unsigned short int *const *a, unsigned short int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(unsigned short int, a, b); } + +inline void libsimple_qsort_nul_rev_ushortp(unsigned short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_ushortpp); } + +inline int libsimple_cmp_rev_ushortpp_nul(unsigned short int *const *a, unsigned short int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(unsigned short int, a, b); } + +inline void libsimple_qsort_rev_ushortp_nul(unsigned short int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ushortpp_nul); } + +inline int libsimple_cmp_intp(const int *a, const int *b) +{ LIBSIMPLE_CMP_NUMP__(int, a, b); } + +inline void libsimple_qsort_int(int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intp); } + +inline int libsimple_cmp_intpp(int *const *a, int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int, a, b); } + +inline void libsimple_qsort_intp(int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intpp); } + +inline int libsimple_cmp_nul_intpp(int *const *a, int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int, a, b); } + +inline void libsimple_qsort_nul_intp(int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_intpp); } + +inline int libsimple_cmp_intpp_nul(int *const *a, int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int, a, b); } + +inline void libsimple_qsort_intp_nul(int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intpp_nul); } + +inline int libsimple_cmp_rev_intp(const int *a, const int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int, a, b); } + +inline void libsimple_qsort_rev_int(int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intp); } + +inline int libsimple_cmp_rev_intpp(int *const *a, int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int, a, b); } + +inline void libsimple_qsort_rev_intp(int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intpp); } + +inline int libsimple_cmp_nul_rev_intpp(int *const *a, int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int, a, b); } + +inline void libsimple_qsort_nul_rev_intp(int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_intpp); } + +inline int libsimple_cmp_rev_intpp_nul(int *const *a, int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int, a, b); } + +inline void libsimple_qsort_rev_intp_nul(int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intpp_nul); } + +inline int libsimple_cmp_uintp(const unsigned int *a, const unsigned int *b) +{ LIBSIMPLE_CMP_NUMP__(unsigned int, a, b); } + +inline void libsimple_qsort_uint(unsigned int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintp); } + +inline int libsimple_cmp_uintpp(unsigned int *const *a, unsigned int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(unsigned int, a, b); } + +inline void libsimple_qsort_uintp(unsigned int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintpp); } + +inline int libsimple_cmp_nul_uintpp(unsigned int *const *a, unsigned int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(unsigned int, a, b); } + +inline void libsimple_qsort_nul_uintp(unsigned int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uintpp); } + +inline int libsimple_cmp_uintpp_nul(unsigned int *const *a, unsigned int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(unsigned int, a, b); } + +inline void libsimple_qsort_uintp_nul(unsigned int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintpp_nul); } + +inline int libsimple_cmp_rev_uintp(const unsigned int *a, const unsigned int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(unsigned int, a, b); } + +inline void libsimple_qsort_rev_uint(unsigned int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintp); } + +inline int libsimple_cmp_rev_uintpp(unsigned int *const *a, unsigned int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(unsigned int, a, b); } + +inline void libsimple_qsort_rev_uintp(unsigned int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintpp); } + +inline int libsimple_cmp_nul_rev_uintpp(unsigned int *const *a, unsigned int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(unsigned int, a, b); } + +inline void libsimple_qsort_nul_rev_uintp(unsigned int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uintpp); } + +inline int libsimple_cmp_rev_uintpp_nul(unsigned int *const *a, unsigned int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(unsigned int, a, b); } + +inline void libsimple_qsort_rev_uintp_nul(unsigned int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintpp_nul); } + +inline int libsimple_cmp_longp(const long int *a, const long int *b) +{ LIBSIMPLE_CMP_NUMP__(long int, a, b); } + +inline void libsimple_qsort_long(long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_longp); } + +inline int libsimple_cmp_longpp(long int *const *a, long int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(long int, a, b); } + +inline void libsimple_qsort_longp(long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_longpp); } + +inline int libsimple_cmp_nul_longpp(long int *const *a, long int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(long int, a, b); } + +inline void libsimple_qsort_nul_longp(long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_longpp); } + +inline int libsimple_cmp_longpp_nul(long int *const *a, long int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(long int, a, b); } + +inline void libsimple_qsort_longp_nul(long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_longpp_nul); } + +inline int libsimple_cmp_rev_longp(const long int *a, const long int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(long int, a, b); } + +inline void libsimple_qsort_rev_long(long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_longp); } + +inline int libsimple_cmp_rev_longpp(long int *const *a, long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(long int, a, b); } + +inline void libsimple_qsort_rev_longp(long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_longpp); } + +inline int libsimple_cmp_nul_rev_longpp(long int *const *a, long int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(long int, a, b); } + +inline void libsimple_qsort_nul_rev_longp(long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_longpp); } + +inline int libsimple_cmp_rev_longpp_nul(long int *const *a, long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(long int, a, b); } + +inline void libsimple_qsort_rev_longp_nul(long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_longpp_nul); } + +inline int libsimple_cmp_ulongp(const unsigned long int *a, const unsigned long int *b) +{ LIBSIMPLE_CMP_NUMP__(unsigned long int, a, b); } + +inline void libsimple_qsort_ulong(unsigned long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ulongp); } + +inline int libsimple_cmp_ulongpp(unsigned long int *const *a, unsigned long int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(unsigned long int, a, b); } + +inline void libsimple_qsort_ulongp(unsigned long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ulongpp); } + +inline int libsimple_cmp_nul_ulongpp(unsigned long int *const *a, unsigned long int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(unsigned long int, a, b); } + +inline void libsimple_qsort_nul_ulongp(unsigned long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_ulongpp); } + +inline int libsimple_cmp_ulongpp_nul(unsigned long int *const *a, unsigned long int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(unsigned long int, a, b); } + +inline void libsimple_qsort_ulongp_nul(unsigned long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ulongpp_nul); } + +inline int libsimple_cmp_rev_ulongp(const unsigned long int *a, const unsigned long int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(unsigned long int, a, b); } + +inline void libsimple_qsort_rev_ulong(unsigned long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ulongp); } + +inline int libsimple_cmp_rev_ulongpp(unsigned long int *const *a, unsigned long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(unsigned long int, a, b); } + +inline void libsimple_qsort_rev_ulongp(unsigned long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ulongpp); } + +inline int libsimple_cmp_nul_rev_ulongpp(unsigned long int *const *a, unsigned long int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(unsigned long int, a, b); } + +inline void libsimple_qsort_nul_rev_ulongp(unsigned long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_ulongpp); } + +inline int libsimple_cmp_rev_ulongpp_nul(unsigned long int *const *a, unsigned long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(unsigned long int, a, b); } + +inline void libsimple_qsort_rev_ulongp_nul(unsigned long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ulongpp_nul); } + +inline int libsimple_cmp_llongp(const long long int *a, const long long int *b) +{ LIBSIMPLE_CMP_NUMP__(long long int, a, b); } + +inline void libsimple_qsort_llong(long long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_llongp); } + +inline int libsimple_cmp_llongpp(long long int *const *a, long long int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(long long int, a, b); } + +inline void libsimple_qsort_llongp(long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_llongpp); } + +inline int libsimple_cmp_nul_llongpp(long long int *const *a, long long int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(long long int, a, b); } + +inline void libsimple_qsort_nul_llongp(long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_llongpp); } + +inline int libsimple_cmp_llongpp_nul(long long int *const *a, long long int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(long long int, a, b); } + +inline void libsimple_qsort_llongp_nul(long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_llongpp_nul); } + +inline int libsimple_cmp_rev_llongp(const long long int *a, const long long int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(long long int, a, b); } + +inline void libsimple_qsort_rev_llong(long long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_llongp); } + +inline int libsimple_cmp_rev_llongpp(long long int *const *a, long long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(long long int, a, b); } + +inline void libsimple_qsort_rev_llongp(long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_llongpp); } + +inline int libsimple_cmp_nul_rev_llongpp(long long int *const *a, long long int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(long long int, a, b); } + +inline void libsimple_qsort_nul_rev_llongp(long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_llongpp); } + +inline int libsimple_cmp_rev_llongpp_nul(long long int *const *a, long long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(long long int, a, b); } + +inline void libsimple_qsort_rev_llongp_nul(long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_llongpp_nul); } + +inline int libsimple_cmp_ullongp(const unsigned long long int *a, const unsigned long long int *b) +{ LIBSIMPLE_CMP_NUMP__(unsigned long long int, a, b); } + +inline void libsimple_qsort_ullong(unsigned long long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ullongp); } + +inline int libsimple_cmp_ullongpp(unsigned long long int *const *a, unsigned long long int *const *b) +{ LIBSIMPLE_CMP_NUMPP__(unsigned long long int, a, b); } + +inline void libsimple_qsort_ullongp(unsigned long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ullongpp); } + +inline int libsimple_cmp_nul_ullongpp(unsigned long long int *const *a, unsigned long long int *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(unsigned long long int, a, b); } + +inline void libsimple_qsort_nul_ullongp(unsigned long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_ullongpp); } + +inline int libsimple_cmp_ullongpp_nul(unsigned long long int *const *a, unsigned long long int *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(unsigned long long int, a, b); } + +inline void libsimple_qsort_ullongp_nul(unsigned long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ullongpp_nul); } + +inline int libsimple_cmp_rev_ullongp(const unsigned long long int *a, const unsigned long long int *b) +{ LIBSIMPLE_CMP_REV_NUMP__(unsigned long long int, a, b); } + +inline void libsimple_qsort_rev_ullong(unsigned long long int base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ullongp); } + +inline int libsimple_cmp_rev_ullongpp(unsigned long long int *const *a, unsigned long long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(unsigned long long int, a, b); } + +inline void libsimple_qsort_rev_ullongp(unsigned long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ullongpp); } + +inline int libsimple_cmp_nul_rev_ullongpp(unsigned long long int *const *a, unsigned long long int *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(unsigned long long int, a, b); } + +inline void libsimple_qsort_nul_rev_ullongp(unsigned long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_ullongpp); } + +inline int libsimple_cmp_rev_ullongpp_nul(unsigned long long int *const *a, unsigned long long int *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(unsigned long long int, a, b); } + +inline void libsimple_qsort_rev_ullongp_nul(unsigned long long int *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ullongpp_nul); } + +inline int libsimple_cmp_int8p(const int8_t *a, const int8_t *b) +{ LIBSIMPLE_CMP_NUMP__(int8_t, a, b); } + +inline void libsimple_qsort_int8(int8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int8p); } + +inline int libsimple_cmp_int8pp(int8_t *const *a, int8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int8_t, a, b); } + +inline void libsimple_qsort_int8p(int8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int8pp); } + +inline int libsimple_cmp_nul_int8pp(int8_t *const *a, int8_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int8_t, a, b); } + +inline void libsimple_qsort_nul_int8p(int8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int8pp); } + +inline int libsimple_cmp_int8pp_nul(int8_t *const *a, int8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int8_t, a, b); } + +inline void libsimple_qsort_int8p_nul(int8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int8pp_nul); } + +inline int libsimple_cmp_rev_int8p(const int8_t *a, const int8_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int8_t, a, b); } + +inline void libsimple_qsort_rev_int8(int8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int8p); } + +inline int libsimple_cmp_rev_int8pp(int8_t *const *a, int8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int8_t, a, b); } + +inline void libsimple_qsort_rev_int8p(int8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int8pp); } + +inline int libsimple_cmp_nul_rev_int8pp(int8_t *const *a, int8_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int8_t, a, b); } + +inline void libsimple_qsort_nul_rev_int8p(int8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int8pp); } + +inline int libsimple_cmp_rev_int8pp_nul(int8_t *const *a, int8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int8_t, a, b); } + +inline void libsimple_qsort_rev_int8p_nul(int8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int8pp_nul); } + +inline int libsimple_cmp_uint8p(const uint8_t *a, const uint8_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint8_t, a, b); } + +inline void libsimple_qsort_uint8(uint8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint8p); } + +inline int libsimple_cmp_uint8pp(uint8_t *const *a, uint8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint8_t, a, b); } + +inline void libsimple_qsort_uint8p(uint8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint8pp); } + +inline int libsimple_cmp_nul_uint8pp(uint8_t *const *a, uint8_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint8_t, a, b); } + +inline void libsimple_qsort_nul_uint8p(uint8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint8pp); } + +inline int libsimple_cmp_uint8pp_nul(uint8_t *const *a, uint8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint8_t, a, b); } + +inline void libsimple_qsort_uint8p_nul(uint8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint8pp_nul); } + +inline int libsimple_cmp_rev_uint8p(const uint8_t *a, const uint8_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint8_t, a, b); } + +inline void libsimple_qsort_rev_uint8(uint8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint8p); } + +inline int libsimple_cmp_rev_uint8pp(uint8_t *const *a, uint8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint8_t, a, b); } + +inline void libsimple_qsort_rev_uint8p(uint8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint8pp); } + +inline int libsimple_cmp_nul_rev_uint8pp(uint8_t *const *a, uint8_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint8_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint8p(uint8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint8pp); } + +inline int libsimple_cmp_rev_uint8pp_nul(uint8_t *const *a, uint8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint8_t, a, b); } + +inline void libsimple_qsort_rev_uint8p_nul(uint8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint8pp_nul); } + +inline int libsimple_cmp_int16p(const int16_t *a, const int16_t *b) +{ LIBSIMPLE_CMP_NUMP__(int16_t, a, b); } + +inline void libsimple_qsort_int16(int16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int16p); } + +inline int libsimple_cmp_int16pp(int16_t *const *a, int16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int16_t, a, b); } + +inline void libsimple_qsort_int16p(int16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int16pp); } + +inline int libsimple_cmp_nul_int16pp(int16_t *const *a, int16_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int16_t, a, b); } + +inline void libsimple_qsort_nul_int16p(int16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int16pp); } + +inline int libsimple_cmp_int16pp_nul(int16_t *const *a, int16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int16_t, a, b); } + +inline void libsimple_qsort_int16p_nul(int16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int16pp_nul); } + +inline int libsimple_cmp_rev_int16p(const int16_t *a, const int16_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int16_t, a, b); } + +inline void libsimple_qsort_rev_int16(int16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int16p); } + +inline int libsimple_cmp_rev_int16pp(int16_t *const *a, int16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int16_t, a, b); } + +inline void libsimple_qsort_rev_int16p(int16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int16pp); } + +inline int libsimple_cmp_nul_rev_int16pp(int16_t *const *a, int16_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int16_t, a, b); } + +inline void libsimple_qsort_nul_rev_int16p(int16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int16pp); } + +inline int libsimple_cmp_rev_int16pp_nul(int16_t *const *a, int16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int16_t, a, b); } + +inline void libsimple_qsort_rev_int16p_nul(int16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int16pp_nul); } + +inline int libsimple_cmp_uint16p(const uint16_t *a, const uint16_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint16_t, a, b); } + +inline void libsimple_qsort_uint16(uint16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint16p); } + +inline int libsimple_cmp_uint16pp(uint16_t *const *a, uint16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint16_t, a, b); } + +inline void libsimple_qsort_uint16p(uint16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint16pp); } + +inline int libsimple_cmp_nul_uint16pp(uint16_t *const *a, uint16_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint16_t, a, b); } + +inline void libsimple_qsort_nul_uint16p(uint16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint16pp); } + +inline int libsimple_cmp_uint16pp_nul(uint16_t *const *a, uint16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint16_t, a, b); } + +inline void libsimple_qsort_uint16p_nul(uint16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint16pp_nul); } + +inline int libsimple_cmp_rev_uint16p(const uint16_t *a, const uint16_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint16_t, a, b); } + +inline void libsimple_qsort_rev_uint16(uint16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint16p); } + +inline int libsimple_cmp_rev_uint16pp(uint16_t *const *a, uint16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint16_t, a, b); } + +inline void libsimple_qsort_rev_uint16p(uint16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint16pp); } + +inline int libsimple_cmp_nul_rev_uint16pp(uint16_t *const *a, uint16_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint16_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint16p(uint16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint16pp); } + +inline int libsimple_cmp_rev_uint16pp_nul(uint16_t *const *a, uint16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint16_t, a, b); } + +inline void libsimple_qsort_rev_uint16p_nul(uint16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint16pp_nul); } + +inline int libsimple_cmp_int32p(const int32_t *a, const int32_t *b) +{ LIBSIMPLE_CMP_NUMP__(int32_t, a, b); } + +inline void libsimple_qsort_int32(int32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int32p); } + +inline int libsimple_cmp_int32pp(int32_t *const *a, int32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int32_t, a, b); } + +inline void libsimple_qsort_int32p(int32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int32pp); } + +inline int libsimple_cmp_nul_int32pp(int32_t *const *a, int32_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int32_t, a, b); } + +inline void libsimple_qsort_nul_int32p(int32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int32pp); } + +inline int libsimple_cmp_int32pp_nul(int32_t *const *a, int32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int32_t, a, b); } + +inline void libsimple_qsort_int32p_nul(int32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int32pp_nul); } + +inline int libsimple_cmp_rev_int32p(const int32_t *a, const int32_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int32_t, a, b); } + +inline void libsimple_qsort_rev_int32(int32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int32p); } + +inline int libsimple_cmp_rev_int32pp(int32_t *const *a, int32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int32_t, a, b); } + +inline void libsimple_qsort_rev_int32p(int32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int32pp); } + +inline int libsimple_cmp_nul_rev_int32pp(int32_t *const *a, int32_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int32_t, a, b); } + +inline void libsimple_qsort_nul_rev_int32p(int32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int32pp); } + +inline int libsimple_cmp_rev_int32pp_nul(int32_t *const *a, int32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int32_t, a, b); } + +inline void libsimple_qsort_rev_int32p_nul(int32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int32pp_nul); } + +inline int libsimple_cmp_uint32p(const uint32_t *a, const uint32_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint32_t, a, b); } + +inline void libsimple_qsort_uint32(uint32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint32p); } + +inline int libsimple_cmp_uint32pp(uint32_t *const *a, uint32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint32_t, a, b); } + +inline void libsimple_qsort_uint32p(uint32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint32pp); } + +inline int libsimple_cmp_nul_uint32pp(uint32_t *const *a, uint32_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint32_t, a, b); } + +inline void libsimple_qsort_nul_uint32p(uint32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint32pp); } + +inline int libsimple_cmp_uint32pp_nul(uint32_t *const *a, uint32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint32_t, a, b); } + +inline void libsimple_qsort_uint32p_nul(uint32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint32pp_nul); } + +inline int libsimple_cmp_rev_uint32p(const uint32_t *a, const uint32_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint32_t, a, b); } + +inline void libsimple_qsort_rev_uint32(uint32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint32p); } + +inline int libsimple_cmp_rev_uint32pp(uint32_t *const *a, uint32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint32_t, a, b); } + +inline void libsimple_qsort_rev_uint32p(uint32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint32pp); } + +inline int libsimple_cmp_nul_rev_uint32pp(uint32_t *const *a, uint32_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint32_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint32p(uint32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint32pp); } + +inline int libsimple_cmp_rev_uint32pp_nul(uint32_t *const *a, uint32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint32_t, a, b); } + +inline void libsimple_qsort_rev_uint32p_nul(uint32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint32pp_nul); } + +inline int libsimple_cmp_int64p(const int64_t *a, const int64_t *b) +{ LIBSIMPLE_CMP_NUMP__(int64_t, a, b); } + +inline void libsimple_qsort_int64(int64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int64p); } + +inline int libsimple_cmp_int64pp(int64_t *const *a, int64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int64_t, a, b); } + +inline void libsimple_qsort_int64p(int64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int64pp); } + +inline int libsimple_cmp_nul_int64pp(int64_t *const *a, int64_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int64_t, a, b); } + +inline void libsimple_qsort_nul_int64p(int64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int64pp); } + +inline int libsimple_cmp_int64pp_nul(int64_t *const *a, int64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int64_t, a, b); } + +inline void libsimple_qsort_int64p_nul(int64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int64pp_nul); } + +inline int libsimple_cmp_rev_int64p(const int64_t *a, const int64_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int64_t, a, b); } + +inline void libsimple_qsort_rev_int64(int64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int64p); } + +inline int libsimple_cmp_rev_int64pp(int64_t *const *a, int64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int64_t, a, b); } + +inline void libsimple_qsort_rev_int64p(int64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int64pp); } + +inline int libsimple_cmp_nul_rev_int64pp(int64_t *const *a, int64_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int64_t, a, b); } + +inline void libsimple_qsort_nul_rev_int64p(int64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int64pp); } + +inline int libsimple_cmp_rev_int64pp_nul(int64_t *const *a, int64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int64_t, a, b); } + +inline void libsimple_qsort_rev_int64p_nul(int64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int64pp_nul); } + +inline int libsimple_cmp_uint64p(const uint64_t *a, const uint64_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint64_t, a, b); } + +inline void libsimple_qsort_uint64(uint64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint64p); } + +inline int libsimple_cmp_uint64pp(uint64_t *const *a, uint64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint64_t, a, b); } + +inline void libsimple_qsort_uint64p(uint64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint64pp); } + +inline int libsimple_cmp_nul_uint64pp(uint64_t *const *a, uint64_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint64_t, a, b); } + +inline void libsimple_qsort_nul_uint64p(uint64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint64pp); } + +inline int libsimple_cmp_uint64pp_nul(uint64_t *const *a, uint64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint64_t, a, b); } + +inline void libsimple_qsort_uint64p_nul(uint64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint64pp_nul); } + +inline int libsimple_cmp_rev_uint64p(const uint64_t *a, const uint64_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint64_t, a, b); } + +inline void libsimple_qsort_rev_uint64(uint64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint64p); } + +inline int libsimple_cmp_rev_uint64pp(uint64_t *const *a, uint64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint64_t, a, b); } + +inline void libsimple_qsort_rev_uint64p(uint64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint64pp); } + +inline int libsimple_cmp_nul_rev_uint64pp(uint64_t *const *a, uint64_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint64_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint64p(uint64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint64pp); } + +inline int libsimple_cmp_rev_uint64pp_nul(uint64_t *const *a, uint64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint64_t, a, b); } + +inline void libsimple_qsort_rev_uint64p_nul(uint64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint64pp_nul); } + +inline int libsimple_cmp_int_least8p(const int_least8_t *a, const int_least8_t *b) +{ LIBSIMPLE_CMP_NUMP__(int_least8_t, a, b); } + +inline void libsimple_qsort_int_least8(int_least8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least8p); } + +inline int libsimple_cmp_int_least8pp(int_least8_t *const *a, int_least8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int_least8_t, a, b); } + +inline void libsimple_qsort_int_least8p(int_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least8pp); } + +inline int libsimple_cmp_nul_int_least8pp(int_least8_t *const *a, int_least8_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int_least8_t, a, b); } + +inline void libsimple_qsort_nul_int_least8p(int_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int_least8pp); } + +inline int libsimple_cmp_int_least8pp_nul(int_least8_t *const *a, int_least8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int_least8_t, a, b); } + +inline void libsimple_qsort_int_least8p_nul(int_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least8pp_nul); } + +inline int libsimple_cmp_rev_int_least8p(const int_least8_t *a, const int_least8_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int_least8_t, a, b); } + +inline void libsimple_qsort_rev_int_least8(int_least8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least8p); } + +inline int libsimple_cmp_rev_int_least8pp(int_least8_t *const *a, int_least8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int_least8_t, a, b); } + +inline void libsimple_qsort_rev_int_least8p(int_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least8pp); } + +inline int libsimple_cmp_nul_rev_int_least8pp(int_least8_t *const *a, int_least8_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int_least8_t, a, b); } + +inline void libsimple_qsort_nul_rev_int_least8p(int_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int_least8pp); } + +inline int libsimple_cmp_rev_int_least8pp_nul(int_least8_t *const *a, int_least8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int_least8_t, a, b); } + +inline void libsimple_qsort_rev_int_least8p_nul(int_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least8pp_nul); } + +inline int libsimple_cmp_uint_least8p(const uint_least8_t *a, const uint_least8_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint_least8_t, a, b); } + +inline void libsimple_qsort_uint_least8(uint_least8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least8p); } + +inline int libsimple_cmp_uint_least8pp(uint_least8_t *const *a, uint_least8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint_least8_t, a, b); } + +inline void libsimple_qsort_uint_least8p(uint_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least8pp); } + +inline int libsimple_cmp_nul_uint_least8pp(uint_least8_t *const *a, uint_least8_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint_least8_t, a, b); } + +inline void libsimple_qsort_nul_uint_least8p(uint_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint_least8pp); } + +inline int libsimple_cmp_uint_least8pp_nul(uint_least8_t *const *a, uint_least8_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint_least8_t, a, b); } + +inline void libsimple_qsort_uint_least8p_nul(uint_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least8pp_nul); } + +inline int libsimple_cmp_rev_uint_least8p(const uint_least8_t *a, const uint_least8_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint_least8_t, a, b); } + +inline void libsimple_qsort_rev_uint_least8(uint_least8_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least8p); } + +inline int libsimple_cmp_rev_uint_least8pp(uint_least8_t *const *a, uint_least8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint_least8_t, a, b); } + +inline void libsimple_qsort_rev_uint_least8p(uint_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least8pp); } + +inline int libsimple_cmp_nul_rev_uint_least8pp(uint_least8_t *const *a, uint_least8_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint_least8_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint_least8p(uint_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint_least8pp); } + +inline int libsimple_cmp_rev_uint_least8pp_nul(uint_least8_t *const *a, uint_least8_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint_least8_t, a, b); } + +inline void libsimple_qsort_rev_uint_least8p_nul(uint_least8_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least8pp_nul); } + +inline int libsimple_cmp_int_least16p(const int_least16_t *a, const int_least16_t *b) +{ LIBSIMPLE_CMP_NUMP__(int_least16_t, a, b); } + +inline void libsimple_qsort_int_least16(int_least16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least16p); } + +inline int libsimple_cmp_int_least16pp(int_least16_t *const *a, int_least16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int_least16_t, a, b); } + +inline void libsimple_qsort_int_least16p(int_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least16pp); } + +inline int libsimple_cmp_nul_int_least16pp(int_least16_t *const *a, int_least16_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int_least16_t, a, b); } + +inline void libsimple_qsort_nul_int_least16p(int_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int_least16pp); } + +inline int libsimple_cmp_int_least16pp_nul(int_least16_t *const *a, int_least16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int_least16_t, a, b); } + +inline void libsimple_qsort_int_least16p_nul(int_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least16pp_nul); } + +inline int libsimple_cmp_rev_int_least16p(const int_least16_t *a, const int_least16_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int_least16_t, a, b); } + +inline void libsimple_qsort_rev_int_least16(int_least16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least16p); } + +inline int libsimple_cmp_rev_int_least16pp(int_least16_t *const *a, int_least16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int_least16_t, a, b); } + +inline void libsimple_qsort_rev_int_least16p(int_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least16pp); } + +inline int libsimple_cmp_nul_rev_int_least16pp(int_least16_t *const *a, int_least16_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int_least16_t, a, b); } + +inline void libsimple_qsort_nul_rev_int_least16p(int_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int_least16pp); } + +inline int libsimple_cmp_rev_int_least16pp_nul(int_least16_t *const *a, int_least16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int_least16_t, a, b); } + +inline void libsimple_qsort_rev_int_least16p_nul(int_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least16pp_nul); } + +inline int libsimple_cmp_uint_least16p(const uint_least16_t *a, const uint_least16_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint_least16_t, a, b); } + +inline void libsimple_qsort_uint_least16(uint_least16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least16p); } + +inline int libsimple_cmp_uint_least16pp(uint_least16_t *const *a, uint_least16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint_least16_t, a, b); } + +inline void libsimple_qsort_uint_least16p(uint_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least16pp); } + +inline int libsimple_cmp_nul_uint_least16pp(uint_least16_t *const *a, uint_least16_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint_least16_t, a, b); } + +inline void libsimple_qsort_nul_uint_least16p(uint_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint_least16pp); } + +inline int libsimple_cmp_uint_least16pp_nul(uint_least16_t *const *a, uint_least16_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint_least16_t, a, b); } + +inline void libsimple_qsort_uint_least16p_nul(uint_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least16pp_nul); } + +inline int libsimple_cmp_rev_uint_least16p(const uint_least16_t *a, const uint_least16_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint_least16_t, a, b); } + +inline void libsimple_qsort_rev_uint_least16(uint_least16_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least16p); } + +inline int libsimple_cmp_rev_uint_least16pp(uint_least16_t *const *a, uint_least16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint_least16_t, a, b); } + +inline void libsimple_qsort_rev_uint_least16p(uint_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least16pp); } + +inline int libsimple_cmp_nul_rev_uint_least16pp(uint_least16_t *const *a, uint_least16_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint_least16_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint_least16p(uint_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint_least16pp); } + +inline int libsimple_cmp_rev_uint_least16pp_nul(uint_least16_t *const *a, uint_least16_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint_least16_t, a, b); } + +inline void libsimple_qsort_rev_uint_least16p_nul(uint_least16_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least16pp_nul); } + +inline int libsimple_cmp_int_least32p(const int_least32_t *a, const int_least32_t *b) +{ LIBSIMPLE_CMP_NUMP__(int_least32_t, a, b); } + +inline void libsimple_qsort_int_least32(int_least32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least32p); } + +inline int libsimple_cmp_int_least32pp(int_least32_t *const *a, int_least32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int_least32_t, a, b); } + +inline void libsimple_qsort_int_least32p(int_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least32pp); } + +inline int libsimple_cmp_nul_int_least32pp(int_least32_t *const *a, int_least32_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int_least32_t, a, b); } + +inline void libsimple_qsort_nul_int_least32p(int_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int_least32pp); } + +inline int libsimple_cmp_int_least32pp_nul(int_least32_t *const *a, int_least32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int_least32_t, a, b); } + +inline void libsimple_qsort_int_least32p_nul(int_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least32pp_nul); } + +inline int libsimple_cmp_rev_int_least32p(const int_least32_t *a, const int_least32_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int_least32_t, a, b); } + +inline void libsimple_qsort_rev_int_least32(int_least32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least32p); } + +inline int libsimple_cmp_rev_int_least32pp(int_least32_t *const *a, int_least32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int_least32_t, a, b); } + +inline void libsimple_qsort_rev_int_least32p(int_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least32pp); } + +inline int libsimple_cmp_nul_rev_int_least32pp(int_least32_t *const *a, int_least32_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int_least32_t, a, b); } + +inline void libsimple_qsort_nul_rev_int_least32p(int_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int_least32pp); } + +inline int libsimple_cmp_rev_int_least32pp_nul(int_least32_t *const *a, int_least32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int_least32_t, a, b); } + +inline void libsimple_qsort_rev_int_least32p_nul(int_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least32pp_nul); } + +inline int libsimple_cmp_uint_least32p(const uint_least32_t *a, const uint_least32_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint_least32_t, a, b); } + +inline void libsimple_qsort_uint_least32(uint_least32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least32p); } + +inline int libsimple_cmp_uint_least32pp(uint_least32_t *const *a, uint_least32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint_least32_t, a, b); } + +inline void libsimple_qsort_uint_least32p(uint_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least32pp); } + +inline int libsimple_cmp_nul_uint_least32pp(uint_least32_t *const *a, uint_least32_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint_least32_t, a, b); } + +inline void libsimple_qsort_nul_uint_least32p(uint_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint_least32pp); } + +inline int libsimple_cmp_uint_least32pp_nul(uint_least32_t *const *a, uint_least32_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint_least32_t, a, b); } + +inline void libsimple_qsort_uint_least32p_nul(uint_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least32pp_nul); } + +inline int libsimple_cmp_rev_uint_least32p(const uint_least32_t *a, const uint_least32_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint_least32_t, a, b); } + +inline void libsimple_qsort_rev_uint_least32(uint_least32_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least32p); } + +inline int libsimple_cmp_rev_uint_least32pp(uint_least32_t *const *a, uint_least32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint_least32_t, a, b); } + +inline void libsimple_qsort_rev_uint_least32p(uint_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least32pp); } + +inline int libsimple_cmp_nul_rev_uint_least32pp(uint_least32_t *const *a, uint_least32_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint_least32_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint_least32p(uint_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint_least32pp); } + +inline int libsimple_cmp_rev_uint_least32pp_nul(uint_least32_t *const *a, uint_least32_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint_least32_t, a, b); } + +inline void libsimple_qsort_rev_uint_least32p_nul(uint_least32_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least32pp_nul); } + +inline int libsimple_cmp_int_least64p(const int_least64_t *a, const int_least64_t *b) +{ LIBSIMPLE_CMP_NUMP__(int_least64_t, a, b); } + +inline void libsimple_qsort_int_least64(int_least64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least64p); } + +inline int libsimple_cmp_int_least64pp(int_least64_t *const *a, int_least64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(int_least64_t, a, b); } + +inline void libsimple_qsort_int_least64p(int_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least64pp); } + +inline int libsimple_cmp_nul_int_least64pp(int_least64_t *const *a, int_least64_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(int_least64_t, a, b); } + +inline void libsimple_qsort_nul_int_least64p(int_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_int_least64pp); } + +inline int libsimple_cmp_int_least64pp_nul(int_least64_t *const *a, int_least64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(int_least64_t, a, b); } + +inline void libsimple_qsort_int_least64p_nul(int_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_int_least64pp_nul); } + +inline int libsimple_cmp_rev_int_least64p(const int_least64_t *a, const int_least64_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(int_least64_t, a, b); } + +inline void libsimple_qsort_rev_int_least64(int_least64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least64p); } + +inline int libsimple_cmp_rev_int_least64pp(int_least64_t *const *a, int_least64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(int_least64_t, a, b); } + +inline void libsimple_qsort_rev_int_least64p(int_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least64pp); } + +inline int libsimple_cmp_nul_rev_int_least64pp(int_least64_t *const *a, int_least64_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(int_least64_t, a, b); } + +inline void libsimple_qsort_nul_rev_int_least64p(int_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_int_least64pp); } + +inline int libsimple_cmp_rev_int_least64pp_nul(int_least64_t *const *a, int_least64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(int_least64_t, a, b); } + +inline void libsimple_qsort_rev_int_least64p_nul(int_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_int_least64pp_nul); } + +inline int libsimple_cmp_uint_least64p(const uint_least64_t *a, const uint_least64_t *b) +{ LIBSIMPLE_CMP_NUMP__(uint_least64_t, a, b); } + +inline void libsimple_qsort_uint_least64(uint_least64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least64p); } + +inline int libsimple_cmp_uint_least64pp(uint_least64_t *const *a, uint_least64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uint_least64_t, a, b); } + +inline void libsimple_qsort_uint_least64p(uint_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least64pp); } + +inline int libsimple_cmp_nul_uint_least64pp(uint_least64_t *const *a, uint_least64_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uint_least64_t, a, b); } + +inline void libsimple_qsort_nul_uint_least64p(uint_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uint_least64pp); } + +inline int libsimple_cmp_uint_least64pp_nul(uint_least64_t *const *a, uint_least64_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uint_least64_t, a, b); } + +inline void libsimple_qsort_uint_least64p_nul(uint_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uint_least64pp_nul); } + +inline int libsimple_cmp_rev_uint_least64p(const uint_least64_t *a, const uint_least64_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uint_least64_t, a, b); } + +inline void libsimple_qsort_rev_uint_least64(uint_least64_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least64p); } + +inline int libsimple_cmp_rev_uint_least64pp(uint_least64_t *const *a, uint_least64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uint_least64_t, a, b); } + +inline void libsimple_qsort_rev_uint_least64p(uint_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least64pp); } + +inline int libsimple_cmp_nul_rev_uint_least64pp(uint_least64_t *const *a, uint_least64_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uint_least64_t, a, b); } + +inline void libsimple_qsort_nul_rev_uint_least64p(uint_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uint_least64pp); } + +inline int libsimple_cmp_rev_uint_least64pp_nul(uint_least64_t *const *a, uint_least64_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uint_least64_t, a, b); } + +inline void libsimple_qsort_rev_uint_least64p_nul(uint_least64_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uint_least64pp_nul); } + +inline int libsimple_cmp_intmaxp(const intmax_t *a, const intmax_t *b) +{ LIBSIMPLE_CMP_NUMP__(intmax_t, a, b); } + +inline void libsimple_qsort_intmax(intmax_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intmaxp); } + +inline int libsimple_cmp_intmaxpp(intmax_t *const *a, intmax_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(intmax_t, a, b); } + +inline void libsimple_qsort_intmaxp(intmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intmaxpp); } + +inline int libsimple_cmp_nul_intmaxpp(intmax_t *const *a, intmax_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(intmax_t, a, b); } + +inline void libsimple_qsort_nul_intmaxp(intmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_intmaxpp); } + +inline int libsimple_cmp_intmaxpp_nul(intmax_t *const *a, intmax_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(intmax_t, a, b); } + +inline void libsimple_qsort_intmaxp_nul(intmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intmaxpp_nul); } + +inline int libsimple_cmp_rev_intmaxp(const intmax_t *a, const intmax_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(intmax_t, a, b); } + +inline void libsimple_qsort_rev_intmax(intmax_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intmaxp); } + +inline int libsimple_cmp_rev_intmaxpp(intmax_t *const *a, intmax_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(intmax_t, a, b); } + +inline void libsimple_qsort_rev_intmaxp(intmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intmaxpp); } + +inline int libsimple_cmp_nul_rev_intmaxpp(intmax_t *const *a, intmax_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(intmax_t, a, b); } + +inline void libsimple_qsort_nul_rev_intmaxp(intmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_intmaxpp); } + +inline int libsimple_cmp_rev_intmaxpp_nul(intmax_t *const *a, intmax_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(intmax_t, a, b); } + +inline void libsimple_qsort_rev_intmaxp_nul(intmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intmaxpp_nul); } + +inline int libsimple_cmp_uintmaxp(const uintmax_t *a, const uintmax_t *b) +{ LIBSIMPLE_CMP_NUMP__(uintmax_t, a, b); } + +inline void libsimple_qsort_uintmax(uintmax_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintmaxp); } + +inline int libsimple_cmp_uintmaxpp(uintmax_t *const *a, uintmax_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uintmax_t, a, b); } + +inline void libsimple_qsort_uintmaxp(uintmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintmaxpp); } + +inline int libsimple_cmp_nul_uintmaxpp(uintmax_t *const *a, uintmax_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uintmax_t, a, b); } + +inline void libsimple_qsort_nul_uintmaxp(uintmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uintmaxpp); } + +inline int libsimple_cmp_uintmaxpp_nul(uintmax_t *const *a, uintmax_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uintmax_t, a, b); } + +inline void libsimple_qsort_uintmaxp_nul(uintmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintmaxpp_nul); } + +inline int libsimple_cmp_rev_uintmaxp(const uintmax_t *a, const uintmax_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uintmax_t, a, b); } + +inline void libsimple_qsort_rev_uintmax(uintmax_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintmaxp); } + +inline int libsimple_cmp_rev_uintmaxpp(uintmax_t *const *a, uintmax_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uintmax_t, a, b); } + +inline void libsimple_qsort_rev_uintmaxp(uintmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintmaxpp); } + +inline int libsimple_cmp_nul_rev_uintmaxpp(uintmax_t *const *a, uintmax_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uintmax_t, a, b); } + +inline void libsimple_qsort_nul_rev_uintmaxp(uintmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uintmaxpp); } + +inline int libsimple_cmp_rev_uintmaxpp_nul(uintmax_t *const *a, uintmax_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uintmax_t, a, b); } + +inline void libsimple_qsort_rev_uintmaxp_nul(uintmax_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintmaxpp_nul); } + +inline int libsimple_cmp_sizep(const size_t *a, const size_t *b) +{ LIBSIMPLE_CMP_NUMP__(size_t, a, b); } + +inline void libsimple_qsort_size(size_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_sizep); } + +inline int libsimple_cmp_sizepp(size_t *const *a, size_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(size_t, a, b); } + +inline void libsimple_qsort_sizep(size_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_sizepp); } + +inline int libsimple_cmp_nul_sizepp(size_t *const *a, size_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(size_t, a, b); } + +inline void libsimple_qsort_nul_sizep(size_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_sizepp); } + +inline int libsimple_cmp_sizepp_nul(size_t *const *a, size_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(size_t, a, b); } + +inline void libsimple_qsort_sizep_nul(size_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_sizepp_nul); } + +inline int libsimple_cmp_rev_sizep(const size_t *a, const size_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(size_t, a, b); } + +inline void libsimple_qsort_rev_size(size_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_sizep); } + +inline int libsimple_cmp_rev_sizepp(size_t *const *a, size_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(size_t, a, b); } + +inline void libsimple_qsort_rev_sizep(size_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_sizepp); } + +inline int libsimple_cmp_nul_rev_sizepp(size_t *const *a, size_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(size_t, a, b); } + +inline void libsimple_qsort_nul_rev_sizep(size_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_sizepp); } + +inline int libsimple_cmp_rev_sizepp_nul(size_t *const *a, size_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(size_t, a, b); } + +inline void libsimple_qsort_rev_sizep_nul(size_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_sizepp_nul); } + +inline int libsimple_cmp_ssizep(const ssize_t *a, const ssize_t *b) +{ LIBSIMPLE_CMP_NUMP__(ssize_t, a, b); } + +inline void libsimple_qsort_ssize(ssize_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ssizep); } + +inline int libsimple_cmp_ssizepp(ssize_t *const *a, ssize_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(ssize_t, a, b); } + +inline void libsimple_qsort_ssizep(ssize_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ssizepp); } + +inline int libsimple_cmp_nul_ssizepp(ssize_t *const *a, ssize_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(ssize_t, a, b); } + +inline void libsimple_qsort_nul_ssizep(ssize_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_ssizepp); } + +inline int libsimple_cmp_ssizepp_nul(ssize_t *const *a, ssize_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(ssize_t, a, b); } + +inline void libsimple_qsort_ssizep_nul(ssize_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ssizepp_nul); } + +inline int libsimple_cmp_rev_ssizep(const ssize_t *a, const ssize_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(ssize_t, a, b); } + +inline void libsimple_qsort_rev_ssize(ssize_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ssizep); } + +inline int libsimple_cmp_rev_ssizepp(ssize_t *const *a, ssize_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(ssize_t, a, b); } + +inline void libsimple_qsort_rev_ssizep(ssize_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ssizepp); } + +inline int libsimple_cmp_nul_rev_ssizepp(ssize_t *const *a, ssize_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(ssize_t, a, b); } + +inline void libsimple_qsort_nul_rev_ssizep(ssize_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_ssizepp); } + +inline int libsimple_cmp_rev_ssizepp_nul(ssize_t *const *a, ssize_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(ssize_t, a, b); } + +inline void libsimple_qsort_rev_ssizep_nul(ssize_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ssizepp_nul); } + +inline int libsimple_cmp_intptrp(const intptr_t *a, const intptr_t *b) +{ LIBSIMPLE_CMP_NUMP__(intptr_t, a, b); } + +inline void libsimple_qsort_intptr(intptr_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intptrp); } + +inline int libsimple_cmp_intptrpp(intptr_t *const *a, intptr_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(intptr_t, a, b); } + +inline void libsimple_qsort_intptrp(intptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intptrpp); } + +inline int libsimple_cmp_nul_intptrpp(intptr_t *const *a, intptr_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(intptr_t, a, b); } + +inline void libsimple_qsort_nul_intptrp(intptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_intptrpp); } + +inline int libsimple_cmp_intptrpp_nul(intptr_t *const *a, intptr_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(intptr_t, a, b); } + +inline void libsimple_qsort_intptrp_nul(intptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_intptrpp_nul); } + +inline int libsimple_cmp_rev_intptrp(const intptr_t *a, const intptr_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(intptr_t, a, b); } + +inline void libsimple_qsort_rev_intptr(intptr_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intptrp); } + +inline int libsimple_cmp_rev_intptrpp(intptr_t *const *a, intptr_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(intptr_t, a, b); } + +inline void libsimple_qsort_rev_intptrp(intptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intptrpp); } + +inline int libsimple_cmp_nul_rev_intptrpp(intptr_t *const *a, intptr_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(intptr_t, a, b); } + +inline void libsimple_qsort_nul_rev_intptrp(intptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_intptrpp); } + +inline int libsimple_cmp_rev_intptrpp_nul(intptr_t *const *a, intptr_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(intptr_t, a, b); } + +inline void libsimple_qsort_rev_intptrp_nul(intptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_intptrpp_nul); } + +inline int libsimple_cmp_uintptrp(const uintptr_t *a, const uintptr_t *b) +{ LIBSIMPLE_CMP_NUMP__(uintptr_t, a, b); } + +inline void libsimple_qsort_uintptr(uintptr_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintptrp); } + +inline int libsimple_cmp_uintptrpp(uintptr_t *const *a, uintptr_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(uintptr_t, a, b); } + +inline void libsimple_qsort_uintptrp(uintptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintptrpp); } + +inline int libsimple_cmp_nul_uintptrpp(uintptr_t *const *a, uintptr_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(uintptr_t, a, b); } + +inline void libsimple_qsort_nul_uintptrp(uintptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_uintptrpp); } + +inline int libsimple_cmp_uintptrpp_nul(uintptr_t *const *a, uintptr_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(uintptr_t, a, b); } + +inline void libsimple_qsort_uintptrp_nul(uintptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_uintptrpp_nul); } + +inline int libsimple_cmp_rev_uintptrp(const uintptr_t *a, const uintptr_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(uintptr_t, a, b); } + +inline void libsimple_qsort_rev_uintptr(uintptr_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintptrp); } + +inline int libsimple_cmp_rev_uintptrpp(uintptr_t *const *a, uintptr_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(uintptr_t, a, b); } + +inline void libsimple_qsort_rev_uintptrp(uintptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintptrpp); } + +inline int libsimple_cmp_nul_rev_uintptrpp(uintptr_t *const *a, uintptr_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(uintptr_t, a, b); } + +inline void libsimple_qsort_nul_rev_uintptrp(uintptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_uintptrpp); } + +inline int libsimple_cmp_rev_uintptrpp_nul(uintptr_t *const *a, uintptr_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(uintptr_t, a, b); } + +inline void libsimple_qsort_rev_uintptrp_nul(uintptr_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_uintptrpp_nul); } + +inline int libsimple_cmp_ptrdiffp(const ptrdiff_t *a, const ptrdiff_t *b) +{ LIBSIMPLE_CMP_NUMP__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_ptrdiff(ptrdiff_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ptrdiffp); } + +inline int libsimple_cmp_ptrdiffpp(ptrdiff_t *const *a, ptrdiff_t *const *b) +{ LIBSIMPLE_CMP_NUMPP__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_ptrdiffp(ptrdiff_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ptrdiffpp); } + +inline int libsimple_cmp_nul_ptrdiffpp(ptrdiff_t *const *a, ptrdiff_t *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_nul_ptrdiffp(ptrdiff_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_ptrdiffpp); } + +inline int libsimple_cmp_ptrdiffpp_nul(ptrdiff_t *const *a, ptrdiff_t *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_ptrdiffp_nul(ptrdiff_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_ptrdiffpp_nul); } + +inline int libsimple_cmp_rev_ptrdiffp(const ptrdiff_t *a, const ptrdiff_t *b) +{ LIBSIMPLE_CMP_REV_NUMP__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_rev_ptrdiff(ptrdiff_t base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ptrdiffp); } + +inline int libsimple_cmp_rev_ptrdiffpp(ptrdiff_t *const *a, ptrdiff_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_rev_ptrdiffp(ptrdiff_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ptrdiffpp); } + +inline int libsimple_cmp_nul_rev_ptrdiffpp(ptrdiff_t *const *a, ptrdiff_t *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_nul_rev_ptrdiffp(ptrdiff_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_ptrdiffpp); } + +inline int libsimple_cmp_rev_ptrdiffpp_nul(ptrdiff_t *const *a, ptrdiff_t *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(ptrdiff_t, a, b); } + +inline void libsimple_qsort_rev_ptrdiffp_nul(ptrdiff_t *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_ptrdiffpp_nul); } + +inline int libsimple_cmp_floatp(const float *a, const float *b) +{ LIBSIMPLE_CMP_NUMP__(float, a, b); } + +inline void libsimple_qsort_float(float base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_floatp); } + +inline int libsimple_cmp_floatpp(float *const *a, float *const *b) +{ LIBSIMPLE_CMP_NUMPP__(float, a, b); } + +inline void libsimple_qsort_floatp(float *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_floatpp); } + +inline int libsimple_cmp_nul_floatpp(float *const *a, float *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(float, a, b); } + +inline void libsimple_qsort_nul_floatp(float *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_floatpp); } + +inline int libsimple_cmp_floatpp_nul(float *const *a, float *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(float, a, b); } + +inline void libsimple_qsort_floatp_nul(float *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_floatpp_nul); } + +inline int libsimple_cmp_rev_floatp(const float *a, const float *b) +{ LIBSIMPLE_CMP_REV_NUMP__(float, a, b); } + +inline void libsimple_qsort_rev_float(float base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_floatp); } + +inline int libsimple_cmp_rev_floatpp(float *const *a, float *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(float, a, b); } + +inline void libsimple_qsort_rev_floatp(float *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_floatpp); } + +inline int libsimple_cmp_nul_rev_floatpp(float *const *a, float *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(float, a, b); } + +inline void libsimple_qsort_nul_rev_floatp(float *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_floatpp); } + +inline int libsimple_cmp_rev_floatpp_nul(float *const *a, float *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(float, a, b); } + +inline void libsimple_qsort_rev_floatp_nul(float *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_floatpp_nul); } + +inline int libsimple_cmp_doublep(const double *a, const double *b) +{ LIBSIMPLE_CMP_NUMP__(double, a, b); } + +inline void libsimple_qsort_double(double base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_doublep); } + +inline int libsimple_cmp_doublepp(double *const *a, double *const *b) +{ LIBSIMPLE_CMP_NUMPP__(double, a, b); } + +inline void libsimple_qsort_doublep(double *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_doublepp); } + +inline int libsimple_cmp_nul_doublepp(double *const *a, double *const *b) +{ LIBSIMPLE_CMP_NUL_NUMPP__(double, a, b); } + +inline void libsimple_qsort_nul_doublep(double *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_doublepp); } + +inline int libsimple_cmp_doublepp_nul(double *const *a, double *const *b) +{ LIBSIMPLE_CMP_NUMPP_NUL__(double, a, b); } + +inline void libsimple_qsort_doublep_nul(double *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_doublepp_nul); } + +inline int libsimple_cmp_rev_doublep(const double *a, const double *b) +{ LIBSIMPLE_CMP_REV_NUMP__(double, a, b); } + +inline void libsimple_qsort_rev_double(double base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_doublep); } + +inline int libsimple_cmp_rev_doublepp(double *const *a, double *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP__(double, a, b); } + +inline void libsimple_qsort_rev_doublep(double *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_doublepp); } + +inline int libsimple_cmp_nul_rev_doublepp(double *const *a, double *const *b) +{ LIBSIMPLE_CMP_NUL_REV_NUMPP__(double, a, b); } + +inline void libsimple_qsort_nul_rev_doublep(double *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_doublepp); } + +inline int libsimple_cmp_rev_doublepp_nul(double *const *a, double *const *b) +{ LIBSIMPLE_CMP_REV_NUMPP_NUL__(double, a, b); } + +inline void libsimple_qsort_rev_doublep_nul(double *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_doublepp_nul); } + +inline int libsimple_cmp_strp(const char *const *a, const char *const *b) +{ LIBSIMPLE_CMP_FUNP__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_str(const char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_strp); } + +inline int libsimple_cmp_strpp(const char **const *a, const char **const *b) +{ LIBSIMPLE_CMP_FUNPP__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_strp(const char **base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_strpp); } + +inline int libsimple_cmp_nul_strpp(const char **const *a, const char **const *b) +{ LIBSIMPLE_CMP_NUL_FUNPP__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_nul_strp(const char **base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_strpp); } + +inline int libsimple_cmp_strpp_nul(const char **const *a, const char **const *b) +{ LIBSIMPLE_CMP_FUNPP_NUL__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_strp_nul(const char **base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_strpp_nul); } + +inline int libsimple_cmp_rev_strp(const char *const *a, const char *const *b) +{ LIBSIMPLE_CMP_REV_FUNP__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_rev_str(const char *base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_strp); } + +inline int libsimple_cmp_rev_strpp(const char **const *a, const char **const *b) +{ LIBSIMPLE_CMP_REV_FUNPP__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_rev_strp(const char **base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_strpp); } + +inline int libsimple_cmp_nul_rev_strpp(const char **const *a, const char **const *b) +{ LIBSIMPLE_CMP_NUL_REV_FUNPP__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_nul_rev_strp(const char **base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_nul_rev_strpp); } + +inline int libsimple_cmp_rev_strpp_nul(const char **const *a, const char **const *b) +{ LIBSIMPLE_CMP_REV_FUNPP_NUL__(const char *, strcmp, a, b); } + +inline void libsimple_qsort_rev_strp_nul(const char **base[], size_t n) +{ qsort(base, n, sizeof(*base), (int (*)(const void *, const void *))&libsimple_cmp_rev_strpp_nul); } + + +#undef LIBSIMPLE_CMP_NUMP__ +#undef LIBSIMPLE_CMP_NUMPP__ +#undef LIBSIMPLE_CMP_NUL_NUMPP__ +#undef LIBSIMPLE_CMP_NUMPP_NUL__ +#undef LIBSIMPLE_CMP_REV_NUMP__ +#undef LIBSIMPLE_CMP_REV_NUMPP__ +#undef LIBSIMPLE_CMP_NUL_REV_NUMPP__ +#undef LIBSIMPLE_CMP_REV_NUMPP_NUL__ + +#undef LIBSIMPLE_CMP_FUNP__ +#undef LIBSIMPLE_CMP_FUNPP__ +#undef LIBSIMPLE_CMP_NUL_FUNPP__ +#undef LIBSIMPLE_CMP_FUNPP_NUL__ +#undef LIBSIMPLE_CMP_REV_FUNP__ +#undef LIBSIMPLE_CMP_REV_FUNPP__ +#undef LIBSIMPLE_CMP_NUL_REV_FUNPP__ +#undef LIBSIMPLE_CMP_REV_FUNPP_NUL__ diff --git a/qsort_double.c b/qsort_double.c new file mode 100644 index 0000000..401e528 --- /dev/null +++ b/qsort_double.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_double(double[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_doublep.c b/qsort_doublep.c new file mode 100644 index 0000000..eff458c --- /dev/null +++ b/qsort_doublep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_doublep(double *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_doublep_nul.c b/qsort_doublep_nul.c new file mode 100644 index 0000000..e497ea7 --- /dev/null +++ b/qsort_doublep_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_doublep_nul(double *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_float.c b/qsort_float.c new file mode 100644 index 0000000..d4798aa --- /dev/null +++ b/qsort_float.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_float(float[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_floatp.c b/qsort_floatp.c new file mode 100644 index 0000000..910c2e6 --- /dev/null +++ b/qsort_floatp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_floatp(float *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_floatp_nul.c b/qsort_floatp_nul.c new file mode 100644 index 0000000..72bb34e --- /dev/null +++ b/qsort_floatp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_floatp_nul(float *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int.c b/qsort_int.c new file mode 100644 index 0000000..8b59e62 --- /dev/null +++ b/qsort_int.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int(int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int16.c b/qsort_int16.c new file mode 100644 index 0000000..27d12bf --- /dev/null +++ b/qsort_int16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int16(int16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int16p.c b/qsort_int16p.c new file mode 100644 index 0000000..6568631 --- /dev/null +++ b/qsort_int16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int16p(int16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int16p_nul.c b/qsort_int16p_nul.c new file mode 100644 index 0000000..407e594 --- /dev/null +++ b/qsort_int16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int16p_nul(int16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int32.c b/qsort_int32.c new file mode 100644 index 0000000..d4c1e84 --- /dev/null +++ b/qsort_int32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int32(int32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int32p.c b/qsort_int32p.c new file mode 100644 index 0000000..fa1083b --- /dev/null +++ b/qsort_int32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int32p(int32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int32p_nul.c b/qsort_int32p_nul.c new file mode 100644 index 0000000..49d3116 --- /dev/null +++ b/qsort_int32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int32p_nul(int32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int64.c b/qsort_int64.c new file mode 100644 index 0000000..020dab0 --- /dev/null +++ b/qsort_int64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int64(int64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int64p.c b/qsort_int64p.c new file mode 100644 index 0000000..0cf2824 --- /dev/null +++ b/qsort_int64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int64p(int64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int64p_nul.c b/qsort_int64p_nul.c new file mode 100644 index 0000000..82f711b --- /dev/null +++ b/qsort_int64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int64p_nul(int64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int8.c b/qsort_int8.c new file mode 100644 index 0000000..40638ca --- /dev/null +++ b/qsort_int8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int8(int8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int8p.c b/qsort_int8p.c new file mode 100644 index 0000000..b5a2ca5 --- /dev/null +++ b/qsort_int8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int8p(int8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int8p_nul.c b/qsort_int8p_nul.c new file mode 100644 index 0000000..96a54ea --- /dev/null +++ b/qsort_int8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int8p_nul(int8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least16.c b/qsort_int_least16.c new file mode 100644 index 0000000..83e7849 --- /dev/null +++ b/qsort_int_least16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least16(int_least16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least16p.c b/qsort_int_least16p.c new file mode 100644 index 0000000..a18577e --- /dev/null +++ b/qsort_int_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least16p(int_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least16p_nul.c b/qsort_int_least16p_nul.c new file mode 100644 index 0000000..0e7f136 --- /dev/null +++ b/qsort_int_least16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least16p_nul(int_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least32.c b/qsort_int_least32.c new file mode 100644 index 0000000..fae4c86 --- /dev/null +++ b/qsort_int_least32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least32(int_least32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least32p.c b/qsort_int_least32p.c new file mode 100644 index 0000000..0489fa4 --- /dev/null +++ b/qsort_int_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least32p(int_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least32p_nul.c b/qsort_int_least32p_nul.c new file mode 100644 index 0000000..ab88e23 --- /dev/null +++ b/qsort_int_least32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least32p_nul(int_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least64.c b/qsort_int_least64.c new file mode 100644 index 0000000..76ad200 --- /dev/null +++ b/qsort_int_least64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least64(int_least64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least64p.c b/qsort_int_least64p.c new file mode 100644 index 0000000..a148140 --- /dev/null +++ b/qsort_int_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least64p(int_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least64p_nul.c b/qsort_int_least64p_nul.c new file mode 100644 index 0000000..ba2a57e --- /dev/null +++ b/qsort_int_least64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least64p_nul(int_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least8.c b/qsort_int_least8.c new file mode 100644 index 0000000..34b1097 --- /dev/null +++ b/qsort_int_least8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least8(int_least8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least8p.c b/qsort_int_least8p.c new file mode 100644 index 0000000..f596049 --- /dev/null +++ b/qsort_int_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least8p(int_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_int_least8p_nul.c b/qsort_int_least8p_nul.c new file mode 100644 index 0000000..db45d3c --- /dev/null +++ b/qsort_int_least8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_int_least8p_nul(int_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intmax.c b/qsort_intmax.c new file mode 100644 index 0000000..5e81930 --- /dev/null +++ b/qsort_intmax.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intmax(intmax_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intmaxp.c b/qsort_intmaxp.c new file mode 100644 index 0000000..fc74910 --- /dev/null +++ b/qsort_intmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intmaxp(intmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intmaxp_nul.c b/qsort_intmaxp_nul.c new file mode 100644 index 0000000..3704633 --- /dev/null +++ b/qsort_intmaxp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intmaxp_nul(intmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intp.c b/qsort_intp.c new file mode 100644 index 0000000..70250d3 --- /dev/null +++ b/qsort_intp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intp(int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intp_nul.c b/qsort_intp_nul.c new file mode 100644 index 0000000..a6e87e1 --- /dev/null +++ b/qsort_intp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intp_nul(int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intptr.c b/qsort_intptr.c new file mode 100644 index 0000000..f65c116 --- /dev/null +++ b/qsort_intptr.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intptr(intptr_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intptrp.c b/qsort_intptrp.c new file mode 100644 index 0000000..569becb --- /dev/null +++ b/qsort_intptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intptrp(intptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_intptrp_nul.c b/qsort_intptrp_nul.c new file mode 100644 index 0000000..588259a --- /dev/null +++ b/qsort_intptrp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_intptrp_nul(intptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_llong.c b/qsort_llong.c new file mode 100644 index 0000000..f8bff7d --- /dev/null +++ b/qsort_llong.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_llong(long long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_llongp.c b/qsort_llongp.c new file mode 100644 index 0000000..664e8b0 --- /dev/null +++ b/qsort_llongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_llongp(long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_llongp_nul.c b/qsort_llongp_nul.c new file mode 100644 index 0000000..c869a98 --- /dev/null +++ b/qsort_llongp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_llongp_nul(long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_long.c b/qsort_long.c new file mode 100644 index 0000000..cd0581e --- /dev/null +++ b/qsort_long.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_long(long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_longp.c b/qsort_longp.c new file mode 100644 index 0000000..0538a5c --- /dev/null +++ b/qsort_longp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_longp(long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_longp_nul.c b/qsort_longp_nul.c new file mode 100644 index 0000000..3fea902 --- /dev/null +++ b/qsort_longp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_longp_nul(long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_doublep.c b/qsort_nul_doublep.c new file mode 100644 index 0000000..ca89bce --- /dev/null +++ b/qsort_nul_doublep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_doublep(double *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_floatp.c b/qsort_nul_floatp.c new file mode 100644 index 0000000..8b13a47 --- /dev/null +++ b/qsort_nul_floatp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_floatp(float *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int16p.c b/qsort_nul_int16p.c new file mode 100644 index 0000000..382c444 --- /dev/null +++ b/qsort_nul_int16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int16p(int16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int32p.c b/qsort_nul_int32p.c new file mode 100644 index 0000000..50579b0 --- /dev/null +++ b/qsort_nul_int32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int32p(int32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int64p.c b/qsort_nul_int64p.c new file mode 100644 index 0000000..3e2b89d --- /dev/null +++ b/qsort_nul_int64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int64p(int64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int8p.c b/qsort_nul_int8p.c new file mode 100644 index 0000000..68bbb8f --- /dev/null +++ b/qsort_nul_int8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int8p(int8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int_least16p.c b/qsort_nul_int_least16p.c new file mode 100644 index 0000000..fe80d4d --- /dev/null +++ b/qsort_nul_int_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int_least16p(int_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int_least32p.c b/qsort_nul_int_least32p.c new file mode 100644 index 0000000..d4b3b70 --- /dev/null +++ b/qsort_nul_int_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int_least32p(int_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int_least64p.c b/qsort_nul_int_least64p.c new file mode 100644 index 0000000..be5d9dd --- /dev/null +++ b/qsort_nul_int_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int_least64p(int_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_int_least8p.c b/qsort_nul_int_least8p.c new file mode 100644 index 0000000..2961025 --- /dev/null +++ b/qsort_nul_int_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_int_least8p(int_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_intmaxp.c b/qsort_nul_intmaxp.c new file mode 100644 index 0000000..394d7d9 --- /dev/null +++ b/qsort_nul_intmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_intmaxp(intmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_intp.c b/qsort_nul_intp.c new file mode 100644 index 0000000..30971f4 --- /dev/null +++ b/qsort_nul_intp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_intp(int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_intptrp.c b/qsort_nul_intptrp.c new file mode 100644 index 0000000..e88e9a3 --- /dev/null +++ b/qsort_nul_intptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_intptrp(intptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_llongp.c b/qsort_nul_llongp.c new file mode 100644 index 0000000..c3d85cf --- /dev/null +++ b/qsort_nul_llongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_llongp(long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_longp.c b/qsort_nul_longp.c new file mode 100644 index 0000000..61b8fe6 --- /dev/null +++ b/qsort_nul_longp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_longp(long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_ptrdiffp.c b/qsort_nul_ptrdiffp.c new file mode 100644 index 0000000..d2948e0 --- /dev/null +++ b/qsort_nul_ptrdiffp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_ptrdiffp(ptrdiff_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_doublep.c b/qsort_nul_rev_doublep.c new file mode 100644 index 0000000..bdb14dc --- /dev/null +++ b/qsort_nul_rev_doublep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_doublep(double *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_floatp.c b/qsort_nul_rev_floatp.c new file mode 100644 index 0000000..8962213 --- /dev/null +++ b/qsort_nul_rev_floatp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_floatp(float *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int16p.c b/qsort_nul_rev_int16p.c new file mode 100644 index 0000000..7d3d488 --- /dev/null +++ b/qsort_nul_rev_int16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int16p(int16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int32p.c b/qsort_nul_rev_int32p.c new file mode 100644 index 0000000..5035e66 --- /dev/null +++ b/qsort_nul_rev_int32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int32p(int32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int64p.c b/qsort_nul_rev_int64p.c new file mode 100644 index 0000000..63739cf --- /dev/null +++ b/qsort_nul_rev_int64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int64p(int64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int8p.c b/qsort_nul_rev_int8p.c new file mode 100644 index 0000000..fb474e1 --- /dev/null +++ b/qsort_nul_rev_int8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int8p(int8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int_least16p.c b/qsort_nul_rev_int_least16p.c new file mode 100644 index 0000000..d302a46 --- /dev/null +++ b/qsort_nul_rev_int_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int_least16p(int_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int_least32p.c b/qsort_nul_rev_int_least32p.c new file mode 100644 index 0000000..f84fc32 --- /dev/null +++ b/qsort_nul_rev_int_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int_least32p(int_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int_least64p.c b/qsort_nul_rev_int_least64p.c new file mode 100644 index 0000000..19d880c --- /dev/null +++ b/qsort_nul_rev_int_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int_least64p(int_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_int_least8p.c b/qsort_nul_rev_int_least8p.c new file mode 100644 index 0000000..4da5625 --- /dev/null +++ b/qsort_nul_rev_int_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_int_least8p(int_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_intmaxp.c b/qsort_nul_rev_intmaxp.c new file mode 100644 index 0000000..e2558b7 --- /dev/null +++ b/qsort_nul_rev_intmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_intmaxp(intmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_intp.c b/qsort_nul_rev_intp.c new file mode 100644 index 0000000..e9cbf60 --- /dev/null +++ b/qsort_nul_rev_intp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_intp(int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_intptrp.c b/qsort_nul_rev_intptrp.c new file mode 100644 index 0000000..a26fc92 --- /dev/null +++ b/qsort_nul_rev_intptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_intptrp(intptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_llongp.c b/qsort_nul_rev_llongp.c new file mode 100644 index 0000000..ae796c7 --- /dev/null +++ b/qsort_nul_rev_llongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_llongp(long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_longp.c b/qsort_nul_rev_longp.c new file mode 100644 index 0000000..460e8df --- /dev/null +++ b/qsort_nul_rev_longp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_longp(long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_ptrdiffp.c b/qsort_nul_rev_ptrdiffp.c new file mode 100644 index 0000000..4e087d2 --- /dev/null +++ b/qsort_nul_rev_ptrdiffp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_ptrdiffp(ptrdiff_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_scharp.c b/qsort_nul_rev_scharp.c new file mode 100644 index 0000000..c8dfdec --- /dev/null +++ b/qsort_nul_rev_scharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_scharp(signed char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_shortp.c b/qsort_nul_rev_shortp.c new file mode 100644 index 0000000..3f856f1 --- /dev/null +++ b/qsort_nul_rev_shortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_shortp(short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_sizep.c b/qsort_nul_rev_sizep.c new file mode 100644 index 0000000..e979236 --- /dev/null +++ b/qsort_nul_rev_sizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_sizep(size_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_ssizep.c b/qsort_nul_rev_ssizep.c new file mode 100644 index 0000000..345681e --- /dev/null +++ b/qsort_nul_rev_ssizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_ssizep(ssize_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_strp.c b/qsort_nul_rev_strp.c new file mode 100644 index 0000000..20c41d7 --- /dev/null +++ b/qsort_nul_rev_strp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_strp(const char **[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_ucharp.c b/qsort_nul_rev_ucharp.c new file mode 100644 index 0000000..6990982 --- /dev/null +++ b/qsort_nul_rev_ucharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_ucharp(unsigned char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint16p.c b/qsort_nul_rev_uint16p.c new file mode 100644 index 0000000..4b3e297 --- /dev/null +++ b/qsort_nul_rev_uint16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint16p(uint16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint32p.c b/qsort_nul_rev_uint32p.c new file mode 100644 index 0000000..ecffb5d --- /dev/null +++ b/qsort_nul_rev_uint32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint32p(uint32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint64p.c b/qsort_nul_rev_uint64p.c new file mode 100644 index 0000000..8b436f8 --- /dev/null +++ b/qsort_nul_rev_uint64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint64p(uint64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint8p.c b/qsort_nul_rev_uint8p.c new file mode 100644 index 0000000..520bbfe --- /dev/null +++ b/qsort_nul_rev_uint8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint8p(uint8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint_least16p.c b/qsort_nul_rev_uint_least16p.c new file mode 100644 index 0000000..5fff034 --- /dev/null +++ b/qsort_nul_rev_uint_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint_least16p(uint_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint_least32p.c b/qsort_nul_rev_uint_least32p.c new file mode 100644 index 0000000..f886c6a --- /dev/null +++ b/qsort_nul_rev_uint_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint_least32p(uint_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint_least64p.c b/qsort_nul_rev_uint_least64p.c new file mode 100644 index 0000000..a7929b6 --- /dev/null +++ b/qsort_nul_rev_uint_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint_least64p(uint_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uint_least8p.c b/qsort_nul_rev_uint_least8p.c new file mode 100644 index 0000000..8208519 --- /dev/null +++ b/qsort_nul_rev_uint_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uint_least8p(uint_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uintmaxp.c b/qsort_nul_rev_uintmaxp.c new file mode 100644 index 0000000..0f00a05 --- /dev/null +++ b/qsort_nul_rev_uintmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uintmaxp(uintmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uintp.c b/qsort_nul_rev_uintp.c new file mode 100644 index 0000000..96485cc --- /dev/null +++ b/qsort_nul_rev_uintp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uintp(unsigned int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_uintptrp.c b/qsort_nul_rev_uintptrp.c new file mode 100644 index 0000000..98495d1 --- /dev/null +++ b/qsort_nul_rev_uintptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_uintptrp(uintptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_ullongp.c b/qsort_nul_rev_ullongp.c new file mode 100644 index 0000000..60777c3 --- /dev/null +++ b/qsort_nul_rev_ullongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_ullongp(unsigned long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_ulongp.c b/qsort_nul_rev_ulongp.c new file mode 100644 index 0000000..407c405 --- /dev/null +++ b/qsort_nul_rev_ulongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_ulongp(unsigned long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_rev_ushortp.c b/qsort_nul_rev_ushortp.c new file mode 100644 index 0000000..ebcc34c --- /dev/null +++ b/qsort_nul_rev_ushortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_rev_ushortp(unsigned short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_scharp.c b/qsort_nul_scharp.c new file mode 100644 index 0000000..1661018 --- /dev/null +++ b/qsort_nul_scharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_scharp(signed char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_shortp.c b/qsort_nul_shortp.c new file mode 100644 index 0000000..1d0e34c --- /dev/null +++ b/qsort_nul_shortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_shortp(short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_sizep.c b/qsort_nul_sizep.c new file mode 100644 index 0000000..c10692f --- /dev/null +++ b/qsort_nul_sizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_sizep(size_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_ssizep.c b/qsort_nul_ssizep.c new file mode 100644 index 0000000..881547e --- /dev/null +++ b/qsort_nul_ssizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_ssizep(ssize_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_strp.c b/qsort_nul_strp.c new file mode 100644 index 0000000..eace016 --- /dev/null +++ b/qsort_nul_strp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_strp(const char **[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_ucharp.c b/qsort_nul_ucharp.c new file mode 100644 index 0000000..af1a37a --- /dev/null +++ b/qsort_nul_ucharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_ucharp(unsigned char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint16p.c b/qsort_nul_uint16p.c new file mode 100644 index 0000000..37cf274 --- /dev/null +++ b/qsort_nul_uint16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint16p(uint16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint32p.c b/qsort_nul_uint32p.c new file mode 100644 index 0000000..7db5d0e --- /dev/null +++ b/qsort_nul_uint32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint32p(uint32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint64p.c b/qsort_nul_uint64p.c new file mode 100644 index 0000000..d37b585 --- /dev/null +++ b/qsort_nul_uint64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint64p(uint64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint8p.c b/qsort_nul_uint8p.c new file mode 100644 index 0000000..55195be --- /dev/null +++ b/qsort_nul_uint8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint8p(uint8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint_least16p.c b/qsort_nul_uint_least16p.c new file mode 100644 index 0000000..4b04a19 --- /dev/null +++ b/qsort_nul_uint_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint_least16p(uint_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint_least32p.c b/qsort_nul_uint_least32p.c new file mode 100644 index 0000000..fcf5799 --- /dev/null +++ b/qsort_nul_uint_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint_least32p(uint_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint_least64p.c b/qsort_nul_uint_least64p.c new file mode 100644 index 0000000..f0492bb --- /dev/null +++ b/qsort_nul_uint_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint_least64p(uint_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uint_least8p.c b/qsort_nul_uint_least8p.c new file mode 100644 index 0000000..6b01670 --- /dev/null +++ b/qsort_nul_uint_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uint_least8p(uint_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uintmaxp.c b/qsort_nul_uintmaxp.c new file mode 100644 index 0000000..7054f44 --- /dev/null +++ b/qsort_nul_uintmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uintmaxp(uintmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uintp.c b/qsort_nul_uintp.c new file mode 100644 index 0000000..800d33b --- /dev/null +++ b/qsort_nul_uintp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uintp(unsigned int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_uintptrp.c b/qsort_nul_uintptrp.c new file mode 100644 index 0000000..c775bf9 --- /dev/null +++ b/qsort_nul_uintptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_uintptrp(uintptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_ullongp.c b/qsort_nul_ullongp.c new file mode 100644 index 0000000..52cc851 --- /dev/null +++ b/qsort_nul_ullongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_ullongp(unsigned long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_ulongp.c b/qsort_nul_ulongp.c new file mode 100644 index 0000000..97ae0c3 --- /dev/null +++ b/qsort_nul_ulongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_ulongp(unsigned long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_nul_ushortp.c b/qsort_nul_ushortp.c new file mode 100644 index 0000000..b3ed238 --- /dev/null +++ b/qsort_nul_ushortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_nul_ushortp(unsigned short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ptrdiff.c b/qsort_ptrdiff.c new file mode 100644 index 0000000..e9665e0 --- /dev/null +++ b/qsort_ptrdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ptrdiff(ptrdiff_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ptrdiffp.c b/qsort_ptrdiffp.c new file mode 100644 index 0000000..4d2625a --- /dev/null +++ b/qsort_ptrdiffp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ptrdiffp(ptrdiff_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ptrdiffp_nul.c b/qsort_ptrdiffp_nul.c new file mode 100644 index 0000000..d301fb5 --- /dev/null +++ b/qsort_ptrdiffp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ptrdiffp_nul(ptrdiff_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_double.c b/qsort_rev_double.c new file mode 100644 index 0000000..a6a0375 --- /dev/null +++ b/qsort_rev_double.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_double(double[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_doublep.c b/qsort_rev_doublep.c new file mode 100644 index 0000000..69cd4dd --- /dev/null +++ b/qsort_rev_doublep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_doublep(double *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_doublep_nul.c b/qsort_rev_doublep_nul.c new file mode 100644 index 0000000..b8b485f --- /dev/null +++ b/qsort_rev_doublep_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_doublep_nul(double *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_float.c b/qsort_rev_float.c new file mode 100644 index 0000000..51c17af --- /dev/null +++ b/qsort_rev_float.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_float(float[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_floatp.c b/qsort_rev_floatp.c new file mode 100644 index 0000000..5014ebe --- /dev/null +++ b/qsort_rev_floatp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_floatp(float *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_floatp_nul.c b/qsort_rev_floatp_nul.c new file mode 100644 index 0000000..b65b531 --- /dev/null +++ b/qsort_rev_floatp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_floatp_nul(float *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int.c b/qsort_rev_int.c new file mode 100644 index 0000000..616cb6e --- /dev/null +++ b/qsort_rev_int.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int(int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int16.c b/qsort_rev_int16.c new file mode 100644 index 0000000..99baeeb --- /dev/null +++ b/qsort_rev_int16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int16(int16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int16p.c b/qsort_rev_int16p.c new file mode 100644 index 0000000..6018501 --- /dev/null +++ b/qsort_rev_int16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int16p(int16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int16p_nul.c b/qsort_rev_int16p_nul.c new file mode 100644 index 0000000..1c13a00 --- /dev/null +++ b/qsort_rev_int16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int16p_nul(int16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int32.c b/qsort_rev_int32.c new file mode 100644 index 0000000..064e1fc --- /dev/null +++ b/qsort_rev_int32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int32(int32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int32p.c b/qsort_rev_int32p.c new file mode 100644 index 0000000..a2e0bae --- /dev/null +++ b/qsort_rev_int32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int32p(int32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int32p_nul.c b/qsort_rev_int32p_nul.c new file mode 100644 index 0000000..eb97627 --- /dev/null +++ b/qsort_rev_int32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int32p_nul(int32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int64.c b/qsort_rev_int64.c new file mode 100644 index 0000000..4005d1c --- /dev/null +++ b/qsort_rev_int64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int64(int64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int64p.c b/qsort_rev_int64p.c new file mode 100644 index 0000000..f71329d --- /dev/null +++ b/qsort_rev_int64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int64p(int64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int64p_nul.c b/qsort_rev_int64p_nul.c new file mode 100644 index 0000000..20e19f8 --- /dev/null +++ b/qsort_rev_int64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int64p_nul(int64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int8.c b/qsort_rev_int8.c new file mode 100644 index 0000000..1aa2476 --- /dev/null +++ b/qsort_rev_int8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int8(int8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int8p.c b/qsort_rev_int8p.c new file mode 100644 index 0000000..863f77c --- /dev/null +++ b/qsort_rev_int8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int8p(int8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int8p_nul.c b/qsort_rev_int8p_nul.c new file mode 100644 index 0000000..5a508ce --- /dev/null +++ b/qsort_rev_int8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int8p_nul(int8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least16.c b/qsort_rev_int_least16.c new file mode 100644 index 0000000..ec11b00 --- /dev/null +++ b/qsort_rev_int_least16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least16(int_least16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least16p.c b/qsort_rev_int_least16p.c new file mode 100644 index 0000000..fc329ef --- /dev/null +++ b/qsort_rev_int_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least16p(int_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least16p_nul.c b/qsort_rev_int_least16p_nul.c new file mode 100644 index 0000000..905cf7c --- /dev/null +++ b/qsort_rev_int_least16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least16p_nul(int_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least32.c b/qsort_rev_int_least32.c new file mode 100644 index 0000000..2d32ec1 --- /dev/null +++ b/qsort_rev_int_least32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least32(int_least32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least32p.c b/qsort_rev_int_least32p.c new file mode 100644 index 0000000..0c227a9 --- /dev/null +++ b/qsort_rev_int_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least32p(int_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least32p_nul.c b/qsort_rev_int_least32p_nul.c new file mode 100644 index 0000000..30f30e3 --- /dev/null +++ b/qsort_rev_int_least32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least32p_nul(int_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least64.c b/qsort_rev_int_least64.c new file mode 100644 index 0000000..f7e663b --- /dev/null +++ b/qsort_rev_int_least64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least64(int_least64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least64p.c b/qsort_rev_int_least64p.c new file mode 100644 index 0000000..996d8f2 --- /dev/null +++ b/qsort_rev_int_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least64p(int_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least64p_nul.c b/qsort_rev_int_least64p_nul.c new file mode 100644 index 0000000..aab34dc --- /dev/null +++ b/qsort_rev_int_least64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least64p_nul(int_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least8.c b/qsort_rev_int_least8.c new file mode 100644 index 0000000..50445ca --- /dev/null +++ b/qsort_rev_int_least8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least8(int_least8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least8p.c b/qsort_rev_int_least8p.c new file mode 100644 index 0000000..5f755e7 --- /dev/null +++ b/qsort_rev_int_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least8p(int_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_int_least8p_nul.c b/qsort_rev_int_least8p_nul.c new file mode 100644 index 0000000..f204ae3 --- /dev/null +++ b/qsort_rev_int_least8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_int_least8p_nul(int_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intmax.c b/qsort_rev_intmax.c new file mode 100644 index 0000000..26593da --- /dev/null +++ b/qsort_rev_intmax.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intmax(intmax_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intmaxp.c b/qsort_rev_intmaxp.c new file mode 100644 index 0000000..c3d97fd --- /dev/null +++ b/qsort_rev_intmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intmaxp(intmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intmaxp_nul.c b/qsort_rev_intmaxp_nul.c new file mode 100644 index 0000000..2de6bcd --- /dev/null +++ b/qsort_rev_intmaxp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intmaxp_nul(intmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intp.c b/qsort_rev_intp.c new file mode 100644 index 0000000..cd79a9e --- /dev/null +++ b/qsort_rev_intp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intp(int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intp_nul.c b/qsort_rev_intp_nul.c new file mode 100644 index 0000000..7f4b29f --- /dev/null +++ b/qsort_rev_intp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intp_nul(int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intptr.c b/qsort_rev_intptr.c new file mode 100644 index 0000000..421078c --- /dev/null +++ b/qsort_rev_intptr.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intptr(intptr_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intptrp.c b/qsort_rev_intptrp.c new file mode 100644 index 0000000..14c50f6 --- /dev/null +++ b/qsort_rev_intptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intptrp(intptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_intptrp_nul.c b/qsort_rev_intptrp_nul.c new file mode 100644 index 0000000..e83d39c --- /dev/null +++ b/qsort_rev_intptrp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_intptrp_nul(intptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_llong.c b/qsort_rev_llong.c new file mode 100644 index 0000000..dfea11e --- /dev/null +++ b/qsort_rev_llong.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_llong(long long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_llongp.c b/qsort_rev_llongp.c new file mode 100644 index 0000000..2dba49c --- /dev/null +++ b/qsort_rev_llongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_llongp(long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_llongp_nul.c b/qsort_rev_llongp_nul.c new file mode 100644 index 0000000..55fdd26 --- /dev/null +++ b/qsort_rev_llongp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_llongp_nul(long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_long.c b/qsort_rev_long.c new file mode 100644 index 0000000..bff6bfb --- /dev/null +++ b/qsort_rev_long.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_long(long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_longp.c b/qsort_rev_longp.c new file mode 100644 index 0000000..091d3b3 --- /dev/null +++ b/qsort_rev_longp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_longp(long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_longp_nul.c b/qsort_rev_longp_nul.c new file mode 100644 index 0000000..d2da55c --- /dev/null +++ b/qsort_rev_longp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_longp_nul(long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ptrdiff.c b/qsort_rev_ptrdiff.c new file mode 100644 index 0000000..369098a --- /dev/null +++ b/qsort_rev_ptrdiff.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ptrdiff(ptrdiff_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ptrdiffp.c b/qsort_rev_ptrdiffp.c new file mode 100644 index 0000000..617246e --- /dev/null +++ b/qsort_rev_ptrdiffp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ptrdiffp(ptrdiff_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ptrdiffp_nul.c b/qsort_rev_ptrdiffp_nul.c new file mode 100644 index 0000000..a32e877 --- /dev/null +++ b/qsort_rev_ptrdiffp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ptrdiffp_nul(ptrdiff_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_schar.c b/qsort_rev_schar.c new file mode 100644 index 0000000..ec23672 --- /dev/null +++ b/qsort_rev_schar.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_schar(signed char[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_scharp.c b/qsort_rev_scharp.c new file mode 100644 index 0000000..3581019 --- /dev/null +++ b/qsort_rev_scharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_scharp(signed char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_scharp_nul.c b/qsort_rev_scharp_nul.c new file mode 100644 index 0000000..a7b6845 --- /dev/null +++ b/qsort_rev_scharp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_scharp_nul(signed char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_short.c b/qsort_rev_short.c new file mode 100644 index 0000000..9eefaf9 --- /dev/null +++ b/qsort_rev_short.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_short(short int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_shortp.c b/qsort_rev_shortp.c new file mode 100644 index 0000000..3a883a3 --- /dev/null +++ b/qsort_rev_shortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_shortp(short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_shortp_nul.c b/qsort_rev_shortp_nul.c new file mode 100644 index 0000000..f3c989a --- /dev/null +++ b/qsort_rev_shortp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_shortp_nul(short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_size.c b/qsort_rev_size.c new file mode 100644 index 0000000..715c203 --- /dev/null +++ b/qsort_rev_size.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_size(size_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_sizep.c b/qsort_rev_sizep.c new file mode 100644 index 0000000..6acecba --- /dev/null +++ b/qsort_rev_sizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_sizep(size_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_sizep_nul.c b/qsort_rev_sizep_nul.c new file mode 100644 index 0000000..cd08674 --- /dev/null +++ b/qsort_rev_sizep_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_sizep_nul(size_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ssize.c b/qsort_rev_ssize.c new file mode 100644 index 0000000..9ea1042 --- /dev/null +++ b/qsort_rev_ssize.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ssize(ssize_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ssizep.c b/qsort_rev_ssizep.c new file mode 100644 index 0000000..7660fb8 --- /dev/null +++ b/qsort_rev_ssizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ssizep(ssize_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ssizep_nul.c b/qsort_rev_ssizep_nul.c new file mode 100644 index 0000000..3eb1eb3 --- /dev/null +++ b/qsort_rev_ssizep_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ssizep_nul(ssize_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_str.c b/qsort_rev_str.c new file mode 100644 index 0000000..582895e --- /dev/null +++ b/qsort_rev_str.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_str(const char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_strp.c b/qsort_rev_strp.c new file mode 100644 index 0000000..0017956 --- /dev/null +++ b/qsort_rev_strp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_strp(const char **[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_strp_nul.c b/qsort_rev_strp_nul.c new file mode 100644 index 0000000..b4d1b47 --- /dev/null +++ b/qsort_rev_strp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_strp_nul(const char **[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uchar.c b/qsort_rev_uchar.c new file mode 100644 index 0000000..37822b5 --- /dev/null +++ b/qsort_rev_uchar.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uchar(unsigned char[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ucharp.c b/qsort_rev_ucharp.c new file mode 100644 index 0000000..8a00662 --- /dev/null +++ b/qsort_rev_ucharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ucharp(unsigned char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ucharp_nul.c b/qsort_rev_ucharp_nul.c new file mode 100644 index 0000000..379817f --- /dev/null +++ b/qsort_rev_ucharp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ucharp_nul(unsigned char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint.c b/qsort_rev_uint.c new file mode 100644 index 0000000..2ed8677 --- /dev/null +++ b/qsort_rev_uint.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint(unsigned int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint16.c b/qsort_rev_uint16.c new file mode 100644 index 0000000..ec439ab --- /dev/null +++ b/qsort_rev_uint16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint16(uint16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint16p.c b/qsort_rev_uint16p.c new file mode 100644 index 0000000..37243c1 --- /dev/null +++ b/qsort_rev_uint16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint16p(uint16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint16p_nul.c b/qsort_rev_uint16p_nul.c new file mode 100644 index 0000000..51eb068 --- /dev/null +++ b/qsort_rev_uint16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint16p_nul(uint16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint32.c b/qsort_rev_uint32.c new file mode 100644 index 0000000..8d5b7ca --- /dev/null +++ b/qsort_rev_uint32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint32(uint32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint32p.c b/qsort_rev_uint32p.c new file mode 100644 index 0000000..9c4cab3 --- /dev/null +++ b/qsort_rev_uint32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint32p(uint32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint32p_nul.c b/qsort_rev_uint32p_nul.c new file mode 100644 index 0000000..81f15ce --- /dev/null +++ b/qsort_rev_uint32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint32p_nul(uint32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint64.c b/qsort_rev_uint64.c new file mode 100644 index 0000000..96fe65f --- /dev/null +++ b/qsort_rev_uint64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint64(uint64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint64p.c b/qsort_rev_uint64p.c new file mode 100644 index 0000000..d3e0351 --- /dev/null +++ b/qsort_rev_uint64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint64p(uint64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint64p_nul.c b/qsort_rev_uint64p_nul.c new file mode 100644 index 0000000..c29c91c --- /dev/null +++ b/qsort_rev_uint64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint64p_nul(uint64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint8.c b/qsort_rev_uint8.c new file mode 100644 index 0000000..fd1ae21 --- /dev/null +++ b/qsort_rev_uint8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint8(uint8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint8p.c b/qsort_rev_uint8p.c new file mode 100644 index 0000000..58d7391 --- /dev/null +++ b/qsort_rev_uint8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint8p(uint8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint8p_nul.c b/qsort_rev_uint8p_nul.c new file mode 100644 index 0000000..e1131c9 --- /dev/null +++ b/qsort_rev_uint8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint8p_nul(uint8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least16.c b/qsort_rev_uint_least16.c new file mode 100644 index 0000000..5e7ae4b --- /dev/null +++ b/qsort_rev_uint_least16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least16(uint_least16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least16p.c b/qsort_rev_uint_least16p.c new file mode 100644 index 0000000..d7887e7 --- /dev/null +++ b/qsort_rev_uint_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least16p(uint_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least16p_nul.c b/qsort_rev_uint_least16p_nul.c new file mode 100644 index 0000000..089f80f --- /dev/null +++ b/qsort_rev_uint_least16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least16p_nul(uint_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least32.c b/qsort_rev_uint_least32.c new file mode 100644 index 0000000..adc6d59 --- /dev/null +++ b/qsort_rev_uint_least32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least32(uint_least32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least32p.c b/qsort_rev_uint_least32p.c new file mode 100644 index 0000000..bdaafdb --- /dev/null +++ b/qsort_rev_uint_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least32p(uint_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least32p_nul.c b/qsort_rev_uint_least32p_nul.c new file mode 100644 index 0000000..3098822 --- /dev/null +++ b/qsort_rev_uint_least32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least32p_nul(uint_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least64.c b/qsort_rev_uint_least64.c new file mode 100644 index 0000000..bb08c93 --- /dev/null +++ b/qsort_rev_uint_least64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least64(uint_least64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least64p.c b/qsort_rev_uint_least64p.c new file mode 100644 index 0000000..93e7beb --- /dev/null +++ b/qsort_rev_uint_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least64p(uint_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least64p_nul.c b/qsort_rev_uint_least64p_nul.c new file mode 100644 index 0000000..42a4df8 --- /dev/null +++ b/qsort_rev_uint_least64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least64p_nul(uint_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least8.c b/qsort_rev_uint_least8.c new file mode 100644 index 0000000..559a3c0 --- /dev/null +++ b/qsort_rev_uint_least8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least8(uint_least8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least8p.c b/qsort_rev_uint_least8p.c new file mode 100644 index 0000000..e188137 --- /dev/null +++ b/qsort_rev_uint_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least8p(uint_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uint_least8p_nul.c b/qsort_rev_uint_least8p_nul.c new file mode 100644 index 0000000..19f14be --- /dev/null +++ b/qsort_rev_uint_least8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uint_least8p_nul(uint_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintmax.c b/qsort_rev_uintmax.c new file mode 100644 index 0000000..ef67dde --- /dev/null +++ b/qsort_rev_uintmax.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintmax(uintmax_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintmaxp.c b/qsort_rev_uintmaxp.c new file mode 100644 index 0000000..69a8317 --- /dev/null +++ b/qsort_rev_uintmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintmaxp(uintmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintmaxp_nul.c b/qsort_rev_uintmaxp_nul.c new file mode 100644 index 0000000..4dd7bf3 --- /dev/null +++ b/qsort_rev_uintmaxp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintmaxp_nul(uintmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintp.c b/qsort_rev_uintp.c new file mode 100644 index 0000000..543e6cf --- /dev/null +++ b/qsort_rev_uintp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintp(unsigned int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintp_nul.c b/qsort_rev_uintp_nul.c new file mode 100644 index 0000000..1398b26 --- /dev/null +++ b/qsort_rev_uintp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintp_nul(unsigned int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintptr.c b/qsort_rev_uintptr.c new file mode 100644 index 0000000..cd3a2ca --- /dev/null +++ b/qsort_rev_uintptr.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintptr(uintptr_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintptrp.c b/qsort_rev_uintptrp.c new file mode 100644 index 0000000..0488a15 --- /dev/null +++ b/qsort_rev_uintptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintptrp(uintptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_uintptrp_nul.c b/qsort_rev_uintptrp_nul.c new file mode 100644 index 0000000..f34f8b9 --- /dev/null +++ b/qsort_rev_uintptrp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_uintptrp_nul(uintptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ullong.c b/qsort_rev_ullong.c new file mode 100644 index 0000000..6791336 --- /dev/null +++ b/qsort_rev_ullong.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ullong(unsigned long long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ullongp.c b/qsort_rev_ullongp.c new file mode 100644 index 0000000..58bac57 --- /dev/null +++ b/qsort_rev_ullongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ullongp(unsigned long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ullongp_nul.c b/qsort_rev_ullongp_nul.c new file mode 100644 index 0000000..8cf02b7 --- /dev/null +++ b/qsort_rev_ullongp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ullongp_nul(unsigned long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ulong.c b/qsort_rev_ulong.c new file mode 100644 index 0000000..1923947 --- /dev/null +++ b/qsort_rev_ulong.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ulong(unsigned long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ulongp.c b/qsort_rev_ulongp.c new file mode 100644 index 0000000..eac1cf4 --- /dev/null +++ b/qsort_rev_ulongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ulongp(unsigned long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ulongp_nul.c b/qsort_rev_ulongp_nul.c new file mode 100644 index 0000000..f922fe3 --- /dev/null +++ b/qsort_rev_ulongp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ulongp_nul(unsigned long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ushort.c b/qsort_rev_ushort.c new file mode 100644 index 0000000..643988b --- /dev/null +++ b/qsort_rev_ushort.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ushort(unsigned short int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ushortp.c b/qsort_rev_ushortp.c new file mode 100644 index 0000000..00671f0 --- /dev/null +++ b/qsort_rev_ushortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ushortp(unsigned short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_rev_ushortp_nul.c b/qsort_rev_ushortp_nul.c new file mode 100644 index 0000000..1ed439b --- /dev/null +++ b/qsort_rev_ushortp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_rev_ushortp_nul(unsigned short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_schar.c b/qsort_schar.c new file mode 100644 index 0000000..ca278d6 --- /dev/null +++ b/qsort_schar.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_schar(signed char[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_scharp.c b/qsort_scharp.c new file mode 100644 index 0000000..8c787a9 --- /dev/null +++ b/qsort_scharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_scharp(signed char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_scharp_nul.c b/qsort_scharp_nul.c new file mode 100644 index 0000000..8d2b532 --- /dev/null +++ b/qsort_scharp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_scharp_nul(signed char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_short.c b/qsort_short.c new file mode 100644 index 0000000..da8c814 --- /dev/null +++ b/qsort_short.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_short(short int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_shortp.c b/qsort_shortp.c new file mode 100644 index 0000000..c3b6a52 --- /dev/null +++ b/qsort_shortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_shortp(short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_shortp_nul.c b/qsort_shortp_nul.c new file mode 100644 index 0000000..082de0a --- /dev/null +++ b/qsort_shortp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_shortp_nul(short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_size.c b/qsort_size.c new file mode 100644 index 0000000..bea2d6b --- /dev/null +++ b/qsort_size.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_size(size_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_sizep.c b/qsort_sizep.c new file mode 100644 index 0000000..8183193 --- /dev/null +++ b/qsort_sizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_sizep(size_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_sizep_nul.c b/qsort_sizep_nul.c new file mode 100644 index 0000000..28f0975 --- /dev/null +++ b/qsort_sizep_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_sizep_nul(size_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ssize.c b/qsort_ssize.c new file mode 100644 index 0000000..4d10a65 --- /dev/null +++ b/qsort_ssize.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ssize(ssize_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ssizep.c b/qsort_ssizep.c new file mode 100644 index 0000000..52ce19c --- /dev/null +++ b/qsort_ssizep.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ssizep(ssize_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ssizep_nul.c b/qsort_ssizep_nul.c new file mode 100644 index 0000000..daa3096 --- /dev/null +++ b/qsort_ssizep_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ssizep_nul(ssize_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_str.c b/qsort_str.c new file mode 100644 index 0000000..00300f7 --- /dev/null +++ b/qsort_str.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_str(const char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_strp.c b/qsort_strp.c new file mode 100644 index 0000000..7c18666 --- /dev/null +++ b/qsort_strp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_strp(const char **[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_strp_nul.c b/qsort_strp_nul.c new file mode 100644 index 0000000..84a2e32 --- /dev/null +++ b/qsort_strp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_strp_nul(const char **[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uchar.c b/qsort_uchar.c new file mode 100644 index 0000000..cc852e4 --- /dev/null +++ b/qsort_uchar.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uchar(unsigned char[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ucharp.c b/qsort_ucharp.c new file mode 100644 index 0000000..d16c082 --- /dev/null +++ b/qsort_ucharp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ucharp(unsigned char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ucharp_nul.c b/qsort_ucharp_nul.c new file mode 100644 index 0000000..f2b9344 --- /dev/null +++ b/qsort_ucharp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ucharp_nul(unsigned char *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint.c b/qsort_uint.c new file mode 100644 index 0000000..138dbf0 --- /dev/null +++ b/qsort_uint.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint(unsigned int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint16.c b/qsort_uint16.c new file mode 100644 index 0000000..790c4db --- /dev/null +++ b/qsort_uint16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint16(uint16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint16p.c b/qsort_uint16p.c new file mode 100644 index 0000000..0c54106 --- /dev/null +++ b/qsort_uint16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint16p(uint16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint16p_nul.c b/qsort_uint16p_nul.c new file mode 100644 index 0000000..f1e4782 --- /dev/null +++ b/qsort_uint16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint16p_nul(uint16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint32.c b/qsort_uint32.c new file mode 100644 index 0000000..9d14c06 --- /dev/null +++ b/qsort_uint32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint32(uint32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint32p.c b/qsort_uint32p.c new file mode 100644 index 0000000..5aff426 --- /dev/null +++ b/qsort_uint32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint32p(uint32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint32p_nul.c b/qsort_uint32p_nul.c new file mode 100644 index 0000000..eb0c6f1 --- /dev/null +++ b/qsort_uint32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint32p_nul(uint32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint64.c b/qsort_uint64.c new file mode 100644 index 0000000..7a8ffd6 --- /dev/null +++ b/qsort_uint64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint64(uint64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint64p.c b/qsort_uint64p.c new file mode 100644 index 0000000..bb1bac1 --- /dev/null +++ b/qsort_uint64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint64p(uint64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint64p_nul.c b/qsort_uint64p_nul.c new file mode 100644 index 0000000..7998606 --- /dev/null +++ b/qsort_uint64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint64p_nul(uint64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint8.c b/qsort_uint8.c new file mode 100644 index 0000000..157ba79 --- /dev/null +++ b/qsort_uint8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint8(uint8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint8p.c b/qsort_uint8p.c new file mode 100644 index 0000000..ec6ab25 --- /dev/null +++ b/qsort_uint8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint8p(uint8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint8p_nul.c b/qsort_uint8p_nul.c new file mode 100644 index 0000000..fe1713d --- /dev/null +++ b/qsort_uint8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint8p_nul(uint8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least16.c b/qsort_uint_least16.c new file mode 100644 index 0000000..969c37b --- /dev/null +++ b/qsort_uint_least16.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least16(uint_least16_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least16p.c b/qsort_uint_least16p.c new file mode 100644 index 0000000..85b91d7 --- /dev/null +++ b/qsort_uint_least16p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least16p(uint_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least16p_nul.c b/qsort_uint_least16p_nul.c new file mode 100644 index 0000000..02a3b9b --- /dev/null +++ b/qsort_uint_least16p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least16p_nul(uint_least16_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least32.c b/qsort_uint_least32.c new file mode 100644 index 0000000..916acfd --- /dev/null +++ b/qsort_uint_least32.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least32(uint_least32_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least32p.c b/qsort_uint_least32p.c new file mode 100644 index 0000000..8442668 --- /dev/null +++ b/qsort_uint_least32p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least32p(uint_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least32p_nul.c b/qsort_uint_least32p_nul.c new file mode 100644 index 0000000..fe1df12 --- /dev/null +++ b/qsort_uint_least32p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least32p_nul(uint_least32_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least64.c b/qsort_uint_least64.c new file mode 100644 index 0000000..46fede6 --- /dev/null +++ b/qsort_uint_least64.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least64(uint_least64_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least64p.c b/qsort_uint_least64p.c new file mode 100644 index 0000000..0244c00 --- /dev/null +++ b/qsort_uint_least64p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least64p(uint_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least64p_nul.c b/qsort_uint_least64p_nul.c new file mode 100644 index 0000000..3c672d1 --- /dev/null +++ b/qsort_uint_least64p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least64p_nul(uint_least64_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least8.c b/qsort_uint_least8.c new file mode 100644 index 0000000..d2e114f --- /dev/null +++ b/qsort_uint_least8.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least8(uint_least8_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least8p.c b/qsort_uint_least8p.c new file mode 100644 index 0000000..8bbe92d --- /dev/null +++ b/qsort_uint_least8p.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least8p(uint_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uint_least8p_nul.c b/qsort_uint_least8p_nul.c new file mode 100644 index 0000000..d63a17d --- /dev/null +++ b/qsort_uint_least8p_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uint_least8p_nul(uint_least8_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintmax.c b/qsort_uintmax.c new file mode 100644 index 0000000..d5e52b7 --- /dev/null +++ b/qsort_uintmax.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintmax(uintmax_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintmaxp.c b/qsort_uintmaxp.c new file mode 100644 index 0000000..644a05b --- /dev/null +++ b/qsort_uintmaxp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintmaxp(uintmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintmaxp_nul.c b/qsort_uintmaxp_nul.c new file mode 100644 index 0000000..0f23f23 --- /dev/null +++ b/qsort_uintmaxp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintmaxp_nul(uintmax_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintp.c b/qsort_uintp.c new file mode 100644 index 0000000..2a85247 --- /dev/null +++ b/qsort_uintp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintp(unsigned int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintp_nul.c b/qsort_uintp_nul.c new file mode 100644 index 0000000..0c254d7 --- /dev/null +++ b/qsort_uintp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintp_nul(unsigned int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintptr.c b/qsort_uintptr.c new file mode 100644 index 0000000..74f4a2e --- /dev/null +++ b/qsort_uintptr.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintptr(uintptr_t[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintptrp.c b/qsort_uintptrp.c new file mode 100644 index 0000000..ff265e6 --- /dev/null +++ b/qsort_uintptrp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintptrp(uintptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_uintptrp_nul.c b/qsort_uintptrp_nul.c new file mode 100644 index 0000000..1110912 --- /dev/null +++ b/qsort_uintptrp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_uintptrp_nul(uintptr_t *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ullong.c b/qsort_ullong.c new file mode 100644 index 0000000..dd6d640 --- /dev/null +++ b/qsort_ullong.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ullong(unsigned long long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ullongp.c b/qsort_ullongp.c new file mode 100644 index 0000000..e3b77a2 --- /dev/null +++ b/qsort_ullongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ullongp(unsigned long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ullongp_nul.c b/qsort_ullongp_nul.c new file mode 100644 index 0000000..7cf4498 --- /dev/null +++ b/qsort_ullongp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ullongp_nul(unsigned long long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ulong.c b/qsort_ulong.c new file mode 100644 index 0000000..061027e --- /dev/null +++ b/qsort_ulong.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ulong(unsigned long int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ulongp.c b/qsort_ulongp.c new file mode 100644 index 0000000..365d122 --- /dev/null +++ b/qsort_ulongp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ulongp(unsigned long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ulongp_nul.c b/qsort_ulongp_nul.c new file mode 100644 index 0000000..7a80bed --- /dev/null +++ b/qsort_ulongp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ulongp_nul(unsigned long int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ushort.c b/qsort_ushort.c new file mode 100644 index 0000000..52adac6 --- /dev/null +++ b/qsort_ushort.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ushort(unsigned short int[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ushortp.c b/qsort_ushortp.c new file mode 100644 index 0000000..74c8d1f --- /dev/null +++ b/qsort_ushortp.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ushortp(unsigned short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/qsort_ushortp_nul.c b/qsort_ushortp_nul.c new file mode 100644 index 0000000..4638147 --- /dev/null +++ b/qsort_ushortp_nul.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline void libsimple_qsort_ushortp_nul(unsigned short int *[], size_t); + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif -- cgit v1.2.3-70-g09d2 From da28397b3d731ab2bdca752c9d3b9cd1ae00c5a5 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 29 Jun 2024 14:11:02 +0200 Subject: Fix C99 support MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libsimple.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libsimple.h b/libsimple.h index 1b22653..25e9a1a 100644 --- a/libsimple.h +++ b/libsimple.h @@ -152,8 +152,8 @@ #include "libsimple/valloc.h" #include "libsimple/pvallocz.h" #include "libsimple/pvalloc.h" -#include "libsimple/aligned_allocz.h" #include "libsimple/aligned_alloc.h" +#include "libsimple/aligned_allocz.h" #include "libsimple/posix_memalignz.h" #include "libsimple/posix_memalign.h" #include "libsimple/env.h" -- cgit v1.2.3-70-g09d2 From 3adb84e43ad41e200beea4d3f09c4632024748fd Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 29 Jun 2024 16:46:08 +0200 Subject: Add (libsimple_)_[v]e[n]printf MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 4 ++ libsimple/printf.h | 143 +++++++++++++++++++++++++++++++++++++++++++- man3/libsimple__enprintf.3 | 1 + man3/libsimple__eprintf.3 | 1 + man3/libsimple__venprintf.3 | 1 + man3/libsimple__veprintf.3 | 1 + man3/libsimple_vweprintf.3 | 85 ++++++++++++++++++++++++-- 7 files changed, 230 insertions(+), 6 deletions(-) create mode 120000 man3/libsimple__enprintf.3 create mode 120000 man3/libsimple__eprintf.3 create mode 120000 man3/libsimple__venprintf.3 create mode 120000 man3/libsimple__veprintf.3 diff --git a/Makefile b/Makefile index c1f2dbc..e1401b8 100644 --- a/Makefile +++ b/Makefile @@ -71,6 +71,10 @@ HDR =\ common.h OBJ =\ + _enprintf.o\ + _eprintf.o\ + _venprintf.o\ + _veprintf.o\ abs.o\ abspath.o\ aligned_allocn.o\ diff --git a/libsimple/printf.h b/libsimple/printf.h index d27a380..b6a0959 100644 --- a/libsimple/printf.h +++ b/libsimple/printf.h @@ -2,7 +2,8 @@ /** - * Exit value for `libsimple_eprintf` + * Exit value for `libsimple_eprintf` and + * `libsimple__eprintf` * * Default value is 1 */ @@ -239,6 +240,40 @@ libsimple_venprintf(int status__, const char *fmt__, va_list ap__) #endif +/** + * Version of `vprintf` for printing error message; + * it prints to standard error (rather than standard + * output) and, unless `fmt` starts with "usage: " + * and unless `argv0` (global `char *`), prefixes + * the output with `"%s: ", argv0`; additionally, if + * `fmt` ends with ':', the output is suffixed with + * `" %s\n", strerror(errno)`, if `fmt` ends with + * neither ':' nor '\n', the outpt is suffixed with + * `\n` + * + * This function will exit the process without + * calling clean-up functions registered with + * atexit(3) + * + * NB! This function uses `strerror` which is not + * thread-safe + * + * @param status Exit value for the process + * @param fmt The format string + * @param ap The format argument + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __format__(__printf__, 2, 0)))) +inline LIBSIMPLE_NORETURN void +libsimple__venprintf(int status__, const char *fmt__, va_list ap__) +{ + libsimple_vweprintf(fmt__, ap__); + _exit(status__); +} +#ifndef _venprintf +# define _venprintf libsimple__venprintf +#endif + + /** * Version of `vprintf` for printing error message; * it prints to standard error (rather than standard @@ -273,6 +308,42 @@ libsimple_enprintf(int status__, const char *fmt__, ...) #endif +/** + * Version of `vprintf` for printing error message; + * it prints to standard error (rather than standard + * output) and, unless `fmt` starts with "usage: " + * and unless `argv0` (global `char *`), prefixes + * the output with `"%s: ", argv0`; additionally, if + * `fmt` ends with ':', the output is suffixed with + * `" %s\n", strerror(errno)`, if `fmt` ends with + * neither ':' nor '\n', the outpt is suffixed with + * `\n` + * + * This function will exit the process without + * calling clean-up functions registered with + * atexit(3) + * + * NB! This function uses `strerror` which is not + * thread-safe + * + * @param status Exit value for the process + * @param fmt The format string + * @param ... The format argument + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(2), __format__(__printf__, 2, 3)))) +inline LIBSIMPLE_NORETURN void +libsimple__enprintf(int status__, const char *fmt__, ...) +{ + va_list ap__; + va_start(ap__, fmt__); + libsimple__venprintf(status__, fmt__, ap__); + va_end(ap__); +} +#ifndef _enprintf +# define _enprintf libsimple__enprintf +#endif + + /** * Version of `vprintf` for printing error message; * it prints to standard error (rather than standard @@ -305,6 +376,40 @@ libsimple_veprintf(const char *fmt__, va_list ap__) #endif +/** + * Version of `vprintf` for printing error message; + * it prints to standard error (rather than standard + * output) and, unless `fmt` starts with "usage: " + * and unless `argv0` (global `char *`), prefixes + * the output with `"%s: ", argv0`; additionally, if + * `fmt` ends with ':', the output is suffixed with + * `" %s\n", strerror(errno)`, if `fmt` ends with + * neither ':' nor '\n', the outpt is suffixed with + * `\n` + * + * This function will exit the process with the + * value `libsimple_default_failure_exit` without + * calling clean-up functions registered with + * atexit(3) + * + * NB! This function uses `strerror` which is not + * thread-safe + * + * @param fmt The format string + * @param ap The format argument + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1), __format__(__printf__, 1, 0)))) +inline LIBSIMPLE_NORETURN void +libsimple__veprintf(const char *fmt__, va_list ap__) +{ + libsimple_vweprintf(fmt__, ap__); + _exit(libsimple_default_failure_exit); +} +#ifndef _veprintf +# define _veprintf libsimple__veprintf +#endif + + /** * Version of `vprintf` for printing error message; * it prints to standard error (rather than standard @@ -337,3 +442,39 @@ libsimple_eprintf(const char *fmt__, ...) #ifndef eprintf # define eprintf libsimple_eprintf #endif + + +/** + * Version of `vprintf` for printing error message; + * it prints to standard error (rather than standard + * output) and, unless `fmt` starts with "usage: " + * and unless `argv0` (global `char *`), prefixes + * the output with `"%s: ", argv0`; additionally, if + * `fmt` ends with ':', the output is suffixed with + * `" %s\n", strerror(errno)`, if `fmt` ends with + * neither ':' nor '\n', the outpt is suffixed with + * `\n` + * + * This function will exit the process with the + * value `libsimple_default_failure_exit` without + * calling clean-up functions registered with + * atexit(3) + * + * NB! This function uses `strerror` which is not + * thread-safe + * + * @param fmt The format string + * @param ... The format argument + */ +LIBSIMPLE_GCC_ONLY__(__attribute__((__nonnull__(1), __format__(__printf__, 1, 2)))) +inline LIBSIMPLE_NORETURN void +libsimple__eprintf(const char *fmt__, ...) +{ + va_list ap__; + va_start(ap__, fmt__); + libsimple__veprintf(fmt__, ap__); + va_end(ap__); +} +#ifndef _eprintf +# define _eprintf libsimple__eprintf +#endif diff --git a/man3/libsimple__enprintf.3 b/man3/libsimple__enprintf.3 new file mode 120000 index 0000000..3d2d430 --- /dev/null +++ b/man3/libsimple__enprintf.3 @@ -0,0 +1 @@ +libsimple_enprintf.3 \ No newline at end of file diff --git a/man3/libsimple__eprintf.3 b/man3/libsimple__eprintf.3 new file mode 120000 index 0000000..07276cb --- /dev/null +++ b/man3/libsimple__eprintf.3 @@ -0,0 +1 @@ +libsimple_eprintf.3 \ No newline at end of file diff --git a/man3/libsimple__venprintf.3 b/man3/libsimple__venprintf.3 new file mode 120000 index 0000000..574bdd9 --- /dev/null +++ b/man3/libsimple__venprintf.3 @@ -0,0 +1 @@ +libsimple_venprintf.3 \ No newline at end of file diff --git a/man3/libsimple__veprintf.3 b/man3/libsimple__veprintf.3 new file mode 120000 index 0000000..3a87c2d --- /dev/null +++ b/man3/libsimple__veprintf.3 @@ -0,0 +1 @@ +libsimple_veprintf.3 \ No newline at end of file diff --git a/man3/libsimple_vweprintf.3 b/man3/libsimple_vweprintf.3 index b40799d..bd11957 100644 --- a/man3/libsimple_vweprintf.3 +++ b/man3/libsimple_vweprintf.3 @@ -16,6 +16,10 @@ inline void libsimple_venprintf(int \fIstatus\fP, const char *\fIfmt\fP, va_list 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, ...); +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 @@ -35,6 +39,18 @@ inline void libsimple_eprintf(const char *\fIfmt\fP, ...); #ifndef eprintf # define eprintf libsimple_eprintf #endif +#ifndef _venprintf +# define _venprintf libsimple__venprintf +#endif +#ifndef _enprintf +# define _enprintf libsimple__enprintf +#endif +#ifndef _veprintf +# define _veprintf libsimple__veprintf +#endif +#ifndef _eprintf +# define _eprintf libsimple__eprintf +#endif .fi .PP Link with @@ -102,6 +118,19 @@ the exit value of the process will be .IR status . .PP The +.BR libsimple__venprintf () +and +.BR libsimple__enprintf () +functions are versions of the +.BR libsimple_vweprintf () +and +.BR libsimple_weprintf () +functions that terminate the process by calling +.BR _exit (3), +the exit value of the process will be +.IR status . +.PP +The .BR libsimple_veprintf () and .BR libsimple_eprintf () @@ -116,13 +145,31 @@ the exit value of the process will be which is 1 by default. .PP The +.BR libsimple__veprintf () +and +.BR libsimple__eprintf () +functions are versions of the +.BR libsimple_vweprintf () +and +.BR libsimple_weprintf () +functions that terminate the process by calling +.BR _exit (3), +the exit value of the process will be +.IR libsimple_default_failure_exit (3), +which is 1 by default. +.PP +The .BR libsimple_vweprintf (), .BR libsimple_weprintf (), .BR libsimple_venprintf (), .BR libsimple_enprintf (), .BR libsimple_veprintf (), +.BR libsimple_eprintf (), +.BR libsimple__venprintf (), +.BR libsimple__enprintf (), +.BR libsimple__veprintf (), and -.BR libsimple_eprintf () +.BR libsimple__eprintf () functions call .I libsimple_eprintf_preprint unless it is @@ -146,8 +193,12 @@ may have a different value from when the .BR libsimple_venprintf (), .BR libsimple_enprintf (), .BR libsimple_veprintf (), +.BR libsimple_eprintf (), +.BR libsimple__venprintf (), +.BR libsimple__enprintf (), +.BR libsimple__veprintf (), or -.BR libsimple_eprintf () +.BR libsimple__eprintf () function called when .I libsimple_eprintf_preprint or @@ -179,7 +230,15 @@ T{ .br .BR libsimple_veprintf (), .br -.BR libsimple_eprintf () +.BR libsimple_eprintf (), +.br +.BR libsimple__venprintf (), +.br +.BR libsimple__enprintf (), +.br +.BR libsimple__veprintf (), +.br +.BR libsimple__eprintf () T} Thread safety MT-Unsafe race:strerror T{ .BR libsimple_vweprintf (), @@ -192,7 +251,15 @@ T{ .br .BR libsimple_veprintf (), .br -.BR libsimple_eprintf () +.BR libsimple_eprintf (), +.br +.BR libsimple__venprintf (), +.br +.BR libsimple__enprintf (), +.br +.BR libsimple__veprintf (), +.br +.BR libsimple__eprintf () T} Async-signal safety AS-Safe T{ .BR libsimple_vweprintf (), @@ -205,7 +272,15 @@ T{ .br .BR libsimple_veprintf (), .br -.BR libsimple_eprintf () +.BR libsimple_eprintf (), +.br +.BR libsimple__venprintf (), +.br +.BR libsimple__enprintf (), +.br +.BR libsimple__veprintf (), +.br +.BR libsimple__eprintf () T} Async-cancel safety AC-Safe .TE -- cgit v1.2.3-70-g09d2 From 2d325db65a6ea4603d048593df39537d204e932a Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Sat, 29 Jun 2024 17:11:06 +0200 Subject: Properly fix support for version of C before C11 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libsimple.h | 2 +- libsimple/aligned_allocz.h | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/libsimple.h b/libsimple.h index 25e9a1a..1b22653 100644 --- a/libsimple.h +++ b/libsimple.h @@ -152,8 +152,8 @@ #include "libsimple/valloc.h" #include "libsimple/pvallocz.h" #include "libsimple/pvalloc.h" -#include "libsimple/aligned_alloc.h" #include "libsimple/aligned_allocz.h" +#include "libsimple/aligned_alloc.h" #include "libsimple/posix_memalignz.h" #include "libsimple/posix_memalign.h" #include "libsimple/env.h" diff --git a/libsimple/aligned_allocz.h b/libsimple/aligned_allocz.h index b27a17b..eb8b34f 100644 --- a/libsimple/aligned_allocz.h +++ b/libsimple/aligned_allocz.h @@ -44,10 +44,21 @@ LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __alloc_align__(2), __alloc_size inline void * libsimple_aligned_allocz(int clear__, size_t alignment__, size_t n__) { +#if defined(aligned_alloc) || defined(_ISOC11_SOURCE) void *ret__ = aligned_alloc(alignment__, n__); if (ret__ && clear__) memset(ret__, 0, n__); return ret__; +#else + if (!alignment__ || alignment__ % sizeof(void *))) { + errno = EINVAL; + return NULL; + } + return libsimple_memalloc(n__, + LIBSIMPLE_MEMALLOC_CONDITIONAL_ZERO_INIT, clear__, + LIBSIMPLE_MEMALLOC_ALIGNMENT, alignment__, + LIBSIMPLE_MEMALLOC_END); +#endif } #ifndef aligned_allocz # define aligned_allocz libsimple_aligned_allocz -- cgit v1.2.3-70-g09d2 From e32e1c61ffc9763c4b512a38a6868a2509a7d68f Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 1 Jul 2024 19:12:45 +0200 Subject: m MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libsimple/aligned_allocz.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libsimple/aligned_allocz.h b/libsimple/aligned_allocz.h index eb8b34f..3137004 100644 --- a/libsimple/aligned_allocz.h +++ b/libsimple/aligned_allocz.h @@ -50,7 +50,7 @@ libsimple_aligned_allocz(int clear__, size_t alignment__, size_t n__) memset(ret__, 0, n__); return ret__; #else - if (!alignment__ || alignment__ % sizeof(void *))) { + if (!alignment__ || alignment__ % sizeof(void *)) { errno = EINVAL; return NULL; } -- cgit v1.2.3-70-g09d2 From 84b6dbef3adccc3eb588afb5d48d9c4fc0c2a3e7 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 1 Jul 2024 19:49:10 +0200 Subject: Fix libsimple_abspath MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- abspath.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/abspath.c b/abspath.c index 57cd644..7cc936b 100644 --- a/abspath.c +++ b/abspath.c @@ -18,7 +18,7 @@ libsimple_abspath(const char *path, const char *relto) while (path[0] == '.' && path[1] == '/') path = &path[2]; - if (relto) { + if (!relto) { relto_free = libsimple_getcwd(); if (!relto_free) return NULL; -- cgit v1.2.3-70-g09d2 From b550a5ba0261f3b6aba8988e37f1005102544568 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 1 Jul 2024 20:11:29 +0200 Subject: Add readlink and readmagiclink functions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 12 ++++++++++ efreadlink.c | 18 ++++++++++++++ enfreadlink.c | 18 ++++++++++++++ enreadlink.c | 18 ++++++++++++++ enreadlinkat.c | 29 +++++++++++++++++++++++ enreadmagiclink.c | 25 ++++++++++++++++++++ ereadlink.c | 18 ++++++++++++++ ereadlinkat.c | 18 ++++++++++++++ ereadmagiclink.c | 18 ++++++++++++++ freadlink.c | 18 ++++++++++++++ libsimple/path.h | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ readlink.c | 18 ++++++++++++++ readlinkat.c | 41 ++++++++++++++++++++++++++++++++ readmagiclink.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++ 14 files changed, 383 insertions(+) create mode 100644 efreadlink.c create mode 100644 enfreadlink.c create mode 100644 enreadlink.c create mode 100644 enreadlinkat.c create mode 100644 enreadmagiclink.c create mode 100644 ereadlink.c create mode 100644 ereadlinkat.c create mode 100644 ereadmagiclink.c create mode 100644 freadlink.c create mode 100644 readlink.c create mode 100644 readlinkat.c create mode 100644 readmagiclink.c diff --git a/Makefile b/Makefile index e1401b8..d44d559 100644 --- a/Makefile +++ b/Makefile @@ -411,6 +411,7 @@ OBJ =\ ealigned_wmemdup.o\ ecalloc.o\ ecallocn.o\ + efreadlink.o\ egetcwd.o\ egmtime.o\ elocaltime.o\ @@ -440,6 +441,7 @@ OBJ =\ enaligned_wmemdup.o\ encalloc.o\ encallocn.o\ + enfreadlink.o\ engetcwd.o\ engmtime.o\ enlocaltime.o\ @@ -463,6 +465,9 @@ OBJ =\ enpvallocn.o\ enpvallocz.o\ enpvalloczn.o\ + enreadlink.o\ + enreadlinkat.o\ + enreadmagiclink.o\ enrealloc.o\ enreallocarray.o\ enreallocn.o\ @@ -502,6 +507,9 @@ OBJ =\ epvallocn.o\ epvallocz.o\ epvalloczn.o\ + ereadlink.o\ + ereadlinkat.o\ + ereadmagiclink.o\ erealloc.o\ ereallocarray.o\ ereallocn.o\ @@ -540,6 +548,7 @@ OBJ =\ fexecl.o\ fexecle.o\ fexecv.o\ + freadlink.o\ generate_seed.o\ getcwd.o\ getenv_e.o\ @@ -943,6 +952,9 @@ OBJ =\ rawmemrchr_inv.o\ rawmemrelem.o\ rawmemrelem_inv.o\ + readlink.o\ + readlinkat.o\ + readmagiclink.o\ reallocarray.o\ reallocarrayf.o\ reallocf.o\ diff --git a/efreadlink.c b/efreadlink.c new file mode 100644 index 0000000..a76c411 --- /dev/null +++ b/efreadlink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_efreadlink(int); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/enfreadlink.c b/enfreadlink.c new file mode 100644 index 0000000..9f6a055 --- /dev/null +++ b/enfreadlink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_enfreadlink(int, int); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/enreadlink.c b/enreadlink.c new file mode 100644 index 0000000..669e1fd --- /dev/null +++ b/enreadlink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_enreadlink(int, const char *); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/enreadlinkat.c b/enreadlinkat.c new file mode 100644 index 0000000..74b4562 --- /dev/null +++ b/enreadlinkat.c @@ -0,0 +1,29 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_enreadlinkat(int status, int dirfd, const char *path) +{ + char *ret = libsimple_readlinkat(dirfd, path); + if (!ret) { + if (dirfd == AT_FDCWD) + libsimple_enprintf(status, "libsimple_readlinkat AT_FDCWD %s:", path); + else + libsimple_enprintf(status, "libsimple_readlinkat %i %s:", dirfd, path); + } + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/enreadmagiclink.c b/enreadmagiclink.c new file mode 100644 index 0000000..a4a99a4 --- /dev/null +++ b/enreadmagiclink.c @@ -0,0 +1,25 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_enreadmagiclink(int status, const char *path) +{ + char *ret = libsimple_readmagiclink(path); + if (!ret) + libsimple_enprintf(status, "libsimple_readmagiclinkat %s:", path); + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/ereadlink.c b/ereadlink.c new file mode 100644 index 0000000..3b990e4 --- /dev/null +++ b/ereadlink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_ereadlink(const char *); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/ereadlinkat.c b/ereadlinkat.c new file mode 100644 index 0000000..7294ade --- /dev/null +++ b/ereadlinkat.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_ereadlinkat(int, const char *); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/ereadmagiclink.c b/ereadmagiclink.c new file mode 100644 index 0000000..396e618 --- /dev/null +++ b/ereadmagiclink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_ereadmagiclink(const char *); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/freadlink.c b/freadlink.c new file mode 100644 index 0000000..90f5380 --- /dev/null +++ b/freadlink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_freadlink(int); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/libsimple/path.h b/libsimple/path.h index 65f2751..6f2a8b8 100644 --- a/libsimple/path.h +++ b/libsimple/path.h @@ -68,3 +68,74 @@ libsimple_eabspath(const char *p__, const char *r__) /* TODO man */ { return libsimple_enabspath(libsimple_default_failure_exit, p__, r__); } + + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__))) +char *libsimple_readlinkat(int, const char *); /* TODO man, doc */ + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +char *libsimple_enreadlinkat(int, int, const char *); /* TODO man, doc */ + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_ereadlinkat(int dirfd__, const char *path__) /* TODO man, doc */ +{ + return libsimple_enreadlinkat(libsimple_default_failure_exit, dirfd__, path__); +} + + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__))) +inline char * +libsimple_readlink(const char *path__) /* TODO man, doc */ +{ + return libsimple_readlinkat(AT_FDCWD, path__); +} + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_enreadlink(int status__, const char *path__) /* TODO man, doc */ +{ + return libsimple_enreadlinkat(status__, AT_FDCWD, path__); +} + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_ereadlink(const char *path__) /* TODO man, doc */ +{ + return libsimple_enreadlinkat(libsimple_default_failure_exit, AT_FDCWD, path__); +} + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__))) +inline char * +libsimple_freadlink(int fd__) /* TODO man, doc */ +{ + return libsimple_readlinkat(fd__, ""); +} + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_enfreadlink(int status__, int fd__) /* TODO man, doc */ +{ + return libsimple_enreadlinkat(status__, fd__, ""); +} + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_efreadlink(int fd__) /* TODO man, doc */ +{ + return libsimple_enreadlinkat(libsimple_default_failure_exit, fd__, ""); +} + + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__))) +char *libsimple_readmagiclink(const char *); /* TODO man, doc */ + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +char *libsimple_enreadmagiclink(int, const char *); /* TODO man, doc */ + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_ereadmagiclink(const char *path__) /* TODO man, doc */ +{ + return libsimple_enreadmagiclink(libsimple_default_failure_exit, path__); +} diff --git a/readlink.c b/readlink.c new file mode 100644 index 0000000..2bd9ffb --- /dev/null +++ b/readlink.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_readlink(const char *); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/readlinkat.c b/readlinkat.c new file mode 100644 index 0000000..2ec5e88 --- /dev/null +++ b/readlinkat.c @@ -0,0 +1,41 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_readlinkat(int dirfd, const char *path) +{ + char *ret = NULL, *new; + size_t size = 0; + ssize_t r; + + do { + new = realloc(ret, size += 128); + if (!new) { + errno = ENOMEM; + fail: + free(ret); + return NULL; + } + ret = new; + r = readlinkat(dirfd, path, ret, size - 1U); + if (r < 0) + goto fail; + } while ((size_t)r >= size - 2U); + + ret[r] = '\0'; + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/readmagiclink.c b/readmagiclink.c new file mode 100644 index 0000000..160dd96 --- /dev/null +++ b/readmagiclink.c @@ -0,0 +1,61 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_readmagiclink(const char *path) +{ + int fd; + struct stat st; + char *target1; + char *target2; + + fd = open(path, O_PATH | O_NOFOLLOW); + if (fd < 0) + return NULL; + + target1 = libsimple_efreadlink(fd); + if (!strends(target1, " (deleted)")) { + close(fd); + return target1; + } + + if (fstat(fd, &st)) { + free(target1); + close(fd); + return NULL; + } + + target2 = libsimple_efreadlink(fd); + if (!strends(target2, " (deleted)")) { + free(target1); + close(fd); + return target2; + } + + close(fd); + + if (strcmp(target1, target2)) { + free(target2); + return target1; + } else { + free(target1); + if (st.st_nlink) + return target2; + target2[strlen(target2) - (sizeof(" (deleted)") - 1U)] = '\0'; + return target2; + } +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif -- cgit v1.2.3-70-g09d2 From 8b367c7f2d77bb5e1d7586853669df644a2b1d52 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 1 Jul 2024 21:04:33 +0200 Subject: Add getexecpath functions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- Makefile | 3 ++ egetexecpath.c | 18 ++++++++ engetexecpath.c | 34 +++++++++++++++ getexecpath.c | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ libsimple/path.h | 14 +++++++ 5 files changed, 194 insertions(+) create mode 100644 egetexecpath.c create mode 100644 engetexecpath.c create mode 100644 getexecpath.c diff --git a/Makefile b/Makefile index d44d559..5a2ada3 100644 --- a/Makefile +++ b/Makefile @@ -413,6 +413,7 @@ OBJ =\ ecallocn.o\ efreadlink.o\ egetcwd.o\ + egetexecpath.o\ egmtime.o\ elocaltime.o\ emalloc.o\ @@ -443,6 +444,7 @@ OBJ =\ encallocn.o\ enfreadlink.o\ engetcwd.o\ + engetexecpath.o\ engmtime.o\ enlocaltime.o\ enmalloc.o\ @@ -553,6 +555,7 @@ OBJ =\ getcwd.o\ getenv_e.o\ getenv_ne.o\ + getexecpath.o\ gmtime.o\ habs.o\ hdiff.o\ diff --git a/egetexecpath.c b/egetexecpath.c new file mode 100644 index 0000000..17998de --- /dev/null +++ b/egetexecpath.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +extern inline char *libsimple_egetexecpath(void); + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/engetexecpath.c b/engetexecpath.c new file mode 100644 index 0000000..14994e8 --- /dev/null +++ b/engetexecpath.c @@ -0,0 +1,34 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + + +char * +libsimple_engetexecpath(int status) +{ + int saved_errno; + char *ret; + saved_errno = errno;; + errno = 0; + ret = libsimple_getexecpath(); + if (!ret) { + if (errno) + libsimple_enprintf(status, "libsimple_getexecpath:"); + else + libsimple_enprintf(status, "libsimple_getexecpath: unable to determine path\n"); + } + errno = saved_errno; + return ret; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/getexecpath.c b/getexecpath.c new file mode 100644 index 0000000..84bfea4 --- /dev/null +++ b/getexecpath.c @@ -0,0 +1,125 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.h" +#ifndef TEST + +#include + + +extern char *argv0; + + +static char * +getexecpath_by_execfn(void) +{ + unsigned long auxval; + char *execpath, *path, *target; + const char *name, *s, *fdlink; + size_t n; + + auxval = getauxval(AT_EXECFN); + if (!auxval) + return NULL; + + name = (void *)auxval; + if (strstarts(name, "/dev/fd/")) + s = &name[sizeof("/dev/fd/") - 1U]; + else if (strstarts(name, "/proc/self/fd/")) + s = &name[sizeof("/proc/self/fd/") - 1U]; + else + return libsimple_abspath(name, NULL); + + while (isdigit(*s)) + s++; + if (*s) { + n = (size_t)(s - name); + path = malloc(n + 1U); + if (!path) + return NULL; + memcpy(path, name, n); + path[n] = '\0'; + fdlink = path; + } else { + path = NULL; + fdlink = name; + } + target = libsimple_readmagiclink(fdlink); + free(path); + if (!target) + return NULL; + execpath = malloc(strlen(target) + strlen(s) + 1U); + if (!execpath) { + free(target); + return NULL; + } + stpcpy(stpcpy(execpath, target), s); + free(target); + + return execpath; +} + + +static char * +getexecpath_by_execfd(void) +{ + unsigned long auxval; + int fd; + char path[sizeof("/dev/fd/") + 3U * sizeof(int)]; + + errno = 0; + auxval = getauxval(AT_EXECFN); + if (!auxval && errno) + return NULL; + fd = (int)auxval; + + sprintf(path, "/dev/fd/%i", fd); + return libsimple_readmagiclink(path); +} + + +static char * +getexecpath_by_proc_exe(void) +{ + return libsimple_readmagiclink("/proc/self/exe"); +} + + +static char * +getexecpath_by_argv0(void) +{ + char *s = argv0; + + if (strchr(s, '/')) + return libsimple_abspath(s, NULL); + + return NULL; +} + + +char * +libsimple_getexecpath(void) +{ + char *r; + + if ((r = getexecpath_by_execfn())) + return r; + if ((r = getexecpath_by_execfd())) + return r; + if ((r = getexecpath_by_proc_exe())) + return r; + if ((r = getexecpath_by_argv0())) + return r; + + return NULL; +} + + +#else +#include "test.h" + +int +main(void) /* TODO test */ +{ + return 0; +} + +#endif diff --git a/libsimple/path.h b/libsimple/path.h index 6f2a8b8..cb78863 100644 --- a/libsimple/path.h +++ b/libsimple/path.h @@ -139,3 +139,17 @@ libsimple_ereadmagiclink(const char *path__) /* TODO man, doc */ { return libsimple_enreadmagiclink(libsimple_default_failure_exit, path__); } + + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__))) +char *libsimple_getexecpath(void); /* TODO man, doc */ + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +char *libsimple_engetexecpath(int); /* TODO man, doc */ + +LIBSIMPLE_GCC_ONLY__(__attribute__((__malloc__, __assume_aligned__(1), __warn_unused_result__, __nonnull__, __returns_nonnull__))) +inline char * +libsimple_egetexecpath(void) /* TODO man, doc */ +{ + return libsimple_engetexecpath(libsimple_default_failure_exit); +} -- cgit v1.2.3-70-g09d2 From 2a47a999bb86486700f47a22547bf66c39255ed9 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 1 Jul 2024 21:29:28 +0200 Subject: Add missing man pages MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- man3/_enprintf.3libsimple | 1 + man3/_eprintf.3libsimple | 1 + man3/_venprintf.3libsimple | 1 + man3/_veprintf.3libsimple | 1 + 4 files changed, 4 insertions(+) create mode 120000 man3/_enprintf.3libsimple create mode 120000 man3/_eprintf.3libsimple create mode 120000 man3/_venprintf.3libsimple create mode 120000 man3/_veprintf.3libsimple diff --git a/man3/_enprintf.3libsimple b/man3/_enprintf.3libsimple new file mode 120000 index 0000000..d06df60 --- /dev/null +++ b/man3/_enprintf.3libsimple @@ -0,0 +1 @@ +enprintf.3libsimple \ No newline at end of file diff --git a/man3/_eprintf.3libsimple b/man3/_eprintf.3libsimple new file mode 120000 index 0000000..7990141 --- /dev/null +++ b/man3/_eprintf.3libsimple @@ -0,0 +1 @@ +eprintf.3libsimple \ No newline at end of file diff --git a/man3/_venprintf.3libsimple b/man3/_venprintf.3libsimple new file mode 120000 index 0000000..e007970 --- /dev/null +++ b/man3/_venprintf.3libsimple @@ -0,0 +1 @@ +venprintf.3libsimple \ No newline at end of file diff --git a/man3/_veprintf.3libsimple b/man3/_veprintf.3libsimple new file mode 120000 index 0000000..5f64b97 --- /dev/null +++ b/man3/_veprintf.3libsimple @@ -0,0 +1 @@ +veprintf.3libsimple \ No newline at end of file -- cgit v1.2.3-70-g09d2 From 6a4bc5d6d1f13075de678ee6f2e8481dc03d868b Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Mon, 1 Jul 2024 21:42:26 +0200 Subject: Add missing .c files MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- _enprintf.c | 18 ++++++++++++++++++ _eprintf.c | 18 ++++++++++++++++++ _venprintf.c | 18 ++++++++++++++++++ _veprintf.c | 18 ++++++++++++++++++ 4 files changed, 72 insertions(+) create mode 100644 _enprintf.c create mode 100644 _eprintf.c create mode 100644 _venprintf.c create mode 100644 _veprintf.c diff --git a/_enprintf.c b/_enprintf.c new file mode 100644 index 0000000..a482af9 --- /dev/null +++ b/_enprintf.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.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/_eprintf.c b/_eprintf.c new file mode 100644 index 0000000..9d04565 --- /dev/null +++ b/_eprintf.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.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/_venprintf.c b/_venprintf.c new file mode 100644 index 0000000..ad51fbb --- /dev/null +++ b/_venprintf.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.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..ec950d8 --- /dev/null +++ b/_veprintf.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "common.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 -- cgit v1.2.3-70-g09d2