From 7e1986c10dea181d5a096b6c6de78ab23dabcb95 Mon Sep 17 00:00:00 2001
From: Martin Baute <solar@rootdirectory.de>
Date: Tue, 5 Apr 2016 07:47:32 +0200
Subject: [PATCH] Using code from tzcode.

---
 functions/time/difftime.c                   | 42 ++++++++++++++++++++-
 internals/_PDCLIB_aux.h                     |  6 +++
 platform/example/internals/_PDCLIB_config.h |  1 -
 3 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/functions/time/difftime.c b/functions/time/difftime.c
index fa6eb9c..b76efb9 100644
--- a/functions/time/difftime.c
+++ b/functions/time/difftime.c
@@ -10,7 +10,47 @@
 
 double difftime( time_t time1, time_t time0 )
 {
-    return ( time1 > time0 ) ? (double)( time1 - time0 ) : -(double)( time0 - time1 );
+    /* If we want to avoid rounding errors and overflows, we need to be
+       careful with the exact type of time_t being unknown to us.
+       The code below is based on tzcode's difftime.c, which is in the
+       public domain, so clarified as of 1996-06-05 by Arthur David Olson.
+    */
+
+    /* If double is large enough, simply covert and substract
+       (assuming that the larger type has more precision).
+    */
+    if ( sizeof( time_t ) < sizeof( double ) )
+    {
+        return (double)time1 - (double)time0;
+    }
+
+    /* The difference of two unsigned values cannot overflow if the
+       minuend is greater or equal to the subtrahend.
+    */
+    if ( ! _PDCLIB_TYPE_SIGNED( time_t ) )
+    {
+        return ( time1 >= time0 ) ? (double)( time1 - time0 ) : -(double)( time0 - time1 );
+    }
+
+    /* Use uintmax_t if wide enough. */
+    if ( sizeof( time_t ) <= sizeof( _PDCLIB_uintmax_t ) )
+    {
+        _PDCLIB_uintmax_t t1 = time1, t0 = time0;
+        return ( time1 >= time0 ) ? t1 - t0 : -(double)( t0 - t1 );
+    }
+
+    /* If both times have the same sign, their difference cannot overflow. */
+    if ( ( time1 < 0 ) == ( time0 < 0 ) )
+    {
+        return time1 - time0;
+    }
+
+    /* The times have opposite signs, and uintmax_t is too narrow.
+       This suffers from double rounding; attempt to lessen that
+       by using long double temporaries.
+    */
+    long double t1 = time1, t0 = time0;
+    return t1 - t0;
 }
 
 #endif
diff --git a/internals/_PDCLIB_aux.h b/internals/_PDCLIB_aux.h
index d09c9e7..ebbced4 100644
--- a/internals/_PDCLIB_aux.h
+++ b/internals/_PDCLIB_aux.h
@@ -47,6 +47,9 @@
 /* _PDCLIB_concat( x, y ) concatenates two preprocessor tokens with extending */
 /* _PDCLIB_static_assert( e, m ) does a compile-time assertion of expression  */
 /*                               e, with m as the failure message.            */
+/* _PDCLIB_TYPE_SIGNED( type ) resolves to true if type is signed.            */
+/* _PDCLIB_TWOS_COMPLEMENT( type ) resolves to true if two's complement is    */
+/*                                 used for type.                             */
 /* -------------------------------------------------------------------------- */
 
 #define _PDCLIB_cc( x, y )     x ## y
@@ -54,6 +57,9 @@
 
 #define _PDCLIB_static_assert( e, m ) enum { _PDCLIB_concat( _PDCLIB_assert_, __LINE__ ) = 1 / ( !!(e) ) }
 
+#define _PDCLIB_TYPE_SIGNED( type ) (((type) -1) < 0)
+#define _PDCLIB_TWOS_COMPLEMENT( type ) ((type) ~ (type) 0 < 0 )
+
 #define _PDCLIB_symbol2value( x ) #x
 #define _PDCLIB_symbol2string( x ) _PDCLIB_symbol2value( x )
 
diff --git a/platform/example/internals/_PDCLIB_config.h b/platform/example/internals/_PDCLIB_config.h
index 41fe9e0..fe23663 100755
--- a/platform/example/internals/_PDCLIB_config.h
+++ b/platform/example/internals/_PDCLIB_config.h
@@ -176,7 +176,6 @@ struct _PDCLIB_imaxdiv_t
 
 /* See <time.h> for a couple of comments on these types and their semantics. */
 
-/* If you change this type to something exotic, check time/difftime.c */
 #define _PDCLIB_time long
 
 #define _PDCLIB_clock long
-- 
2.40.0