1 files changed, 446 insertions, 0 deletions
diff --git a/include/timevalops.h b/include/timevalops.h
new file mode 100644
index 0000000..e873b8b
--- /dev/null
+++ b/include/timevalops.h
@@ -0,0 +1,446 @@
+/*
+ * timevalops.h -- calculations on 'struct timeval' values
+ *
+ * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
+ * The contents of 'html/copyright.html' apply.
+ *
+ * For a rationale look at 'timespecops.h'; we do the same here, but the
+ * normalisation keeps the microseconds in [0 .. 10^6[, of course.
+ */
+#ifndef TIMEVALOPS_H
+#define TIMEVALOPS_H
+
+#include <sys/types.h>
+#include <stdio.h>
+
+#include "ntp.h"
+#include "timetoa.h"
+
+
+/* microseconds per second */
+#define MICROSECONDS 1000000
+
+#ifndef HAVE_U_INT64
+# define USE_TSF_USEC_TABLES
+#endif
+
+/*
+ * Convert usec to a time stamp fraction.
+ */
+#ifdef USE_TSF_USEC_TABLES
+extern const u_int32 ustotslo[];
+extern const u_int32 ustotsmid[];
+extern const u_int32 ustotshi[];
+
+# define TVUTOTSF(tvu, tsf)						\
+	 ((tsf) = ustotslo[(tvu) & 0xff]				\
+		  + ustotsmid[((tvu) >> 8) & 0xff]			\
+		  + ustotshi[((tvu) >> 16) & 0xf])
+#else
+# define TVUTOTSF(tvu, tsf)						\
+	((tsf) = (u_int32)						\
+		 ((((u_int64)(tvu) << 32) + MICROSECONDS / 2) /		\
+		  MICROSECONDS))
+#endif
+
+/*
+ * Convert a time stamp fraction to microseconds.  The time stamp
+ * fraction is assumed to be unsigned.
+ */
+#ifdef USE_TSF_USEC_TABLES
+extern const u_int32 tstouslo[256];
+extern const u_int32 tstousmid[256];
+extern const u_int32 tstoushi[128];
+
+/*
+ * TV_SHIFT is used to turn the table result into a usec value.  To
+ * round, add in TV_ROUNDBIT before shifting.
+ */
+#define	TV_SHIFT	3
+#define	TV_ROUNDBIT	0x4
+
+# define TSFTOTVU(tsf, tvu)						\
+	 ((tvu) = (tstoushi[((tsf) >> 24) & 0xff]			\
+		  + tstousmid[((tsf) >> 16) & 0xff]			\
+		  + tstouslo[((tsf) >> 9) & 0x7f]			\
+		  + TV_ROUNDBIT) >> TV_SHIFT)
+#else
+# define TSFTOTVU(tsf, tvu)						\
+	 ((tvu) = (int32)						\
+		  (((u_int64)(tsf) * MICROSECONDS + 0x80000000) >> 32))
+#endif
+
+/*
+ * Convert a struct timeval to a time stamp.
+ */
+#define TVTOTS(tv, ts) \
+	do { \
+		(ts)->l_ui = (u_long)(tv)->tv_sec; \
+		TVUTOTSF((tv)->tv_usec, (ts)->l_uf); \
+	} while (FALSE)
+
+#define sTVTOTS(tv, ts) \
+	do { \
+		int isneg = 0; \
+		long usec; \
+		(ts)->l_ui = (tv)->tv_sec; \
+		usec = (tv)->tv_usec; \
+		if (((tv)->tv_sec < 0) || ((tv)->tv_usec < 0)) { \
+			usec = -usec; \
+			(ts)->l_ui = -(ts)->l_ui; \
+			isneg = 1; \
+		} \
+		TVUTOTSF(usec, (ts)->l_uf); \
+		if (isneg) { \
+			L_NEG((ts)); \
+		} \
+	} while (FALSE)
+
+/*
+ * Convert a time stamp to a struct timeval.  The time stamp
+ * has to be positive.
+ */
+#define	TSTOTV(ts, tv) \
+	do { \
+		(tv)->tv_sec = (ts)->l_ui; \
+		TSFTOTVU((ts)->l_uf, (tv)->tv_usec); \
+		if ((tv)->tv_usec == 1000000) { \
+			(tv)->tv_sec++; \
+			(tv)->tv_usec = 0; \
+		} \
+	} while (FALSE)
+
+
+/*
+ * predicate: returns TRUE if the microseconds are in nominal range
+ * use like: int timeval_isnormal(const struct timeval *x)
+ */
+#define timeval_isnormal(x) \
+	((x)->tv_usec >= 0 && (x)->tv_usec < MICROSECONDS)
+
+/*
+ * Convert milliseconds to a time stamp fraction.  Unused except for
+ * refclock_leitch.c, so accompanying lookup tables were removed in
+ * favor of reusing the microseconds conversion tables.
+ */
+#define	MSUTOTSF(msu, tsf)	TVUTOTSF((msu) * 1000, tsf)
+
+/*
+ * predicate: returns TRUE if the microseconds are out-of-bounds
+ * use like: int timeval_isdenormal(const struct timeval *x)
+ */
+#define timeval_isdenormal(x)	(!timeval_isnormal(x))
+
+/* make sure microseconds are in nominal range */
+static inline struct timeval
+normalize_tval(
+	struct timeval	x
+	)
+{
+	long		z;
+
+	/*
+	 * If the fraction becomes excessive denormal, we use division
+	 * to do first partial normalisation. The normalisation loops
+	 * following will do the remaining cleanup. Since the size of
+	 * tv_usec has a peculiar definition by the standard the range
+	 * check is coded manually. And labs() is intentionally not used
+	 * here: it has implementation-defined behaviour when applied
+	 * to LONG_MIN.
+	 */
+	if (x.tv_usec < -3l * MICROSECONDS ||
+	    x.tv_usec >  3l * MICROSECONDS  ) {
+		z = x.tv_usec / MICROSECONDS;
+		x.tv_usec -= z * MICROSECONDS;
+		x.tv_sec += z;
+	}
+
+	/*
+	 * Do any remaining normalisation steps in loops. This takes 3
+	 * steps max, and should outperform a division even if the
+	 * mul-by-inverse trick is employed. (It also does the floor
+	 * division adjustment if the above division was executed.)
+	 */
+	if (x.tv_usec < 0)
+		do {
+			x.tv_usec += MICROSECONDS;
+			x.tv_sec--;
+		} while (x.tv_usec < 0);
+	else if (x.tv_usec >= MICROSECONDS)
+		do {
+			x.tv_usec -= MICROSECONDS;
+			x.tv_sec++;
+		} while (x.tv_usec >= MICROSECONDS);
+
+	return x;
+}
+
+/* x = a + b */
+static inline struct timeval
+add_tval(
+	struct timeval	a,
+	struct timeval	b
+	)
+{
+	struct timeval	x;
+
+	x = a;
+	x.tv_sec += b.tv_sec;
+	x.tv_usec += b.tv_usec;
+
+	return normalize_tval(x);
+}
+
+/* x = a + b, b is fraction only */
+static inline struct timeval
+add_tval_us(
+	struct timeval	a,
+	long		b
+	)
+{
+	struct timeval x;
+
+	x = a;
+	x.tv_usec += b;
+
+	return normalize_tval(x);
+}
+
+/* x = a - b */
+static inline struct timeval
+sub_tval(
+	struct timeval	a,
+	struct timeval	b
+	)
+{	
+	struct timeval	x;
+
+	x = a;
+	x.tv_sec -= b.tv_sec;
+	x.tv_usec -= b.tv_usec;
+
+	return normalize_tval(x);
+}
+
+/* x = a - b, b is fraction only */
+static inline struct timeval
+sub_tval_us(
+	struct timeval	a,
+	long		b
+	)
+{
+	struct timeval x;
+
+	x = a;
+	x.tv_usec -= b;
+
+	return normalize_tval(x);
+}
+
+/* x = -a */
+static inline struct timeval
+neg_tval(
+	struct timeval	a
+	)
+{	
+	struct timeval	x;
+
+	x.tv_sec = -a.tv_sec;
+	x.tv_usec = -a.tv_usec;
+
+	return normalize_tval(x);
+}
+
+/* x = abs(a) */
+static inline struct timeval
+abs_tval(
+	struct timeval	a
+	)
+{
+	struct timeval	c;
+
+	c = normalize_tval(a);
+	if (c.tv_sec < 0) {
+		if (c.tv_usec != 0) {
+			c.tv_sec = -c.tv_sec - 1;
+			c.tv_usec = MICROSECONDS - c.tv_usec;
+		} else {
+			c.tv_sec = -c.tv_sec;
+		}
+	}
+
+	return c;
+}
+
+/*
+ * compare previously-normalised a and b
+ * return 1 / 0 / -1 if a < / == / > b
+ */
+static inline int
+cmp_tval(
+	struct timeval a,
+	struct timeval b
+	)
+{
+	int r;
+
+	r = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
+	if (0 == r)
+		r = (a.tv_usec > b.tv_usec) -
+		    (a.tv_usec < b.tv_usec);
+	
+	return r;
+}
+
+/*
+ * compare possibly-denormal a and b
+ * return 1 / 0 / -1 if a < / == / > b
+ */
+static inline int
+cmp_tval_denorm(
+	struct timeval	a,
+	struct timeval	b
+	)
+{
+	return cmp_tval(normalize_tval(a), normalize_tval(b));
+}
+
+/*
+ * test previously-normalised a
+ * return 1 / 0 / -1 if a < / == / > 0
+ */
+static inline int
+test_tval(
+	struct timeval	a
+	)
+{
+	int		r;
+
+	r = (a.tv_sec > 0) - (a.tv_sec < 0);
+	if (r == 0)
+		r = (a.tv_usec > 0);
+	
+	return r;
+}
+
+/*
+ * test possibly-denormal a
+ * return 1 / 0 / -1 if a < / == / > 0
+ */
+static inline int
+test_tval_denorm(
+	struct timeval	a
+	)
+{
+	return test_tval(normalize_tval(a));
+}
+
+/* return LIB buffer ptr to string rep */
+static inline const char *
+tvaltoa(
+	struct timeval	x
+	)
+{
+	return format_time_fraction(x.tv_sec, x.tv_usec, 6);
+}
+
+/* convert from timeval duration to l_fp duration */
+static inline l_fp
+tval_intv_to_lfp(
+	struct timeval	x
+	)
+{
+	struct timeval	v;
+	l_fp		y;
+	
+	v = normalize_tval(x);
+	TVUTOTSF(v.tv_usec, y.l_uf);
+	y.l_i = (int32)v.tv_sec;
+
+	return y;
+}
+
+/* x must be UN*X epoch, output *y will be in NTP epoch */
+static inline l_fp
+tval_stamp_to_lfp(
+	struct timeval	x
+	)
+{
+	l_fp		y;
+
+	y = tval_intv_to_lfp(x);
+	y.l_ui += JAN_1970;
+
+	return y;
+}
+
+/* convert to l_fp type, relative signed/unsigned and absolute */
+static inline struct timeval
+lfp_intv_to_tval(
+	l_fp		x
+	)
+{
+	struct timeval	out;
+	l_fp		absx;
+	int		neg;
+	
+	neg = L_ISNEG(&x);
+	absx = x;
+	if (neg) {
+		L_NEG(&absx);	
+	}
+	TSFTOTVU(absx.l_uf, out.tv_usec);
+	out.tv_sec = absx.l_i;
+	if (neg) {
+		out.tv_sec = -out.tv_sec;
+		out.tv_usec = -out.tv_usec;
+		out = normalize_tval(out);
+	}
+
+	return out;
+}
+
+static inline struct timeval
+lfp_uintv_to_tval(
+	l_fp		x
+	)
+{
+	struct timeval	out;
+	
+	TSFTOTVU(x.l_uf, out.tv_usec);
+	out.tv_sec = x.l_ui;
+
+	return out;
+}
+
+/*
+ * absolute (timestamp) conversion. Input is time in NTP epoch, output
+ * is in UN*X epoch. The NTP time stamp will be expanded around the
+ * pivot time *p or the current time, if p is NULL.
+ */
+static inline struct timeval
+lfp_stamp_to_tval(
+	l_fp		x,
+	const time_t *	p
+	)
+{
+	struct timeval	out;
+	vint64		sec;
+
+	sec = ntpcal_ntp_to_time(x.l_ui, p);
+	TSFTOTVU(x.l_uf, out.tv_usec);
+
+	/* copying a vint64 to a time_t needs some care... */
+#if SIZEOF_TIME_T <= 4
+	out.tv_sec = (time_t)sec.d_s.lo;
+#elif defined(HAVE_INT64)
+	out.tv_sec = (time_t)sec.q_s;
+#else
+	out.tv_sec = ((time_t)sec.d_s.hi << 32) | sec.d_s.lo;
+#endif
+	out = normalize_tval(out);
+
+	return out;
+}
+
+#endif	/* TIMEVALOPS_H */