diff options
| -rw-r--r-- | libsimple/calloc.h | 155 | ||||
| -rw-r--r-- | libsimple/env.h | 16 | ||||
| -rw-r--r-- | libsimple/malloc.h | 155 | ||||
| -rw-r--r-- | man/libsimple_minimise_number_string.3 | 64 | ||||
| -rw-r--r-- | man/libsimple_strtotimespec.3 | 133 | ||||
| -rw-r--r-- | man/libsimple_timespectostr.3 | 2 | ||||
| l--------- | man/minimise_number_string.3libsimple | 1 | ||||
| l--------- | man/strtotimespec.3libsimple | 1 | ||||
| l--------- | man/strtotimeval.3libsimple | 1 |
9 files changed, 517 insertions, 11 deletions
diff --git a/libsimple/calloc.h b/libsimple/calloc.h index ab73ff3..2820d02 100644 --- a/libsimple/calloc.h +++ b/libsimple/calloc.h @@ -1,5 +1,23 @@ /* See LICENSE file for copyright and license details. */ + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * @param n First factor for the allocation size, must not be 0 + * @param ap The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + * @throws EINVAL `n` is 0 + * @throws ENOMEM Could not allocated enough memory + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__))) static inline void *libsimple_vcallocn(size_t __n, va_list __ap) { return libsimple_vmalloczn(1, __n, __ap); } @@ -7,6 +25,24 @@ static inline void *libsimple_vcallocn(size_t __n, va_list __ap) # define vcallocn libsimple_vcallocn #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * @param n First factor for the allocation size, must not be 0 + * @param ... The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + * @throws EINVAL `n` is 0 + * @throws ENOMEM Could not allocated enough memory + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__))) static inline void * libsimple_callocn(size_t __n, ... /*, (size_t)0 */) @@ -20,12 +56,51 @@ libsimple_callocn(size_t __n, ... /*, (size_t)0 */) # define callocn libsimple_callocn #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * On failure, the `libsimple_enprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_enprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n The number of elements to allocate, the behaviour of + * this function is unspecified for the value 0 + * @param m The size of each element, the behaviour of + * this function is unspecified for the value 0 + * @return A unique pointer with at least the size `n * m` + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2, 3), __warn_unused_result__, __returns_nonnull__))) void *libsimple_encalloc(int, size_t, size_t); #ifndef encalloc # define encalloc libsimple_encalloc #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_enprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_enprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ap The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void *libsimple_envcallocn(int __st, size_t __n, va_list __ap) { return libsimple_envmalloczn(__st, 1, __n, __ap); } @@ -33,6 +108,27 @@ static inline void *libsimple_envcallocn(int __st, size_t __n, va_list __ap) # define envcallocn libsimple_envcallocn #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_enprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_enprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ... The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void * libsimple_encallocn(int __status, size_t __n, ... /*, (size_t)0 */) @@ -46,6 +142,23 @@ libsimple_encallocn(int __status, size_t __n, ... /*, (size_t)0 */) # define encallocn libsimple_encallocn #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * On failure, the `libsimple_eprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_eprintf` for more information + * + * @param n The number of elements to allocate, the behaviour of + * this function is unspecified for the value 0 + * @param m The size of each element, the behaviour of + * this function is unspecified for the value 0 + * @return A unique pointer with at least the size `n * m` + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(1, 2), __warn_unused_result__, __returns_nonnull__))) static inline void *libsimple_ecalloc(size_t __n, size_t __m) { return encalloc(libsimple_default_failure_exit, __n, __m); } @@ -53,6 +166,27 @@ static inline void *libsimple_ecalloc(size_t __n, size_t __m) # define ecalloc libsimple_ecalloc #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_eprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_eprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ap The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void *libsimple_evcallocn(size_t __n, va_list __ap) { return libsimple_envcallocn(libsimple_default_failure_exit, __n, __ap); } @@ -60,6 +194,27 @@ static inline void *libsimple_evcallocn(size_t __n, va_list __ap) # define evcallocn libsimple_evcallocn #endif + +/** + * Dynamically allocates heap allocated, initialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_eprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_eprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ... The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void * libsimple_ecallocn(size_t __n, ... /*, (size_t)0 */) diff --git a/libsimple/env.h b/libsimple/env.h index e97c65f..dc58276 100644 --- a/libsimple/env.h +++ b/libsimple/env.h @@ -93,9 +93,9 @@ libsimple_putenvf(const char *__fmt, ...) * only the name, but this can couse problems in some programs * and should not done; the name however must not be empty * - * On failure, the libsimple_enprintf function is called, + * On failure, the `libsimple_enprintf` function is called, * cause the program to print an error message and exit, - * see libsimple_enprintf for more information + * see `libsimple_enprintf` for more information * * @param status The exit value for the process in case of failure * @param fmt Format string, see vsprintf(3) @@ -117,9 +117,9 @@ void libsimple_envputenvf(int, const char *, va_list); * only the name, but this can couse problems in some programs * and should not done; the name however must not be empty * - * On failure, the libsimple_enprintf function is called, + * On failure, the `libsimple_enprintf` function is called, * cause the program to print an error message and exit, - * see libsimple_enprintf for more information + * see `libsimple_enprintf` for more information * * @param status The exit value for the process in case of failure * @param fmt Format string, see vsprintf(3) @@ -148,9 +148,9 @@ libsimple_enputenvf(int __status, const char *__fmt, ...) * only the name, but this can couse problems in some programs * and should not done; the name however must not be empty * - * On failure, the libsimple_eprintf function is called, + * On failure, the `libsimple_eprintf` function is called, * cause the program to print an error message and exit, - * see libsimple_eprintf for more information + * see `libsimple_eprintf` for more information * * @param fmt Format string, see vsprintf(3) * @param ap Format arguments, see vsprintf(3) @@ -172,9 +172,9 @@ static inline void libsimple_evputenvf(const char *__fmt, va_list __ap) * only the name, but this can couse problems in some programs * and should not done; the name however must not be empty * - * On failure, the libsimple_eprintf function is called, + * On failure, the `libsimple_eprintf` function is called, * cause the program to print an error message and exit, - * see libsimple_eprintf for more information + * see `libsimple_eprintf` for more information * * @param fmt Format string, see vsprintf(3) * @param ap Format arguments, see vsprintf(3) diff --git a/libsimple/malloc.h b/libsimple/malloc.h index feb1944..883a216 100644 --- a/libsimple/malloc.h +++ b/libsimple/malloc.h @@ -1,5 +1,23 @@ /* See LICENSE file for copyright and license details. */ + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * @param n First factor for the allocation size, must not be 0 + * @param ap The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + * @throws EINVAL `n` is 0 + * @throws ENOMEM Could not allocated enough memory + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__))) static inline void *libsimple_vmallocn(size_t __n, va_list __ap) { return libsimple_vmalloczn(0, __n, __ap); } @@ -7,6 +25,24 @@ static inline void *libsimple_vmallocn(size_t __n, va_list __ap) # define vmallocn libsimple_vmallocn #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * @param n First factor for the allocation size, must not be 0 + * @param ... The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + * @throws EINVAL `n` is 0 + * @throws ENOMEM Could not allocated enough memory + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__))) static inline void * libsimple_mallocn(size_t __n, ... /*, (size_t)0 */) @@ -20,19 +56,77 @@ libsimple_mallocn(size_t __n, ... /*, (size_t)0 */) # define mallocn libsimple_mallocn #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * On failure, the `libsimple_enprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_enprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n The number of bytes to allocate, the behaviour of + * this function is unspecified for the value 0 + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(2), __warn_unused_result__, __returns_nonnull__))) void *libsimple_enmalloc(int, size_t); #ifndef enmalloc # define enmalloc libsimple_enmalloc #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_enprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_enprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ap The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) -static inline void *libsimple_envmallocn(int __st, size_t __n, va_list __ap) -{ return libsimple_envmalloczn(__st, 0, __n, __ap); } +static inline void *libsimple_envmallocn(int __status, size_t __n, va_list __ap) +{ return libsimple_envmalloczn(__status, 0, __n, __ap); } #ifndef envmallocn # define envmallocn libsimple_envmallocn #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_enprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_enprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ... The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void * libsimple_enmallocn(int __status, size_t __n, ... /*, (size_t)0 */) @@ -46,6 +140,21 @@ libsimple_enmallocn(int __status, size_t __n, ... /*, (size_t)0 */) # define enmallocn libsimple_enmallocn #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * On failure, the `libsimple_eprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_eprintf` for more information + * + * @param n The number of bytes to allocate, the behaviour of + * this function is unspecified for the value 0 + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __alloc_size__(1), __warn_unused_result__, __returns_nonnull__))) static inline void *libsimple_emalloc(size_t __n) { return libsimple_enmalloc(libsimple_default_failure_exit, __n); } @@ -53,6 +162,27 @@ static inline void *libsimple_emalloc(size_t __n) # define emalloc libsimple_emalloc #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_eprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_eprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ap The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void *libsimple_evmallocn(size_t __n, va_list __ap) { return libsimple_envmallocn(libsimple_default_failure_exit, __n, __ap); } @@ -60,6 +190,27 @@ static inline void *libsimple_evmallocn(size_t __n, va_list __ap) # define evmallocn libsimple_evmallocn #endif + +/** + * Dynamically allocates heap allocated, uninitialised, + * memory with default alignment (`alignof(max_align_t)`) + * + * The product of all arguments, up to the first 0, + * will be used as the number of bytes to allocated + * + * On failure, the `libsimple_eprintf` function is called, + * cause the program to print an error message and exit, + * see `libsimple_eprintf` for more information + * + * @param status The exit value for the process in case of failure + * @param n First factor for the allocation size, must not be 0 + * @param ... The rest of the factors for the allocation size, + * all arguments should have the type `size_t`, and + * list must end with 0 (which is not factor) + * @return A unique pointer with at least the specified size + * and with the alignment `alignof(max_align_t)`; + * `NULL` on failure + */ _LIBSIMPLE_GCC_ONLY(__attribute__((__malloc__, __warn_unused_result__, __returns_nonnull__))) static inline void * libsimple_emallocn(size_t __n, ... /*, (size_t)0 */) diff --git a/man/libsimple_minimise_number_string.3 b/man/libsimple_minimise_number_string.3 new file mode 100644 index 0000000..310b725 --- /dev/null +++ b/man/libsimple_minimise_number_string.3 @@ -0,0 +1,64 @@ +.TH LIBSIMPLE_MINIMISE_NUMBER_STRING 3 2018-10-31 libsimple +.SH NAME +libsimple_minimise_number_string \- ninimise a numerical string +.SH SYNOPSIS +.nf +#include <libsimple.h> + +char *libsimple_minimise_number_string(char *\fIs\fP); + +#ifndef minimise_number_string +# define minimise_number_string libsimple_minimise_number_string +#endif +.fi +.PP +Link with +.IR \-lsimple . +.SH DESCRIPTION +The +.BR libsimple_minimise_number_string () +function minimises a string representing a real value with +the assumption that the string is on the format +.B [+-]\e?[0-9]*\e(\e.[0-9]*\e)\e? +(repeating decimals are not supported). +.SH RETURN VALUE +The +.BR libsimple_minimise_number_string () +function returns the pointer +.IR s . +.SH ERRORS +The +.BR libsimple_minimise_number_string () +function cannot fail. +.SH ATTRIBUTES +For an explanation of the terms used in this section, see +.BR attributes (7). +.TS +allbox; +lb lb lb +l l l. +Interface Attribute Value +T{ +.BR libsimple_minimise_number_string () +T} Thread safety MT-Safe +T{ +.BR libsimple_minimise_number_string () +T} Async-signal safety AS-Safe +T{ +.BR libsimple_minimise_number_string () +T} Async-cancel safety AC-Safe +.TE +.SH EXAMPLES +None. +.SH APPLICATION USAGE +None. +.SH RATIONALE +None. +.SH FUTURE DIRECTIONS +None. +.SH NOTES +None. +.SH BUGS +None. +.SH SEE ALSO +.BR libsimple_timespectostr (3) diff --git a/man/libsimple_strtotimespec.3 b/man/libsimple_strtotimespec.3 new file mode 100644 index 0000000..85ff88b --- /dev/null +++ b/man/libsimple_strtotimespec.3 @@ -0,0 +1,133 @@ +.TH LIBSIMPLE_STRTOTIMESPEC 3 2018-10-31 libsimple +.SH NAME +libsimple_strtotimespec, libsimple_strtotimeval \- convert a string to a duration data structure +.SH SYNOPSIS +.nf +#include <libsimple.h> + +int libsimple_strtotimespec(struct timespec *restrict \fIts\fP, const char *\fIs\fP, char **\fIend\fP); +int libsimple_strtotimeval(struct timeval *restrict \fItv\fP, const char *\fIs\fP, char **\fIend\fP); + +#ifndef strtotimespec +# define strtotimespec libsimple_strtotimespec +#endif +#ifndef strtotimeval +# define strtotimeval libsimple_strtotimeval +#endif +.fi +.PP +Link with +.IR \-lsimple . +.SH DESCRIPTION +The +.BR libsimple_strtotimespec () +and +.BR libsimple_strtotimeval () +functions will parse the string +.IR s , +representing a real value of number of seconds, +and store the value in +.I ts +and +.R tv +respectively, rounding to the nearest nanosecond +(for the +.BR libsimple_strtotimespec ()) +or microsecond +(for the +.BR libsimple_strtotimeval ()). +These functions will ignore any leading whitespace +and byte where the parsing stopped, as +.I s +with an offset, to +.IR end . +The parsed part of +.I s +must contain atleast one digit and be on the +format +.BR [+-]\e?[0-9]*\e(\e.[0-9]*\e(\e.[0-9]*\e|([0-9]*)\e)\e?\e)\e? . +where the digits in +.BR \e2 , +if any, are repeating decimals and must contain atleast +one digit if it is included. +.SH RETURN VALUE +The +.BR libsimple_strtotimespec () +and +.BR libsimple_strtotimeval () +functions return 0 upon successful completion; +otherwise \-1 is returned. +.SH ERRORS +The +.BR libsimple_strtotimespec () +and +.BR libsimple_strtotimeval () +functions fail if: +.TP +.B EINVAL +.I s +does not represent a real value in a recognised format. +.I *end +will not be set. +.TP +.B ERANGE +The result is too large or too small to be store. Either +.I *ts +will be set to +.I {.tv_sec=TIME_MAX,.tv_nsec=999999999L} +and +.I *tv +set to +.I {.tv_sec=TIME_MAX,.tv_usec=999999L} +(if the result is too large) or to +.I {.tv_sec=TIME_MIN,.tv_nsec=0L} +and +.I {.tv_sec=TIME_MIN,.tv_usec=0L} +(if the result is too small). +.I *end +will be set. +.SH ATTRIBUTES +For an explanation of the terms used in this section, see +.BR attributes (7). +.TS +allbox; +lb lb lb +l l l. +Interface Attribute Value +T{ +.BR libsimple_strtotimespec () +.br +.BR libsimple_strtotimeval () +T} Thread safety MT-Safe +T{ +.BR libsimple_strtotimespec () +.br +.BR libsimple_strtotimeval () +T} Async-signal safety AS-Safe +T{ +.BR libsimple_strtotimespec () +.br +.BR libsimple_strtotimeval () +T} Async-cancel safety AC-Safe +.TE +.SH EXAMPLES +None. +.SH APPLICATION USAGE +None. +.SH RATIONALE +None. +.SH FUTURE DIRECTIONS +None. +.SH NOTES +None. +.SH BUGS +None. +.SH SEE ALSO +.BR libsimple_sumtimespec (3), +.BR libsimple_difftimespec (3), +.BR libsimple_multimespec (3), +.BR libsimple_cmptimespec (3), +.BR libsimple_timespectostr (3), +.BR libsimple_timespectodouble (3), +.BR libsimple_doubletotimespec (3), +.BR libsimple_timeval2timespec (3) diff --git a/man/libsimple_timespectostr.3 b/man/libsimple_timespectostr.3 index 1585603..d6e2b71 100644 --- a/man/libsimple_timespectostr.3 +++ b/man/libsimple_timespectostr.3 @@ -96,7 +96,7 @@ failed because it could not allocate enough memory. .I ts->tv_nsec is negative or greater than 999\ 999\ 999, or .I tv->tv_usec -is negative or greater than 999\ 999, or +is negative or greater than 999\ 999. .SH ATTRIBUTES For an explanation of the terms used in this section, see .BR attributes (7). diff --git a/man/minimise_number_string.3libsimple b/man/minimise_number_string.3libsimple new file mode 120000 index 0000000..7d0d47c --- /dev/null +++ b/man/minimise_number_string.3libsimple @@ -0,0 +1 @@ +libsimple_minimise_number_string.3
\ No newline at end of file diff --git a/man/strtotimespec.3libsimple b/man/strtotimespec.3libsimple new file mode 120000 index 0000000..9bc7f8b --- /dev/null +++ b/man/strtotimespec.3libsimple @@ -0,0 +1 @@ +libsimple_strtotimespec.3
\ No newline at end of file diff --git a/man/strtotimeval.3libsimple b/man/strtotimeval.3libsimple new file mode 120000 index 0000000..21cc596 --- /dev/null +++ b/man/strtotimeval.3libsimple @@ -0,0 +1 @@ +libsimple_strtotimeval.3
\ No newline at end of file |