From 351aae58f2c73749a12e2b19cbb447614a2ee3ff Mon Sep 17 00:00:00 2001 From: Laurent Bercot Date: Tue, 27 Sep 2022 08:49:04 +0000 Subject: Doc fixes: remove _t from skalibs types Signed-off-by: Laurent Bercot --- doc/libstddjb/alarm.html | 6 +- doc/libstddjb/allreadwrite.html | 12 ++-- doc/libstddjb/djbtime.html | 32 +++++------ doc/libstddjb/djbunix.html | 4 +- doc/libstddjb/iopause.html | 6 +- doc/libstddjb/ip46.html | 6 +- doc/libstddjb/tai.html | 122 ++++++++++++++++++++-------------------- 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.

- int alarm_timeout (tain_t const *tto)
+ int alarm_timeout (tain const *tto)
Sets a fuse that will raise a SIGALRM after some amount of time has passed. The amount of time is described in *tto, which is a relative -tain_t, i.e. a structure containing +tain, i.e. a structure containing a relative TAIN64 time. Returns 1 on success and 0 (and sets errno) on failure.

- int alarm_deadline (tain_t const *deadline)
+ int alarm_deadline (tain const *deadline)
Sets a fuse that will raise a SIGALRM when the clock reaches *deadline, which is an absolute time expressed in TAI64N 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 buffer and

Function types

- typedef ssize_t iofunc_t (int fd, char *buf, size_t len)
+ typedef ssize_t io_func (int fd, char *buf, size_t len)
This is the simplified type of IO functions such as read() and @@ -52,7 +52,7 @@ and

- typedef ssize_t iovfunc_t (int fd, struct iovec const *v, unsigned int vlen)
+ typedef ssize_t iov_func (int fd, struct iovec const *v, unsigned int vlen)
This is the simplified type of IO functions such as readv() and @@ -64,7 +64,7 @@ elements instead of a single string.

- typedef size_t alliofunc_t (int fd, char *buf, size_t len)
+ typedef size_t allio_func (int fd, char *buf, size_t len)
This is the type of an IO operation that expects all of its len bytes to be sent or received, and that will loop around a lower-level IO function until either len bytes have been @@ -100,7 +100,7 @@ Returns the inverse of sanitize_read.

- size_t allreadwrite (iofunc_t *f, int fd, char *s, size_t len)
+ size_t allreadwrite (io_func *f, int fd, char *s, size_t len)
*f must be a basic reading or writing function such as fd_read or fd_write. allreadwrite() performs *f on fd, s and len until len @@ -112,7 +112,7 @@ set errno to EWOULDBLOCK or EAGAIN.

- size_t allreadwritev (iovfunc_t *f, int fd, struct iovec const *v, unsigned int vlen)
+ size_t allreadwritev (iov_func *f, int fd, struct iovec const *v, unsigned int vlen)
Like allreadwrite but the content to perform IO on is specified as a scatter/gather array of vlen @@ -171,7 +171,7 @@ an error occurs.

size_t allwrite (int fd, char const *s, size_t len)
-Equivalent to allreadwrite((iofunc_t *)&fd_write, fd, s, len) : +Equivalent to allreadwrite((io_func *)&fd_write, fd, s, len) : attempts to write len bytes from s to fd, looping around fd_write() if necessary, until either len 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 libskarnet.a or libskarnet.so library.

djbtime is a set of functions to convert -tai_t and tain_t structures, and +tai and tain structures, and TAI time, from and to other time formats and user-friendly representations.

@@ -37,13 +37,13 @@ other time formats and user-friendly representations.

Data structures

@@ -52,7 +52,7 @@ field and an unsigned long nano field.

UTC

- int utc_from_tai (uint64_t *u, tai_t const *t)
+ int utc_from_tai (uint64_t *u, tai const *t)
Converts the absolute TAI64 time in *t to an UTC time, stored in *u as an unsigned 64-bit integer. *u is actually 2^62 plus the number of seconds since the Epoch. @@ -62,7 +62,7 @@ returns 2 instead of 1.

- int tai_from_utc (tai_t *t, uint64_t u)
+ int tai_from_utc (tai *t, uint64_t u)
Converts the UTC time in u, stored as an unsigned 64-bit integer (2^62 plus the number of seconds since the Epoch), to a TAI64 time in *t. @@ -73,7 +73,7 @@ error occurs.

NTP

- int ntp_from_tain (uint64_t *ntp, tain_t const *a)
+ int ntp_from_tain (uint64_t *ntp, tain const *a)
Converts the absolute TAI64N time in *a to a 64-bit NTP timestamp, stored in *ntp. The higher 32 bits of *ntp represent a number of seconds ; the lower 32 bits are the fractional part of the timestamp. @@ -83,7 +83,7 @@ error occurs (for instance:

- int tain_from_ntp (tain_t *a, uint64_t ntp)
+ int tain_from_ntp (tain *a, uint64_t ntp)
Converts the NTP timestamp in ntp to a TAI64N time in *a. 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.

- int localtm_from_tai (struct tm *tm, tai_t const *t, int lo)
+ int localtm_from_tai (struct tm *tm, tai const *t, int lo)
Converts the TAI time in *t to broken-down GMT (if lo is zero) or local (if lo is nonzero) time in *tm. @@ -141,7 +141,7 @@ error occurs.

- int tai_from_localtm (tai_t *t, struct tm const *tm)
+ int tai_from_localtm (tai *t, struct tm const *tm)
Converts the broken-down local time in *tm to a TAI value in *t. The function returns 1 if it succeeds, or 0 (and sets errno) if an @@ -157,11 +157,11 @@ error occurs.

- The following functions use the localtmn_t type to hold both + The following functions use the localtmn type to hold both a broken-down time and a nanosecond count:

-
typedef struct localtmn_s localtmn_t, *localtmn_t_ref ;
+
typedef struct localtmn_s localtmn, *localtmn_ref ;
 struct localtmn_s
 {
   struct tm tm ;
@@ -174,10 +174,10 @@ struct localtmn_s
 

 
 

- int localtmn_from_tain (localtmn_t *tmn, tain_t const *a, int lo) ; 

-int tain_from_localtmn (tain_t *a, localtmn_t const *tmn) ; 

-int localtmn_from_sysclock (localtmn_t *tmn, tain_t const *a, int lo) ; 

-int sysclock_from_localtmn (tain_t *a, localtmn_t const *tmn) ;  

+ int localtmn_from_tain (localtmn *tmn, tain const *a, int lo) ; 

+int tain_from_localtmn (tain *a, localtmn const *tmn) ; 

+int localtmn_from_sysclock (localtmn *tmn, tain const *a, int lo) ; 

+int sysclock_from_localtmn (tain *a, localtmn const *tmn) ;  

 

 
 
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.
 
 Temporization 

 
 

- void deepsleepuntil (tain_t const *deadline, tain_t *stamp)  

+ void deepsleepuntil (tain const *deadline, tain *stamp)  

 Sleeps until the absolute time represented by the
-tain_t *deadline. *stamp
+tain *deadline. *stamp
 must contain the current time. When the function returns, *stamp
 has been updated to reflect the new current time.
 

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 iopause() function uses a deadline argument,
 i.e. an absolute time at which it must return 0 if no event has happened
 so far, as well as a stamp argument, i.e. an absolute time meaning
 now. Those arguments are stored in
-tain_ts. Here is why:
+tains. Here is why:
 

 
 

@@ -153,7 +153,7 @@ that is why iopause relies on the tai library.
 
 Functions 

 
 

- int iopause (iopause_fd *x, unsigned int len, tain_t const *deadline, tain_t const *stamp)  

+ int iopause (iopause_fd *x, unsigned int len, tain const *deadline, tain const *stamp)  

 Blocks until one of the events described in the x array, of length
 len, happens, or until the absolute date *deadline is
 reached. deadline 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.
 

 
 

- int iopause_stamp (iopause_fd *x, unsigned int len, tain_t const *deadline, tain_t *stamp)  

+ int iopause_stamp (iopause_fd *x, unsigned int len, tain const *deadline, tain *stamp)  

 Like iopause(), but if stamp 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 stamp;
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.
 

 
 

- int socket_deadlineconnstamp46 (int fd, ip46_t const *a, uint16_t port, tain_t const *deadline, tain_t *stamp)  

+ int socket_deadlineconnstamp46 (int fd, ip46_t const *a, uint16_t port, tain const *deadline, tain *stamp)  

 Attempts to synchronously connect the socket fd to address aa
 and port port. Returns 1 if it succeeds and 0 (and sets errno)
 if it fails. stamp must contain an accurate enough
@@ -153,7 +153,7 @@ Returns 0 in case of success, and -1 (and sets errno) in case of failure.
 
 

  ssize_t socket_recvnb46 (int fd, char *s, size_t len, ip46_t *a, uint16_t *port,
-tain_t const *deadline, tain_t *stamp)  

+tain const *deadline, tain *stamp)  

 Like socket_recv46, except that the function blocks until a datagram
 is received. *stamp 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 *deadline, the function returns -1 ETIMEOUT.
 
 

  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)  

+tain const *deadline, tain *stamp)  

 Like socket_send46, except that the function blocks until a datagram
 has been effectively sent. *stamp 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.
 
 Data structures 

 
 

- A tai_t structure holds an absolute date with a one-second
-precision. A tain_t structure holds an absolute date with a
+ A tai structure holds an absolute date with a one-second
+precision. A tain structure holds an absolute date with a
 maximum of one-nanosecond precision, as permitted by the underlying system
 call. If flag-usert 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 
 clock_gettime()
 system call, which has a one-nanosecond precision. In either case, a current
-tain_t will be unable to be more precise than the underlying
+tain will be unable to be more precise than the underlying
 implementation.
 

 
 

- A tai_t, as well as a tain_t, can also
+ A tai, as well as a tain, 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.
 
 Wallclock operations 

 
 

- int tai_now (tai_t *t)  

+ int tai_now (tai *t)  

 Writes the current time as a TAI value to *t, 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.
 

 
 

- int sysclock_get (tain_t *a)  

+ int sysclock_get (tain *a)  

 Reads the current value of the system clock (as in CLOCK_REALTIME) into *a.
 Returns 1 if it succeeds or 0 (and sets errno) if it fails.
-Note that despite being a tain_t, *a
+Note that despite being a tain, *a
 does not contain a TAI value - 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.
 

 
 

- int sysclock_set (tain_t const *a)  

+ int sysclock_set (tain const *a)  

 Sets the system clock to *a, provided *a has
 the correct internal representation. You should not use this
 function directly unless you know exactly what you are doing.
 

 
 

- int tain_wallclock_read (tain_t *a)  

+ int tain_wallclock_read (tain *a)  

 Reads the current time into *a, as a TAI64N value.
 Returns 1 if it succeeds or 0 (and sets errno) if it fails.
 Here a contains a valid TAI64N stamp, no matter what the
@@ -156,7 +156,7 @@ on it.
 

 
 

- int tain_setnow (tain_t const *a)  

+ int tain_setnow (tain const *a)  

 Sets the current time to *a.
 Returns 1 if it succeeds or 0 (and sets errno) if it fails.
 a must contain a valid TAI64N stamp; proper
@@ -165,7 +165,7 @@ the right format for the system clock.
 

 
 

- int tain_now_set_wallclock (tain_t *a)  

+ int tain_now_set_wallclock (tain *a)  

 Tells skalibs that future invocations of tain_now()
 (see below) should use a wall clock, i.e. the system time
 as returned by clock_gettime(CLOCK_REALTIME) or
@@ -186,7 +186,7 @@ Otherwise, they will fail with errno set to ENOSYS.
 

 
 

- int tain_stopwatch_init (tain_t *a, clock_t cl, tain_t *offset)  

+ int tain_stopwatch_init (tain *a, clock_t cl, tain *offset)  

 Initializes a stopwatch in *offset, using a clock named cl.
 Typically, cl is something like CLOCK_MONOTONIC, when it is defined
 by the system. The actual value of
@@ -208,7 +208,7 @@ to zero.
 

 
 

- int tain_stopwatch_read (tain_t *a, clock_t cl, tain_t const *offset)  

+ int tain_stopwatch_read (tain *a, clock_t cl, tain const *offset)  

  Gives the absolute time, as a TAI64N value, in *a. This
 absolute time is computed as a linear increase (as measured with
 the cl 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.
 

 
 

- int tain_now_set_stopwatch (tain_t *a)  

+ int tain_now_set_stopwatch (tain *a)  

 Tells skalibs that future invocations of tain_now()
 (see below) should use a stopwatch, i.e. the system time
 as returned by clock_gettime(CLOCK_MONOTONIC) or similar,
@@ -240,7 +240,7 @@ is returned in *a.
 
 All-purpose time reading 

 
 

- int tain_now (tain_t *a)  

+ int tain_now (tain *a)  

 Writes the current time, as a TAI value, to *a. 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 tai_from_timeval 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.
 

 
@@ -290,32 +290,32 @@ system clock format to TAI, see the next section.
 

 
 

- int tai_from_time (tai_t *t, time_t u) 

-int tai_relative_from_time (tai_t *t, time_t u)  

+ int tai_from_time (tai *t, time_t u) 

+int tai_relative_from_time (tai *t, time_t u)  

 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).
 

 
 

- int time_from_tai (time_t *u, tai_t const *t) 

-int time_from_tai_relative (time_t *u, tai_t const *t)  

+ int time_from_tai (time_t *u, tai const *t) 

+int time_from_tai_relative (time_t *u, tai const *t)  

 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).
 

 
 

- int tain_from_timeval (tain_t *a, struct timeval const *tv) 

-int tain_relative_from_timeval (tain_t *a, struct timeval const *tv) 

-int tain_from_timespec (tain_t *a, struct timespec const *ts) 

-int tain_relative_from_timespec (tain_t *a, struct timespec const *ts) 

-int timeval_from_tain (struct timeval *tv, tain_t const *a) 

-int timeval_from_tain_relative (struct timeval *tv, tain_t const *a) 

-int timespec_from_tain (struct timespec *ts, tain_t const *a) 

-int timespec_from_tain_relative (struct timespec *ts, tain_t const *a)  

-Same conversion operations, between tain_t and a
+ int tain_from_timeval (tain *a, struct timeval const *tv) 

+int tain_relative_from_timeval (tain *a, struct timeval const *tv) 

+int tain_from_timespec (tain *a, struct timespec const *ts) 

+int tain_relative_from_timespec (tain *a, struct timespec const *ts) 

+int timeval_from_tain (struct timeval *tv, tain const *a) 

+int timeval_from_tain_relative (struct timeval *tv, tain const *a) 

+int timespec_from_tain (struct timespec *ts, tain const *a) 

+int timespec_from_tain_relative (struct timespec *ts, tain const *a)  

+Same conversion operations, between tain and a
 struct timeval or struct timespec. The 1-microsecond
 (for struct timeval) or 1-nanosecond (for struct timespec)
 precision is preserved.
@@ -326,8 +326,8 @@ precision is preserved.
 

  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 time_t), or other error
 codes.
 

 
- int tai_from_time_sysclock (tai_t *a, time_t t) 

-int time_sysclock_from_tai (time_t *t, tai_t const *a) 

-int tain_from_timeval_sysclock (tain_t *a, struct timeval const *tv) 

-int timeval_sysclock_from_tain (struct timeval *tv, tain_t const *a) 

-int tain_from_timespec_sysclock (tain_t *a, struct timespec const *ts) 

-int timespec_sysclock_from_tain (struct timespec *ts, tain_t const *a) 
+ int tai_from_time_sysclock (tai *a, time_t t) 

+int time_sysclock_from_tai (time_t *t, tai const *a) 

+int tain_from_timeval_sysclock (tain *a, struct timeval const *tv) 

+int timeval_sysclock_from_tain (struct timeval *tv, tain const *a) 

+int tain_from_timespec_sysclock (tain *a, struct timespec const *ts) 

+int timespec_sysclock_from_tain (struct timespec *ts, tain const *a) 
 
 
 Conversions to/from basic types 

 
 

- int tain_uint (tain_t *a, unsigned int c)  

+ int tain_uint (tain *a, unsigned int c)  

 Stores a relative time of c seconds into a.
 Normally returns 1, but may return 0 EINVAL on pathological numbers.
 

 
 

- int tain_from_millisecs (tain_t *a, int ms)  

-This function makes a tain_t representing a relative
+ int tain_from_millisecs (tain *a, int ms)  

+This function makes a tain representing a relative
 time of ms milliseconds. ms must be non-negative.
 The function returns 1, unless ms is negative, in which case
 it returns 0 EINVAL.
 

 
 

- int tain_to_millisecs (tain_t const *a)  

+ int taino_millisecs (tain const *a)  

 If *a 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.
 
 Time computations 

 
 

- int tai_add (tai_t *t, tai_t const *t1, tai_t const *t2)  

+ int tai_add (tai *t, tai const *t1, tai const *t2)  

 Stores *t1 + *t2 into t. Of course, *t1
 and *t2 must not both represent absolute times.
 The function normally returns 1, but will return 0 on bad inputs.
 

 
 

- int tai_sub (tai_t *t, tai_t const *t1, tai_t const *t2)  

+ int tai_sub (tai *t, tai const *t1, tai const *t2)  

 Stores *t1 - *t2 into t. *t1 cannot
 be relative if *t2 is absolute. If they are both relative or
 both absolute, then *t is relative, else it's absolute.
@@ -395,27 +395,27 @@ The function normally returns 1, but will return 0 on bad inputs.
 

 
 

- int tain_add (tain_t *a, tain_t const *a1, tain_t const *a2) 

-int tain_sub (tain_t *a, tain_t const *a1, tain_t const *a2)  

-Same thing with tain_t.
+ int tain_add (tain *a, tain const *a1, tain const *a2) 

+int tain_sub (tain *a, tain const *a1, tain const *a2)  

+Same thing with tain.
 

 
 

- int tain_addsec (tain_t *a, tain_t const *a1, int c)  

+ int tain_addsec (tain *a, tain const *a1, int c)  

 Adds c seconds to *a1 and stores the result into a.
 c may be negative.
 

 
 

- void tain_half (tain_t *a, tain_t const *b)  

+ void tain_half (tain *a, tain const *b)  

 Stores *b/2 into a. *b must be relative.
 

 
 
 Comparing dates or durations 

 
 

- int tai_less (tai_t const *t1, tai_t const *t2) 

-int tain_less (tain_t const *t1, tain_t const *t2)  

+ int tai_less (tai const *t1, tai const *t2) 

+int tain_less (tain const *t1, tain const *t2)  

 Those functions return nonzero iff *t1 is lesser than *t2.
 *t1 and *t2 must be both relative, or both absolute.
 

@@ -423,7 +423,7 @@ Those functions return nonzero iff *t1 is lesser than *t2.
 
 Packing and unpacking 

 
 

- void tai_pack (char *s, tai_t const *t)  

+ void tai_pack (char *s, tai const *t)  

 Marshals *t into the buffer s points to, which
 must be preallocated with at least TAI_PACK (8) characters. Afterwards,
 the buffer contains the
@@ -432,7 +432,7 @@ representation of *t.
 

 
 

- void tai_unpack (char const *s, tai_t *t)  

+ void tai_unpack (char const *s, tai *t)  

 Unmarshals the
 external TAI64 format
 label pointed to by s (at least TAI_PACK characters) and stores
@@ -440,8 +440,8 @@ the result into t.
 

 
 

- void tain_pack (char *s, tain_t const *a) 

-void tain_unpack (char const *s, tain_t *a)  

+ void tain_pack (char *s, tain const *a) 

+void tain_unpack (char const *s, tain *a)  

 Same thing with
 external TAI64N format,
 using TAIN_PACK (12) characters.
@@ -450,7 +450,7 @@ using TAIN_PACK (12) characters.
 
 Formatting and scanning 

 
 

- unsigned int tain_fmt (char *s, tain_t const *a)  

+ unsigned int tain_fmt (char *s, tain const *a)  

 Writes into s an ASCII representation of *a in external
 TAI64N format. s 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 s (24).
 

 
 

- unsigned int tain_scan (char const *s, tain_t *a)  

+ unsigned int tain_scan (char const *s, tain *a)  

 Reads 24 characters from s; if those characters are a valid ASCII
 representation of the external TAI64N format of some time value, this value
 is stored into a, and 24 is returned. Else 0 is returned.
@@ -473,13 +473,13 @@ format of an absolute date.
 

 
 

- unsigned int timestamp_fmt (char *s, tain_t const *a)  

+ unsigned int timestamp_fmt (char *s, tain const *a)  

 Writes a TAI64N timestamp representing the absolute date *a
 into the 25 characters pointed to by s. Returns 25.
 

 
 

- unsigned int timestamp_scan (char const *s, tain_t *a)  

+ unsigned int timestamp_scan (char const *s, tain *a)  

 Reads 25 characters at s. If those characters are a valid TAI64N
 timestamp, stores the absolute date in a and returns 25. Else,
 returns 0.
-- 
cgit v1.2.3