Changeset 1788

Timestamp:

Jan 17, 2005, 9:07:48 AM (21 years ago)

Author:

bird

Message:

Added time64_t and a few 64-bit time functions for dealing better with over/underflows.

Location:

trunk/src/emx

Files:

• include/emx/time.h (modified) (2 diffs, 1 prop)
• include/time.h (modified) (3 diffs, 1 prop)
• src/lib/libc.def (modified) (1 diff, 1 prop)
• src/lib/time/gmtime.c (modified) (2 diffs, 1 prop)
• src/lib/time/gmtloc.c (modified) (2 diffs, 1 prop)
• src/lib/time/localtim.c (modified) (2 diffs, 1 prop)
• src/lib/time/mktime.c (modified) (2 diffs, 1 prop)

trunk/src/emx/include/emx/time.h

@@ -20 +20 @@
 #define _TIME_T                         /* bird: EMX */
 #endif
+
+#ifndef _TIME64_T_DECLARED              /* bird: LIBC */
+typedef __int64_t       time64_t;       /* bird: LIBC */
+#define _TIME64_T_DECLARED              /* bird: LIBC */
+#endif                                  /* bird: LIBC */
 
 struct tm;
@@ -45 +50 @@
 int _day (int, int, int);
 int _gmt2loc (time_t *);
+int _gmt2loc64 (time64_t *p);
 int _loc2gmt (time_t *, int);
-/* struct tm *_gmtime (struct tm *, const time_t *); - use gmtime_r */
-/* struct tm *_localtime (struct tm *, const time_t *); - use localtime_r */
+int _loc2gmt64 (time64_t *, int);
+/* struct tm *_gmtime (struct tm *, const time_t *); - use _gmtime64_r */
+/* struct tm *_localtime (struct tm *, const time_t *); - use _localtime64_r */
 unsigned long _mktime (struct tm *);
+time64_t _mktime64 (struct tm *);
 void _compute_dst_table (void);
 

trunk/src/emx/include/time.h

@@ -93 +93 @@
 #endif
 
+#ifndef _TIME64_T_DECLARED              /* bird: LIBC */
+typedef __int64_t       time64_t;       /* bird: LIBC */
+#define _TIME64_T_DECLARED              /* bird: LIBC */
+#endif                                  /* bird: LIBC */
+
 #if !defined(_SIZE_T_DECLARED) && !defined(_SIZE_T) /* bird: EMX */
 typedef __size_t        size_t;
@@ -145 +150 @@
 struct tm *gmtime(const time_t *);
 struct tm *localtime(const time_t *);
+struct tm *_localtime64_r(const time64_t *, struct tm *); /* bird: LIBC */
 time_t mktime(struct tm *);
+time64_t _mktime64(struct tm *); /* bird: LIBC  */
 size_t strftime(char * __restrict, size_t, const char * __restrict,
     const struct tm * __restrict);
@@ -165 +172 @@
 char *ctime_r(const time_t *, char *);
 struct tm *gmtime_r(const time_t *, struct tm *);
+struct tm *_gmtime64_r(const time64_t *, struct tm *); /* bird: LIBC */
 struct tm *localtime_r(const time_t *, struct tm *);
 #endif

trunk/src/emx/src/lib/libc.def

@@ -1373 +1373 @@
     "__std_wcswidth" @1387
     "___libc_Back_fsUnlink" @1388
+    "__gmt2loc64" @1389
+    "__gmtime64_r" @1390
+    "__loc2gmt64" @1391
+    "__localtime64_r" @1392
+    "__mktime64" @1393
+    "___mktime64" @1394

trunk/src/emx/src/lib/time/gmtime.c

@@ -4 +4 @@
 #include <stdlib.h>
 #include <time.h>
+#include <stdint.h>
 #include <InnoTekLIBC/thread.h>
 #include <emx/time.h>
 
-struct tm *_STD(gmtime_r)(const time_t *t, struct tm *dst)
+struct tm *_gmtime64_r(const time64_t *t, struct tm *dst)
 {
     int days;
     int rem;
+    time64_t t1 = *t;
 
     /* calc days relative to Epoch. */
-    rem = *t;
-    days = rem / (60*60*24);
-    rem %= (60*60*24);
+    days = t1 / (60*60*24);
+    rem = t1 % (60*60*24);
     while (rem < 0)
     {
@@ -67 +68 @@
 }
 
+struct tm *_STD(gmtime_r)(const time_t *t, struct tm *dst)
+{
+    time64_t t64 = *t;
+    return _gmtime64_r(&t64, dst);
+}
+
 struct tm *_STD(gmtime)(const time_t *t)
 {
-    __LIBC_PTHREAD pThrd = __libc_threadCurrent ();
-    return gmtime_r (t, &pThrd->GmTimeAndLocalTimeBuf);
+    __LIBC_PTHREAD pThrd = __libc_threadCurrent();
+    return gmtime_r(t, &pThrd->GmTimeAndLocalTimeBuf);
 }

trunk/src/emx/src/lib/time/gmtloc.c

@@ -187 +187 @@
 }
 
+/**
+ * Convert from gmt to local time.
+ *
+ * @returns 1 if dts.
+ * @returns 0 if not dts.
+ * @returns -1 on over/under flow.
+ * @param   p   The time to convert.
+ */
+int _gmt2loc64 (time64_t *p)
+{
+    struct _dstswitch *sw;
+    sw = find_switch ((time_t)*p); //fixme!
+    time64_t t = *p - (_tzi.tz - sw->shift);
+    if (_tzi.tz - sw->shift > 0 ? t > *p : t < *p)
+        return -1;
+    *p = t;
+    return sw->shift != 0;
+}
+
 
 /* Note that this function returns -1 on error (overflow).
@@ -265 +284 @@
     }
 }
+
+
+/**
+ * Convert from local time to gmt.
+ *
+ * @returns 1 if dts.
+ * @returns 0 if not dts.
+ * @returns -1 on over/under flow.
+ * @param   p   The time to convert.
+ */
+int _loc2gmt64(time64_t *p, int is_dst)
+{
+    time64_t x;
+    struct _dstswitch *sw;
+    int count;
+
+    if (is_dst > 0)
+    {
+        /* Our caller says that *P is specified as DST.  Compute UTC
+           from *P, assuming that daylight saving applies. */
+
+        x = *p + (_tzi.tz - _tzi.shift);
+        if (_tzi.tz - _tzi.shift > 0 ? x < *p : x > *p)
+            return -1;
+        sw = find_switch (x);
+        *p = x;
+        return sw->shift != 0;
+    }
+    else if (is_dst == 0)
+    {
+        /* Our caller says that *P is specified as standard time.
+           Compute UTC from *P, assuming that daylight saving does not
+           apply. */
+
+        x = *p + _tzi.tz;
+        if (_tzi.tz > 0 ? x < *p : x > *p)
+            return -1;
+        sw = find_switch (x);
+        *p = x;
+        return sw->shift != 0;
+    }
+    else
+    {
+        /* Our caller does not know whether *P is specified as DST or
+           standard time.  Try to find out.  First try DST. */
+
+        count = 0;
+        x = *p + _tzi.tz - _tzi.shift;
+        if (!(_tzi.tz - _tzi.shift > 0 ? x < *p : x > *p))
+        {
+            sw = find_switch (x);
+            if (sw->shift != 0)
+            {
+                *p = x;
+                return 1;         /* DST */
+            }
+            ++count;
+        }
+
+        x = *p + _tzi.tz;
+        if (!(_tzi.tz > 0 ? x < *p : x > *p))
+        {
+            sw = find_switch (x);
+            if (sw->shift == 0)
+            {
+                *p = x;
+                return 0;         /* Not DST */
+            }
+            ++count;
+        }
+
+        if (count != 2)
+            return -1;              /* Overflow */
+
+        /* Assume that DST does not apply in the gap.  This makes moving
+           into the gap from below work, but breaks moving into the gap
+           from above.  The advantage of this choice is that ftime()
+           works correctly in the gap if the clock is not adjusted. */
+
+        *p += _tzi.tz;
+        return 0;                 /* Not DST */
+    }
+}

trunk/src/emx/src/lib/time/localtim.c

@@ -6 +6 @@
 #include <emx/time.h>
 
+struct tm *_localtime64_r(const time64_t *t, struct tm *dst)
+{
+    if (!_tzset_flag)
+        tzset();
+    time64_t lt = *t;
+    int isdst = _gmt2loc64(&lt);
+    struct tm *p = _gmtime64_r(&lt, dst);
+    p->tm_isdst = isdst;
+    return p;
+}
+
+struct tm *_STD(localtime_r)(const time_t *t, struct tm *dst)
+{
+    time64_t t64 = *t;
+    return _localtime64_r(&t64, dst);
+}
+
 struct tm *_STD(localtime)(const time_t *t)
 {
@@ -12 +29 @@
 }
 
-struct tm *_STD(localtime_r)(const time_t *t, struct tm *dst)
-{
-    time_t lt;
-    int isdst;
-    struct tm *p;
-
-    if (!_tzset_flag) tzset();
-    lt = *t;
-    isdst = _gmt2loc(&lt);
-    p = gmtime_r(&lt, dst);
-    p->tm_isdst = isdst;
-    return p;
-}

trunk/src/emx/src/lib/time/mktime.c

@@ -8 +8 @@
 time_t _STD(mktime) (struct tm *t)
 {
-  time_t t1, t2;
-  struct tm tmp;
-  int dst;
+    time64_t t64 = _mktime64(t);
+    time64_t t32 = _mktime64(t);
+    if (t64 != t32)
+        t32 = t64 > 0 ? TIME_T_MAX : TIME_T_MIN;
+    return t32;
+}
 
-  if (!_tzset_flag) tzset ();
 
-  /* _mktime() requires that tm_mon is in range.  The other members
-     are not restricted. */
+time64_t _mktime64(struct tm *t)
+{
+    time64_t t1, t2;
+    struct tm tmp;
+    int dst;
 
-  if (t->tm_mon < 0)
+    if (!_tzset_flag)
+        tzset ();
+
+    /* mktime() requires that tm_mon is in range.  The other members
+       are not restricted. */
+
+    if (t->tm_mon < 0)
     {
-      /* Avoid applying the `/' and `%' operators to negative numbers
-         as the results are implementation-defined for negative
-         numbers. */
+        /* Avoid applying the `/' and `%' operators to negative numbers
+           as the results are implementation-defined for negative
+           numbers. */
 
-      t->tm_year -= 1 + ((-t->tm_mon) / 12);
-      t->tm_mon = 12 - ((-t->tm_mon) % 12);
+        t->tm_year -= 1 + ((-t->tm_mon) / 12);
+        t->tm_mon = 12 - ((-t->tm_mon) % 12);
     }
-  if (t->tm_mon >= 12)
+    if (t->tm_mon >= 12)
     {
-      t->tm_year += (t->tm_mon / 12);
-      t->tm_mon %= 12;
+        t->tm_year += (t->tm_mon / 12);
+        t->tm_mon %= 12;
     }
 
-  t1 = (time_t)_mktime (t);
-  if (t1 == (time_t)-1)
-    return (time_t)-1;
-  dst = _loc2gmt (&t1, t->tm_isdst);
-  if (dst == -1)
-    return (time_t)-1;
-  t2 = t1;
-  dst = _gmt2loc (&t2);
-  if (dst == -1)
-    return (time_t)-1;
+    t1 = (time_t)__mktime64(t);
+    if (t1 == (time_t)-1)
+        return -1;
+    dst = _loc2gmt64(&t1, t->tm_isdst);
+    if (dst == -1)
+        return -1;
+    t2 = t1;
+    dst = _gmt2loc64(&t2);
+    if (dst == -1)
+        return -1;
 
-  if (gmtime_r (&t2, &tmp) == NULL)
-    return (time_t)-1;
-  *t = tmp;
-  t->tm_isdst = dst;
-  return t1;
+    if (_gmtime64_r(&t2, &tmp) == NULL)
+        return -1;
+    *t = tmp;
+    t->tm_isdst = dst;
+    return t1;
 }
 
@@ -68 +79 @@
 }
 
+time64_t __mktime64(struct tm *t)
+{
+  time64_t x;
+  time64_t r;
+
+  x = _day(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday);
+  /* 719528 = day (1970, 1, 1) */
+  r = (x - 719528) * 24 * 60 * 60;
+
+  /* This expression is not checked for overflow. */
+  x = t->tm_sec
+      + 60 * t->tm_min
+      + 60 *60 * t->tm_hour;
+
+  r += x;
+  return r;
+}
+
 /* mkstd.awk: NOUNDERSCORE(mktime) */
 unsigned long _mktime (struct tm *t)