Declare chown manually.

[gnulib.git] / lib / mktime.c

diff --git a/lib/mktime.c b/lib/mktime.c
index b63fa05..1feb404 100644 (file)
--- a/lib/mktime.c
+++ b/lib/mktime.c
@@ -1,5 +1,5 @@
 /* mktime: convert a `struct tm' to a time_t value
-   Copyright (C) 1993-1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1993-1998, 1999 Free Software Foundation, Inc.
    Contributed by Paul Eggert (eggert@twinsun.com).
 
    NOTE: The canonical source of this file is maintained with the GNU C Library.
@@ -57,7 +57,7 @@
 #endif /* DEBUG */
 
 #ifndef __P
-# if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
+# if defined __GNUC__ || (defined __STDC__ && __STDC__)
 #  define __P(args) args
 # else
 #  define __P(args) ()
@@ -126,9 +126,7 @@ time_t __mktime_internal __P ((struct tm *,
    are buggy.  */
 static struct tm *my_mktime_localtime_r __P ((const time_t *, struct tm *));
 static struct tm *
-my_mktime_localtime_r (t, tp)
-     const time_t *t;
-     struct tm *tp;
+my_mktime_localtime_r (const time_t *t, struct tm *tp)
 {
   struct tm *l = localtime (t);
   if (! l)
@@ -146,9 +144,8 @@ my_mktime_localtime_r (t, tp)
    If TP is null, return a nonzero value.
    If overflow occurs, yield the low order bits of the correct answer.  */
 static time_t
-ydhms_tm_diff (year, yday, hour, min, sec, tp)
-     int year, yday, hour, min, sec;
-     const struct tm *tp;
+ydhms_tm_diff (int year, int yday, int hour, int min, int sec,
+              const struct tm *tp)
 {
   if (!tp)
     return 1;
@@ -180,8 +177,7 @@ static time_t localtime_offset;
 
 /* Convert *TP to a time_t value.  */
 time_t
-mktime (tp)
-     struct tm *tp;
+mktime (struct tm *tp)
 {
 #ifdef _LIBC
   /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
@@ -197,10 +193,8 @@ mktime (tp)
    If *T is out of range for conversion, adjust it so that
    it is the nearest in-range value and then convert that.  */
 static struct tm *
-ranged_convert (convert, t, tp)
-     struct tm *(*convert) __P ((const time_t *, struct tm *));
-     time_t *t;
-     struct tm *tp;
+ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
+               time_t *t, struct tm *tp)
 {
   struct tm *r;
 
@@ -247,10 +241,9 @@ ranged_convert (convert, t, tp)
    compared to what the result would be for UTC without leap seconds.
    If *OFFSET's guess is correct, only one CONVERT call is needed.  */
 time_t
-__mktime_internal (tp, convert, offset)
-     struct tm *tp;
-     struct tm *(*convert) __P ((const time_t *, struct tm *));
-     time_t *offset;
+__mktime_internal (struct tm *tp,
+                  struct tm *(*convert) (const time_t *, struct tm *),
+                  time_t *offset)
 {
   time_t t, dt, t0, t1, t2;
   struct tm tm;
@@ -325,28 +318,32 @@ __mktime_internal (tp, convert, offset)
 
   /* If we have a match, check whether tm.tm_isdst has the requested
      value, if any.  */
-  if (dt == 0 && 0 <= isdst && 0 <= tm.tm_isdst)
+  if (dt == 0 && isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
     {
-      int dst_diff = (isdst != 0) - (tm.tm_isdst != 0);
-      if (dst_diff)
+      /* tm.tm_isdst has the wrong value.  Look for a neighboring
+        time with the right value, and use its UTC offset.
+        Heuristic: probe the previous three calendar quarters (approximately),
+        looking for the desired isdst.  This isn't perfect,
+        but it's good enough in practice.  */
+      int quarter = 7889238; /* seconds per average 1/4 Gregorian year */
+      int i;
+
+      /* If we're too close to the time_t limit, look in future quarters.  */
+      if (t < TIME_T_MIN + 3 * quarter)
+       quarter = -quarter;
+
+      for (i = 1; i <= 3; i++)
        {
-         /* Move two hours in the direction indicated by the disagreement,
-            probe some more, and switch to a new time if found.
-            The largest known fallback due to daylight savings is two hours:
-            once, in Newfoundland, 1988-10-30 02:00 -> 00:00.  */
-         time_t ot = t - 2 * 60 * 60 * dst_diff;
-         while (--remaining_probes != 0)
+         time_t ot = t - i * quarter;
+         struct tm otm;
+         ranged_convert (convert, &ot, &otm);
+         if (otm.tm_isdst == isdst)
            {
-             struct tm otm;
-             if (! (dt = ydhms_tm_diff (year, yday, hour, min, sec,
-                                        ranged_convert (convert, &ot, &otm))))
-               {
-                 t = ot;
-                 tm = otm;
-                 break;
-               }
-             if ((ot += dt) == t)
-               break;  /* Avoid a redundant probe.  */
+             /* We found the desired tm_isdst.
+                Extrapolate back to the desired time.  */
+             t = ot + ydhms_tm_diff (year, yday, hour, min, sec, &otm);
+             ranged_convert (convert, &t, &tm);
+             break;
            }
        }
     }