More documentation

Signed-off-by: Mattias Andrée <maandree@kth.se>

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