Doc fixes: remove _t from skalibs types

Signed-off-by: Laurent Bercot <ska@appnovation.com>

7 files changed, 94 insertions, 94 deletions

diff --git a/doc/libstddjb/alarm.html b/doc/libstddjb/alarm.html
index a6cc748..cf673f6 100644
--- a/doc/libstddjb/alarm.html
+++ b/doc/libstddjb/alarm.html
@@ -54,17 +54,17 @@ Returns 1 on success and 0 (and sets errno) on failure.
 </p>
 
 <p>
-<code> int alarm_timeout (tain_t const *tto) </code> <br />
+<code> int alarm_timeout (tain const *tto) </code> <br />
 Sets a fuse that will raise a SIGALRM after some amount
 of time has passed. The amount of time is described in
 *<em>tto</em>, which is a relative
-<a href="tai.html">tain_t</a>, i.e. a structure containing
+<a href="tai.html">tain</a>, i.e. a structure containing
 a relative TAIN64 time.
 Returns 1 on success and 0 (and sets errno) on failure.
 </p>
 
 <p>
-<code> int alarm_deadline (tain_t const *deadline) </code> <br />
+<code> int alarm_deadline (tain const *deadline) </code> <br />
 Sets a fuse that will raise a SIGALRM when the clock reaches
 *<em>deadline</em>, which is an absolute time expressed in
 <a href="tai.html">TAI64N</a> format.
diff --git a/doc/libstddjb/allreadwrite.html b/doc/libstddjb/allreadwrite.html
index 8003431..9ad14de 100644
--- a/doc/libstddjb/allreadwrite.html
+++ b/doc/libstddjb/allreadwrite.html
@@ -44,7 +44,7 @@ use higher-level APIs such as <a href="buffer.html">buffer</a> and
 <h2> Function types </h2>
 
 <p>
-<code> typedef ssize_t iofunc_t (int fd, char *buf, size_t len) </code> <br />
+<code> typedef ssize_t io_func (int fd, char *buf, size_t len) </code> <br />
 This is the simplified type of IO functions such as
 <a href="https://www.opengroup.org/onlinepubs/9699919799/functions/read.html">read()</a>
 and
@@ -52,7 +52,7 @@ and
 </p>
 
 <p>
-<code> typedef ssize_t iovfunc_t (int fd, struct iovec const *v, unsigned int vlen) </code> <br />
+<code> typedef ssize_t iov_func (int fd, struct iovec const *v, unsigned int vlen) </code> <br />
 This is the simplified type of IO functions such as
 <a href="https://www.opengroup.org/onlinepubs/9699919799/functions/readv.html">readv()</a>
 and
@@ -64,7 +64,7 @@ elements instead of a single string.
 
 
 <p>
-<code> typedef size_t alliofunc_t (int fd, char *buf, size_t len) </code> <br />
+<code> typedef size_t allio_func (int fd, char *buf, size_t len) </code> <br />
 This is the type of an IO operation that expects <em>all</em> of its
 <em>len</em> bytes to be sent or received, and that will loop around a
 lower-level IO function until either <em>len</em> bytes have been
@@ -100,7 +100,7 @@ Returns the inverse of <code>sanitize_read</code>.
 </p>
 
 <p>
-<code> size_t allreadwrite (iofunc_t *f, int fd, char *s, size_t len) </code> <br />
+<code> size_t allreadwrite (io_func *f, int fd, char *s, size_t len) </code> <br />
 *<em>f</em> must be a basic reading or writing function such as
 <tt>fd_read</tt> or <tt>fd_write</tt>. <tt>allreadwrite()</tt> performs
 *<em>f</em> on <em>fd</em>, <em>s</em> and <em>len</em> until <em>len</em>
@@ -112,7 +112,7 @@ set errno to EWOULDBLOCK or EAGAIN.
 </p>
 
 <p>
-<code> size_t allreadwritev (iovfunc_t *f, int fd, struct iovec const *v, unsigned int vlen) </code> <br />
+<code> size_t allreadwritev (iov_func *f, int fd, struct iovec const *v, unsigned int vlen) </code> <br />
 Like <code> allreadwrite </code>
 but the content to perform IO on is specified as a
 <a href="siovec.html">scatter/gather array</a> of <em>vlen</em>
@@ -171,7 +171,7 @@ an error occurs.
 
 <p>
 <code> size_t allwrite (int fd, char const *s, size_t len) </code> <br />
-Equivalent to <code> allreadwrite((iofunc_t *)&amp;fd_write, fd, s, len) </code>:
+Equivalent to <code> allreadwrite((io_func *)&amp;fd_write, fd, s, len) </code>:
 attempts to write <em>len</em> bytes from <em>s</em> to <em>fd</em>, looping
 around <tt>fd_write()</tt> if necessary, until either <em>len</em> bytes are
 written or an error occurs.
diff --git a/doc/libstddjb/djbtime.html b/doc/libstddjb/djbtime.html
index 8d47b5c..bc6b37a 100644
--- a/doc/libstddjb/djbtime.html
+++ b/doc/libstddjb/djbtime.html
@@ -29,7 +29,7 @@ and implemented in the <tt>libskarnet.a</tt> or <tt>libskarnet.so</tt> library.
 
 <p>
  <tt>djbtime</tt> is a set of functions to convert
-<a href="tai.html">tai_t and tain_t</a> structures, and
+<a href="tai.html">tai and tain</a> structures, and
 <a href="https://cr.yp.to/libtai/tai64.html">TAI time</a>, from and to
 other time formats and user-friendly representations.
 </p>
@@ -37,13 +37,13 @@ other time formats and user-friendly representations.
 <h2> Data structures </h2>
 
 <ul>
- <li> TAI time with 1-second precision is represented as a <a href="tai.html">tai_t</a>. </li>
- <li> TAI time with more precision is represented as a <a href="tai.html">tain_t</a>. </li>
+ <li> TAI time with 1-second precision is represented as a <a href="tai.html">tai</a>. </li>
+ <li> TAI time with more precision is represented as a <a href="tai.html">tain</a>. </li>
  <li> UTC time is represented as an unsigned 64-bit integer
 equal to 2^62 added to the number of seconds since the Epoch. It's a trivial extension of
 the standard 32-bit Unix time that will expire in 2038. </li>
  <li> Broken-down GMT or local time with more than a 1-second precision is stored in a
-<tt>localtmn_t</tt> structure, containing a <tt>struct tm</tt> <em>tm</em>
+<tt>localtmn</tt> structure, containing a <tt>struct tm</tt> <em>tm</em>
 field and an unsigned long <em>nano</em> field. </li>
 </ul>
 
@@ -52,7 +52,7 @@ field and an unsigned long <em>nano</em> field. </li>
 <h3> UTC </h3>
 
 <p>
-<code> int utc_from_tai (uint64_t *u, tai_t const *t) </code> <br />
+<code> int utc_from_tai (uint64_t *u, tai const *t) </code> <br />
 Converts the absolute TAI64 time in *<em>t</em> to an UTC time, stored in
 *<em>u</em> as an unsigned 64-bit integer. *<em>u</em> is actually 2^62
 plus the number of seconds since the Epoch.
@@ -62,7 +62,7 @@ returns 2 instead of 1.
 </p>
 
 <p>
-<code> int tai_from_utc (tai_t *t, uint64_t u) </code> <br />
+<code> int tai_from_utc (tai *t, uint64_t u) </code> <br />
 Converts the UTC time in <em>u</em>, stored
 as an unsigned 64-bit integer (2^62 plus the number of seconds since
 the Epoch), to a TAI64 time in *<em>t</em>.
@@ -73,7 +73,7 @@ error occurs.
 <h3> NTP </h3>
 
 <p>
-<code> int ntp_from_tain (uint64_t *ntp, tain_t const *a) </code> <br />
+<code> int ntp_from_tain (uint64_t *ntp, tain const *a) </code> <br />
 Converts the absolute TAI64N time in *<em>a</em> to a 64-bit NTP timestamp,
 stored in *<em>ntp</em>. The higher 32 bits of *<em>ntp</em> represent a number
 of seconds ; the lower 32 bits are the fractional part of the timestamp.
@@ -83,7 +83,7 @@ error occurs (for instance:
 </p>
 
 <p>
-<code> int tain_from_ntp (tain_t *a, uint64_t ntp) </code> <br />
+<code> int tain_from_ntp (tain *a, uint64_t ntp) </code> <br />
 Converts the NTP timestamp in <em>ntp</em> to a TAI64N time in
 *<em>a</em>.
 The function returns 1 if it succeeds, or 0 (and sets errno) if an
@@ -101,7 +101,7 @@ timezone takes leap seconds into account or not.
 </p>
 
 <p>
-<code> int localtm_from_tai (struct tm *tm, tai_t const *t, int lo) </code> <br />
+<code> int localtm_from_tai (struct tm *tm, tai const *t, int lo) </code> <br />
 Converts the TAI time in *<em>t</em> to broken-down GMT (if
 <em>lo</em> is zero) or local (if <em>lo</em> is nonzero) time in
 *<em>tm</em>.
@@ -141,7 +141,7 @@ error occurs.
 </p>
 
 <p>
-<code> int tai_from_localtm (tai_t *t, struct tm const *tm) </code> <br />
+<code> int tai_from_localtm (tai *t, struct tm const *tm) </code> <br />
 Converts the broken-down local time in *<em>tm</em> to a TAI value
 in *<em>t</em>.
 The function returns 1 if it succeeds, or 0 (and sets errno) if an
@@ -157,11 +157,11 @@ error occurs.
 </p>
 
 <p>
- The following functions use the <tt>localtmn_t</tt> type to hold both
+ The following functions use the <tt>localtmn</tt> type to hold both
 a broken-down time and a nanosecond count:
 </p>
 
-<pre>typedef struct localtmn_s localtmn_t, *localtmn_t_ref ;
+<pre>typedef struct localtmn_s localtmn, *localtmn_ref ;
 struct localtmn_s
 {
   struct tm tm ;
@@ -174,10 +174,10 @@ struct localtmn_s
 </p>
 
 <p>
-<code> int localtmn_from_tain (localtmn_t *tmn, tain_t const *a, int lo) ; <br />
-int tain_from_localtmn (tain_t *a, localtmn_t const *tmn) ; <br />
-int localtmn_from_sysclock (localtmn_t *tmn, tain_t const *a, int lo) ; <br />
-int sysclock_from_localtmn (tain_t *a, localtmn_t const *tmn) ; </code> <br />
+<code> int localtmn_from_tain (localtmn *tmn, tain const *a, int lo) ; <br />
+int tain_from_localtmn (tain *a, localtmn const *tmn) ; <br />
+int localtmn_from_sysclock (localtmn *tmn, tain const *a, int lo) ; <br />
+int sysclock_from_localtmn (tain *a, localtmn const *tmn) ; </code> <br />
 </p>
 
 </body>
diff --git a/doc/libstddjb/djbunix.html b/doc/libstddjb/djbunix.html
index 7c90c8a..8232209 100644
--- a/doc/libstddjb/djbunix.html
+++ b/doc/libstddjb/djbunix.html
@@ -723,9 +723,9 @@ Returns 0 if it succeeds and -1 (and sets errno) if it fails.
 <h3> Temporization </h3>
 
 <p>
-<code> void deepsleepuntil (tain_t const *deadline, tain_t *stamp) </code> <br />
+<code> void deepsleepuntil (tain const *deadline, tain *stamp) </code> <br />
 Sleeps until the absolute time represented by the
-<a href="tai.html">tain_t</a> *<em>deadline</em>. *<em>stamp</em>
+<a href="tai.html">tain</a> *<em>deadline</em>. *<em>stamp</em>
 must contain the current time. When the function returns, *<em>stamp</em>
 has been updated to reflect the new current time.
 </p>
diff --git a/doc/libstddjb/iopause.html b/doc/libstddjb/iopause.html
index 6b35416..2f887ed 100644
--- a/doc/libstddjb/iopause.html
+++ b/doc/libstddjb/iopause.html
@@ -77,7 +77,7 @@ argument, the <tt>iopause()</tt> function uses a <em>deadline</em> argument,
 i.e. an absolute time at which it must return 0 if no event has happened
 so far, as well as a <em>stamp</em> argument, i.e. an absolute time meaning
 <em>now</em>. Those arguments are stored in
-<a href="tai.html">tain_t</a>s. Here is why:
+<a href="tai.html">tain</a>s. Here is why:
 </p>
 
 <p>
@@ -153,7 +153,7 @@ that is why <tt>iopause</tt> relies on the <a href="tai.html">tai</a> library.
 <h2> Functions </h2>
 
 <p>
-<code> int iopause (iopause_fd *x, unsigned int len, tain_t const *deadline, tain_t const *stamp) </code> <br />
+<code> int iopause (iopause_fd *x, unsigned int len, tain const *deadline, tain const *stamp) </code> <br />
 Blocks until one of the events described in the <em>x</em> array, of length
 <em>len</em>, happens, or until the absolute date *<em>deadline</em> is
 reached. <em>deadline</em> may be null, in which case the function blocks
@@ -164,7 +164,7 @@ happened, 0 for a timeout, or -1 (and sets errno) for an error.
 </p>
 
 <p>
-<code> int iopause_stamp (iopause_fd *x, unsigned int len, tain_t const *deadline, tain_t *stamp) </code> <br />
+<code> int iopause_stamp (iopause_fd *x, unsigned int len, tain const *deadline, tain *stamp) </code> <br />
 Like <tt>iopause()</tt>, but if <em>stamp</em> is not null, it is updated
 right before the function returns. This helps the user always keep a
 reasonably accurate estimation of the current time in <em>stamp</em>;
diff --git a/doc/libstddjb/ip46.html b/doc/libstddjb/ip46.html
index d6ffcf4..2842d6f 100644
--- a/doc/libstddjb/ip46.html
+++ b/doc/libstddjb/ip46.html
@@ -114,7 +114,7 @@ Same as the previous function, with the SO_REUSEADDR option.
 </p>
 
 <p>
-<code> int socket_deadlineconnstamp46 (int fd, ip46_t const *a, uint16_t port, tain_t const *deadline, tain_t *stamp) </code> <br />
+<code> int socket_deadlineconnstamp46 (int fd, ip46_t const *a, uint16_t port, tain const *deadline, tain *stamp) </code> <br />
 Attempts to synchronously connect the socket <em>fd</em> to address a<em>a</em>
 and port <em>port</em>. Returns 1 if it succeeds and 0 (and sets errno)
 if it fails. <em>stamp</em> must contain an accurate enough
@@ -153,7 +153,7 @@ Returns 0 in case of success, and -1 (and sets errno) in case of failure.
 
 <p>
 <code> ssize_t socket_recvnb46 (int fd, char *s, size_t len, ip46_t *a, uint16_t *port,
-tain_t const *deadline, tain_t *stamp) </code> <br />
+tain const *deadline, tain *stamp) </code> <br />
 Like <tt>socket_recv46</tt>, except that the function blocks until a datagram
 is received. *<em>stamp</em> must be an accurate enough approximation of the
 current time, and is updated when the function returns. If no datagram has
@@ -162,7 +162,7 @@ arrived by absolute date *<em>deadline</em>, the function returns -1 ETIMEOUT.
 
 <p>
 <code> ssize_t socket_sendnb46 (int fd, char const *s, size_t len, ip46_t const *a, uint16_t port,
-tain_t const *deadline, tain_t *stamp) </code> <br />
+tain const *deadline, tain *stamp) </code> <br />
 Like <tt>socket_send46</tt>, except that the function blocks until a datagram
 has been effectively sent. *<em>stamp</em> must be an accurate enough approximation of the
 current time, and is updated when the function returns. If the message still has
diff --git a/doc/libstddjb/tai.html b/doc/libstddjb/tai.html
index 892cf45..dcdad11 100644
--- a/doc/libstddjb/tai.html
+++ b/doc/libstddjb/tai.html
@@ -91,8 +91,8 @@ borrow any code from it.
 <h2> Data structures </h2>
 
 <p>
- A <tt>tai_t</tt> structure holds an absolute date with a one-second
-precision. A <tt>tain_t</tt> structure holds an absolute date with a
+ A <tt>tai</tt> structure holds an absolute date with a one-second
+precision. A <tt>tain</tt> structure holds an absolute date with a
 maximum of one-nanosecond precision, as permitted by the underlying system
 call. If <a href="../flags.html#usert">flag-usert</a> is clear, the system
 clock will be read via
@@ -101,12 +101,12 @@ system call, which has a one-microsecond precision; if it is set, the
 system clock will be read via the 
 <a href="https://www.opengroup.org/onlinepubs/9699919799/functions/clock_gettime.html">clock_gettime()</a>
 system call, which has a one-nanosecond precision. In either case, a current
-<tt>tain_t</tt> will be unable to be more precise than the underlying
+<tt>tain</tt> will be unable to be more precise than the underlying
 implementation.
 </p>
 
 <p>
- A <tt>tai_t</tt>, as well as a <tt>tain_t</tt>, can also
+ A <tt>tai</tt>, as well as a <tt>tain</tt>, can also
 hold a (possibly negative) relative time, i.e. a difference of absolute
 dates. It is up to the programmer to make sure that a relative time is
 never interpreted as an absolute TAI64 date, and vice-versa.
@@ -117,7 +117,7 @@ never interpreted as an absolute TAI64 date, and vice-versa.
 <h3> Wallclock operations </h3>
 
 <p>
-<code> int tai_now (tai_t *t) </code> <br />
+<code> int tai_now (tai *t) </code> <br />
 Writes the current time as a TAI value to *<em>t</em>, with a
 1-second precision. The current time is based on the system clock.
 Make sure skalibs has been compiled with or without the
@@ -129,10 +129,10 @@ it fails.
 </p>
 
 <p>
-<code> int sysclock_get (tain_t *a) </code> <br />
+<code> int sysclock_get (tain *a) </code> <br />
 Reads the current value of the system clock (as in CLOCK_REALTIME) into *<em>a</em>.
 Returns 1 if it succeeds or 0 (and sets errno) if it fails.
-Note that despite being a <tt>tain_t</tt>, *<em>a</em>
+Note that despite being a <tt>tain</tt>, *<em>a</em>
 <strong>does not contain a TAI value</strong> - it only contains
 an internal, Y2038-safe representation of the value of the system
 clock, which should be either TAI-10 or UTC. You should not use
@@ -140,14 +140,14 @@ this function directly unless you know exactly what you are doing.
 </p>
 
 <p>
-<code> int sysclock_set (tain_t const *a) </code> <br />
+<code> int sysclock_set (tain const *a) </code> <br />
 Sets the system clock to *<em>a</em>, provided *<em>a</em> has
 the correct internal representation. You should not use this
 function directly unless you know exactly what you are doing.
 </p>
 
 <p>
-<code> int tain_wallclock_read (tain_t *a) </code> <br />
+<code> int tain_wallclock_read (tain *a) </code> <br />
 Reads the current time into *<em>a</em>, as a TAI64N value.
 Returns 1 if it succeeds or 0 (and sets errno) if it fails.
 Here <em>a</em> contains a valid TAI64N stamp, no matter what the
@@ -156,7 +156,7 @@ on it.
 </p>
 
 <p>
-<code> int tain_setnow (tain_t const *a) </code> <br />
+<code> int tain_setnow (tain const *a) </code> <br />
 Sets the current time to *<em>a</em>.
 Returns 1 if it succeeds or 0 (and sets errno) if it fails.
 <em>a</em> must contain a valid TAI64N stamp; proper
@@ -165,7 +165,7 @@ the right format for the system clock.
 </p>
 
 <p>
-<code> int tain_now_set_wallclock (tain_t *a) </code> <br />
+<code> int tain_now_set_wallclock (tain *a) </code> <br />
 Tells skalibs that future invocations of <tt>tain_now()</tt>
 (see below) should use a wall clock, i.e. the system time
 as returned by <tt>clock_gettime(CLOCK_REALTIME)</tt> or
@@ -186,7 +186,7 @@ Otherwise, they will fail with errno set to ENOSYS.
 </p>
 
 <p>
-<code> int tain_stopwatch_init (tain_t *a, clock_t cl, tain_t *offset) </code> <br />
+<code> int tain_stopwatch_init (tain *a, clock_t cl, tain *offset) </code> <br />
 Initializes a stopwatch in *<em>offset</em>, using a clock named <em>cl</em>.
 Typically, <em>cl</em> is something like CLOCK_MONOTONIC, when it is defined
 by the system. The actual value of
@@ -208,7 +208,7 @@ to zero.
 </p>
 
 <p>
-<code> int tain_stopwatch_read (tain_t *a, clock_t cl, tain_t const *offset) </code> <br />
+<code> int tain_stopwatch_read (tain *a, clock_t cl, tain const *offset) </code> <br />
  Gives the absolute time, as a TAI64N value, in *<em>a</em>. This
 absolute time is computed as a linear increase (as measured with
 the <em>cl</em> clock, which should be a monotonic clock such as
@@ -220,7 +220,7 @@ The function returns 1 if it succeeds or 0 (and sets errno) if it fails.
 </p>
 
 <p>
-<code> int tain_now_set_stopwatch (tain_t *a) </code> <br />
+<code> int tain_now_set_stopwatch (tain *a) </code> <br />
 Tells skalibs that future invocations of <tt>tain_now()</tt>
 (see below) should use a stopwatch, i.e. the system time
 as returned by <tt>clock_gettime(CLOCK_MONOTONIC)</tt> or similar,
@@ -240,7 +240,7 @@ is returned in *<em>a</em>.
 <h3> All-purpose time reading </h3>
 
 <p>
-<code> int tain_now (tain_t *a) </code> <br />
+<code> int tain_now (tain *a) </code> <br />
 Writes the current time, as a TAI value, to *<em>a</em>. This is the
 function you should use by default. It returns 1 if it succeeds or
 0 (and sets errno) if it fails.
@@ -279,8 +279,8 @@ use the STAMP global variable to store the current timestamp.)
 format to another; they do not make any assumption about the
 format of the time contained in those structures. For instance,
 for the <tt>tai_from_timeval</tt> function, if the struct timeval
-contains an absolute UTC time, then the tai_t will also contain
-the same UTC time. Despite being a tai_t, it may contain
+contains an absolute UTC time, then the tai will also contain
+the same UTC time. Despite being a tai, it may contain
 something else than TAI time.
 </p>
 
@@ -290,32 +290,32 @@ system clock format to TAI, see the next section.
 </p>
 
 <p>
-<code> int tai_from_time (tai_t *t, time_t u) <br />
-int tai_relative_from_time (tai_t *t, time_t u) </code> <br />
+<code> int tai_from_time (tai *t, time_t u) <br />
+int tai_relative_from_time (tai *t, time_t u) </code> <br />
 Those functions convert an absolute (resp. relative) time in a
 time_t to an absolute (resp. relative)
-time in a tai_t, with a 1-second precision. They return 1,
+time in a tai, with a 1-second precision. They return 1,
 unless the time_t value is invalid (in which case they return 0).
 </p>
 
 <p>
-<code> int time_from_tai (time_t *u, tai_t const *t) <br />
-int time_from_tai_relative (time_t *u, tai_t const *t) </code> <br />
+<code> int time_from_tai (time_t *u, tai const *t) <br />
+int time_from_tai_relative (time_t *u, tai const *t) </code> <br />
 The inverse functions of the previous ones. Be aware that
 time_t is 32 bits on some systems and cannot store all values
-of a tai_t (in which case the functions will return 0 EOVERFLOW).
+of a tai (in which case the functions will return 0 EOVERFLOW).
 </p>
 
 <p>
-<code> int tain_from_timeval (tain_t *a, struct timeval const *tv) <br />
-int tain_relative_from_timeval (tain_t *a, struct timeval const *tv) <br />
-int tain_from_timespec (tain_t *a, struct timespec const *ts) <br />
-int tain_relative_from_timespec (tain_t *a, struct timespec const *ts) <br />
-int timeval_from_tain (struct timeval *tv, tain_t const *a) <br />
-int timeval_from_tain_relative (struct timeval *tv, tain_t const *a) <br />
-int timespec_from_tain (struct timespec *ts, tain_t const *a) <br />
-int timespec_from_tain_relative (struct timespec *ts, tain_t const *a) </code> <br />
-Same conversion operations, between <tt>tain_t</tt> and a
+<code> int tain_from_timeval (tain *a, struct timeval const *tv) <br />
+int tain_relative_from_timeval (tain *a, struct timeval const *tv) <br />
+int tain_from_timespec (tain *a, struct timespec const *ts) <br />
+int tain_relative_from_timespec (tain *a, struct timespec const *ts) <br />
+int timeval_from_tain (struct timeval *tv, tain const *a) <br />
+int timeval_from_tain_relative (struct timeval *tv, tain const *a) <br />
+int timespec_from_tain (struct timespec *ts, tain const *a) <br />
+int timespec_from_tain_relative (struct timespec *ts, tain const *a) </code> <br />
+Same conversion operations, between <tt>tain</tt> and a
 <tt>struct timeval</tt> or <tt>struct timespec</tt>. The 1-microsecond
 (for <tt>struct timeval</tt>) or 1-nanosecond (for <tt>struct timespec</tt>)
 precision is preserved.
@@ -326,8 +326,8 @@ precision is preserved.
 <p>
  Unlike the previous functions, the functions listed here will
 always operate on valid absolute timestamps. Only TAI64 time is
-stored in tai_t structures, and only TAI64N time is stored in
-tain_t structures. These functions will convert to/from TAI,
+stored in tai structures, and only TAI64N time is stored in
+tain structures. These functions will convert to/from TAI,
 from/to the machine system clock format, i.e. TAI-10 or UTC
 depending on whether skalibs was
 compiled with the --enable-tai-clock configure option).
@@ -347,31 +347,31 @@ happen on systems with a 32 bit <tt>time_t</tt>), or other error
 codes.
 </p>
 
-<code> int tai_from_time_sysclock (tai_t *a, time_t t) <br />
-int time_sysclock_from_tai (time_t *t, tai_t const *a) <br />
-int tain_from_timeval_sysclock (tain_t *a, struct timeval const *tv) <br />
-int timeval_sysclock_from_tain (struct timeval *tv, tain_t const *a) <br />
-int tain_from_timespec_sysclock (tain_t *a, struct timespec const *ts) <br />
-int timespec_sysclock_from_tain (struct timespec *ts, tain_t const *a) </code>
+<code> int tai_from_time_sysclock (tai *a, time_t t) <br />
+int time_sysclock_from_tai (time_t *t, tai const *a) <br />
+int tain_from_timeval_sysclock (tain *a, struct timeval const *tv) <br />
+int timeval_sysclock_from_tain (struct timeval *tv, tain const *a) <br />
+int tain_from_timespec_sysclock (tain *a, struct timespec const *ts) <br />
+int timespec_sysclock_from_tain (struct timespec *ts, tain const *a) </code>
 
 <h3> Conversions to/from basic types </h3>
 
 <p>
-<code> int tain_uint (tain_t *a, unsigned int c) </code> <br />
+<code> int tain_uint (tain *a, unsigned int c) </code> <br />
 Stores a relative time of <em>c</em> seconds into <em>a</em>.
 Normally returns 1, but may return 0 EINVAL on pathological numbers.
 </p>
 
 <p>
-<code> int tain_from_millisecs (tain_t *a, int ms) </code> <br />
-This function makes a <tt>tain_t</tt> representing a relative
+<code> int tain_from_millisecs (tain *a, int ms) </code> <br />
+This function makes a <tt>tain</tt> representing a relative
 time of <em>ms</em> milliseconds. <em>ms</em> must be non-negative.
 The function returns 1, unless <em>ms</em> is negative, in which case
 it returns 0 EINVAL.
 </p>
 
 <p>
-<code> int tain_to_millisecs (tain_t const *a) </code> <br />
+<code> int taino_millisecs (tain const *a) </code> <br />
 If *<em>a</em> contains a non-negative relative time that fits into
 a 31-bit integer number of milliseconds, the function returns that
 number. Else it returns -1 EINVAL.
@@ -380,14 +380,14 @@ number. Else it returns -1 EINVAL.
 <h3> Time computations </h3>
 
 <p>
-<code> int tai_add (tai_t *t, tai_t const *t1, tai_t const *t2) </code> <br />
+<code> int tai_add (tai *t, tai const *t1, tai const *t2) </code> <br />
 Stores *<em>t1</em> + *<em>t2</em> into <em>t</em>. Of course, *<em>t1</em>
 and *<em>t2</em> must not both represent absolute times.
 The function normally returns 1, but will return 0 on bad inputs.
 </p>
 
 <p>
-<code> int tai_sub (tai_t *t, tai_t const *t1, tai_t const *t2) </code> <br />
+<code> int tai_sub (tai *t, tai const *t1, tai const *t2) </code> <br />
 Stores *<em>t1</em> - *<em>t2</em> into <em>t</em>. *<em>t1</em> cannot
 be relative if *<em>t2</em> is absolute. If they are both relative or
 both absolute, then *<em>t</em> is relative, else it's absolute.
@@ -395,27 +395,27 @@ The function normally returns 1, but will return 0 on bad inputs.
 </p>
 
 <p>
-<code> int tain_add (tain_t *a, tain_t const *a1, tain_t const *a2) <br />
-int tain_sub (tain_t *a, tain_t const *a1, tain_t const *a2) </code> <br />
-Same thing with <tt>tain_t</tt>.
+<code> int tain_add (tain *a, tain const *a1, tain const *a2) <br />
+int tain_sub (tain *a, tain const *a1, tain const *a2) </code> <br />
+Same thing with <tt>tain</tt>.
 </p>
 
 <p>
-<code> int tain_addsec (tain_t *a, tain_t const *a1, int c) </code> <br />
+<code> int tain_addsec (tain *a, tain const *a1, int c) </code> <br />
 Adds <em>c</em> seconds to *<em>a1</em> and stores the result into <em>a</em>.
 <em>c</em> may be negative.
 </p>
 
 <p>
-<code> void tain_half (tain_t *a, tain_t const *b) </code> <br />
+<code> void tain_half (tain *a, tain const *b) </code> <br />
 Stores *<em>b</em>/2 into <em>a</em>. *<em>b</em> must be relative.
 </p>
 
 <h3> Comparing dates or durations </h3>
 
 <p>
-<code> int tai_less (tai_t const *t1, tai_t const *t2) <br />
-int tain_less (tain_t const *t1, tain_t const *t2) </code> <br />
+<code> int tai_less (tai const *t1, tai const *t2) <br />
+int tain_less (tain const *t1, tain const *t2) </code> <br />
 Those functions return nonzero iff *<em>t1</em> is lesser than *<em>t2</em>.
 *<em>t1</em> and *<em>t2</em> must be both relative, or both absolute.
 </p>
@@ -423,7 +423,7 @@ Those functions return nonzero iff *<em>t1</em> is lesser than *<em>t2</em>.
 <h3> Packing and unpacking </h3>
 
 <p>
-<code> void tai_pack (char *s, tai_t const *t) </code> <br />
+<code> void tai_pack (char *s, tai const *t) </code> <br />
 Marshals *<em>t</em> into the buffer <em>s</em> points to, which
 must be preallocated with at least TAI_PACK (8) characters. Afterwards,
 the buffer contains the
@@ -432,7 +432,7 @@ representation of *<em>t</em>.
 </p>
 
 <p>
-<code> void tai_unpack (char const *s, tai_t *t) </code> <br />
+<code> void tai_unpack (char const *s, tai *t) </code> <br />
 Unmarshals the
 <a href="https://cr.yp.to/libtai/tai64.html#tai64">external TAI64 format</a>
 label pointed to by <em>s</em> (at least TAI_PACK characters) and stores
@@ -440,8 +440,8 @@ the result into <em>t</em>.
 </p>
 
 <p>
-<code> void tain_pack (char *s, tain_t const *a) <br />
-void tain_unpack (char const *s, tain_t *a) </code> <br />
+<code> void tain_pack (char *s, tain const *a) <br />
+void tain_unpack (char const *s, tain *a) </code> <br />
 Same thing with
 <a href="https://cr.yp.to/libtai/tai64.html#tai64n">external TAI64N format</a>,
 using TAIN_PACK (12) characters.
@@ -450,7 +450,7 @@ using TAIN_PACK (12) characters.
 <h3> Formatting and scanning </h3>
 
 <p>
-<code> unsigned int tain_fmt (char *s, tain_t const *a) </code> <br />
+<code> unsigned int tain_fmt (char *s, tain const *a) </code> <br />
 Writes into <em>s</em> an ASCII representation of *<em>a</em> in external
 TAI64N format. <em>s</em> must point to a preallocated buffer of at least
 TAIN_PACK*2 (24) characters. The function returns the number of bytes that
@@ -458,7 +458,7 @@ have been written to <em>s</em> (24).
 </p>
 
 <p>
-<code> unsigned int tain_scan (char const *s, tain_t *a) </code> <br />
+<code> unsigned int tain_scan (char const *s, tain *a) </code> <br />
 Reads 24 characters from <em>s</em>; if those characters are a valid ASCII
 representation of the external TAI64N format of some time value, this value
 is stored into <em>a</em>, and 24 is returned. Else 0 is returned.
@@ -473,13 +473,13 @@ format of an absolute date.
 </p>
 
 <p>
-<code> unsigned int timestamp_fmt (char *s, tain_t const *a) </code> <br />
+<code> unsigned int timestamp_fmt (char *s, tain const *a) </code> <br />
 Writes a TAI64N timestamp representing the absolute date *<em>a</em>
 into the 25 characters pointed to by <em>s</em>. Returns 25.
 </p>
 
 <p>
-<code> unsigned int timestamp_scan (char const *s, tain_t *a) </code> <br />
+<code> unsigned int timestamp_scan (char const *s, tain *a) </code> <br />
 Reads 25 characters at <em>s</em>. If those characters are a valid TAI64N
 timestamp, stores the absolute date in <em>a</em> and returns 25. Else,
 returns 0.