Update from FSF.

1 files changed, 153 insertions, 68 deletions

diff --git a/lib/mktime.c b/lib/mktime.c
index a96ff8939..f759c29bb 100644
--- a/lib/mktime.c
+++ b/lib/mktime.c
@@ -1,8 +1,8 @@
 /* Copyright (C) 1993, 1994, 1995, 1996, 1997 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.  Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+   NOTE: The canonical source of this file is maintained with the GNU C Library.
+   Bugs can be reported to bug-glibc@prep.ai.mit.edu.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
@@ -15,15 +15,16 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+   USA.  */
 
 /* Define this to have a standalone program to test this implementation of
    mktime.  */
 /* #define DEBUG 1 */
 
 #ifdef HAVE_CONFIG_H
-#include <config.h>
+# include <config.h>
 #endif
 
 #ifdef _LIBC
@@ -36,52 +37,52 @@
    If the host has a `zic' command with a `-L leapsecondfilename' option,
    then it supports leap seconds; otherwise it probably doesn't.  */
 #ifndef LEAP_SECONDS_POSSIBLE
-#define LEAP_SECONDS_POSSIBLE 1
+# define LEAP_SECONDS_POSSIBLE 1
 #endif
 
 #include <sys/types.h>		/* Some systems define `time_t' here.  */
 #include <time.h>
 
 #if HAVE_LIMITS_H
-#include <limits.h>
+# include <limits.h>
 #endif
 
 #if DEBUG
-#include <stdio.h>
-#if STDC_HEADERS
-#include <stdlib.h>
-#endif
+# include <stdio.h>
+# if STDC_HEADERS
+#  include <stdlib.h>
+# endif
 /* Make it work even if the system's libc has its own mktime routine.  */
-#define mktime my_mktime
+# define mktime my_mktime
 #endif /* DEBUG */
 
 #ifndef __P
-#if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
-#define __P(args) args
-#else
-#define __P(args) ()
-#endif  /* GCC.  */
+# if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
+#  define __P(args) args
+# else
+#  define __P(args) ()
+# endif  /* GCC.  */
 #endif  /* Not __P.  */
 
 #ifndef CHAR_BIT
-#define CHAR_BIT 8
+# define CHAR_BIT 8
 #endif
 
 #ifndef INT_MIN
-#define INT_MIN (~0 << (sizeof (int) * CHAR_BIT - 1))
+# define INT_MIN (~0 << (sizeof (int) * CHAR_BIT - 1))
 #endif
 #ifndef INT_MAX
-#define INT_MAX (~0 - INT_MIN)
+# define INT_MAX (~0 - INT_MIN)
 #endif
 
 #ifndef TIME_T_MIN
 /* The outer cast to time_t works around a bug in Cray C 5.0.3.0.  */
-#define TIME_T_MIN ((time_t) \
+# define TIME_T_MIN ((time_t) \
 		    (0 < (time_t) -1 ? (time_t) 0 \
 		     : ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1)))
 #endif
 #ifndef TIME_T_MAX
-#define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
+# define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
 #endif
 
 #define TM_YEAR_BASE 1900
@@ -90,7 +91,7 @@
 #ifndef __isleap
 /* Nonzero if YEAR is a leap year (every 4 years,
    except every 100th isn't, and every 400th is).  */
-#define	__isleap(year)	\
+# define __isleap(year)	\
   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
 #endif
 
@@ -103,6 +104,9 @@ const unsigned short int __mon_yday[2][13] =
     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
   };
 
+static struct tm *ranged_convert __P ((struct tm *(*) __P ((const time_t *,
+							    struct tm *)),
+				       time_t *, struct tm *));
 static time_t ydhms_tm_diff __P ((int, int, int, int, int, const struct tm *));
 time_t __mktime_internal __P ((struct tm *,
 			       struct tm *(*) (const time_t *, struct tm *),
@@ -110,11 +114,11 @@ time_t __mktime_internal __P ((struct tm *,
 
 
 #ifdef _LIBC
-#define localtime_r __localtime_r
+# define localtime_r __localtime_r
 #else
-#if ! HAVE_LOCALTIME_R && ! defined (localtime_r)
+# if ! HAVE_LOCALTIME_R && ! defined localtime_r
 /* Approximate localtime_r as best we can in its absence.  */
-#define localtime_r my_localtime_r
+#  define localtime_r my_mktime_localtime_r
 static struct tm *localtime_r __P ((const time_t *, struct tm *));
 static struct tm *
 localtime_r (t, tp)
@@ -127,7 +131,7 @@ localtime_r (t, tp)
   *tp = *l;
   return tp;
 }
-#endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
+# endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
 #endif /* ! _LIBC */
 
 
@@ -135,30 +139,36 @@ localtime_r (t, tp)
    measured in seconds, ignoring leap seconds.
    YEAR uses the same numbering as TM->tm_year.
    All values are in range, except possibly YEAR.
+   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;
 {
-  /* Compute intervening leap days correctly even if year is negative.
-     Take care to avoid int overflow.  time_t overflow is OK, since
-     only the low order bits of the correct time_t answer are needed.
-     Don't convert to time_t until after all divisions are done, since
-     time_t might be unsigned.  */
-  int a4 = (year >> 2) + (TM_YEAR_BASE >> 2) - ! (year & 3);
-  int b4 = (tp->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (tp->tm_year & 3);
-  int a100 = a4 / 25 - (a4 % 25 < 0);
-  int b100 = b4 / 25 - (b4 % 25 < 0);
-  int a400 = a100 >> 2;
-  int b400 = b100 >> 2;
-  int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
-  time_t years = year - (time_t) tp->tm_year;
-  time_t days = (365 * years + intervening_leap_days
-		 + (yday - tp->tm_yday));
-  return (60 * (60 * (24 * days + (hour - tp->tm_hour))
-		+ (min - tp->tm_min))
-	  + (sec - tp->tm_sec));
+  if (!tp)
+    return 1;
+  else
+    {
+      /* Compute intervening leap days correctly even if year is negative.
+	 Take care to avoid int overflow.  time_t overflow is OK, since
+	 only the low order bits of the correct time_t answer are needed.
+	 Don't convert to time_t until after all divisions are done, since
+	 time_t might be unsigned.  */
+      int a4 = (year >> 2) + (TM_YEAR_BASE >> 2) - ! (year & 3);
+      int b4 = (tp->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (tp->tm_year & 3);
+      int a100 = a4 / 25 - (a4 % 25 < 0);
+      int b100 = b4 / 25 - (b4 % 25 < 0);
+      int a400 = a100 >> 2;
+      int b400 = b100 >> 2;
+      int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
+      time_t years = year - (time_t) tp->tm_year;
+      time_t days = (365 * years + intervening_leap_days
+		     + (yday - tp->tm_yday));
+      return (60 * (60 * (24 * days + (hour - tp->tm_hour))
+		    + (min - tp->tm_min))
+	      + (sec - tp->tm_sec));
+    }
 }
 
 
@@ -179,6 +189,54 @@ mktime (tp)
   return __mktime_internal (tp, localtime_r, &localtime_offset);
 }
 
+/* Use CONVERT to convert *T to a broken down time in *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;
+{
+  struct tm *r;
+
+  if (! (r = (*convert) (t, tp)) && *t)
+    {
+      time_t bad = *t;
+      time_t ok = 0;
+      struct tm tm;
+
+      /* BAD is a known unconvertible time_t, and OK is a known good one.
+	 Use binary search to narrow the range between BAD and OK until
+	 they differ by 1.  */
+      while (bad != ok + (bad < 0 ? -1 : 1))
+	{
+	  time_t mid = *t = (bad < 0
+			     ? bad + ((ok - bad) >> 1)
+			     : ok + ((bad - ok) >> 1));
+	  if ((r = (*convert) (t, tp)))
+	    {
+	      tm = *r;
+	      ok = mid;
+	    }
+	  else
+	    bad = mid;
+	}
+
+      if (!r && ok)
+	{
+	  /* The last conversion attempt failed;
+	     revert to the most recent successful attempt.  */
+	  *t = ok;
+	  *tp = tm;
+	  r = tp;
+	}
+    }
+
+  return r;
+}
+
+
 /* Convert *TP to a time_t value, inverting
    the monotonic and mostly-unit-linear conversion function CONVERT.
    Use *OFFSET to keep track of a guess at the offset of the result,
@@ -195,7 +253,7 @@ __mktime_internal (tp, convert, offset)
 
   /* The maximum number of probes (calls to CONVERT) should be enough
      to handle any combinations of time zone rule changes, solar time,
-     and leap seconds.  Posix.1 prohibits leap seconds, but some hosts
+     and leap seconds.  POSIX.1 prohibits leap seconds, but some hosts
      have them anyway.  */
   int remaining_probes = 4;
 
@@ -244,7 +302,8 @@ __mktime_internal (tp, convert, offset)
   t0 = ydhms_tm_diff (year, yday, hour, min, sec, &tm);
 
   for (t = t0 + *offset;
-       (dt = ydhms_tm_diff (year, yday, hour, min, sec, (*convert) (&t, &tm)));
+       (dt = ydhms_tm_diff (year, yday, hour, min, sec,
+			    ranged_convert (convert, &t, &tm)));
        t += dt)
     if (--remaining_probes == 0)
       return -1;
@@ -264,7 +323,7 @@ __mktime_internal (tp, convert, offset)
 	    {
 	      struct tm otm;
 	      if (! (dt = ydhms_tm_diff (year, yday, hour, min, sec,
-					 (*convert) (&ot, &otm))))
+					 ranged_convert (convert, &ot, &otm))))
 		{
 		  t = ot;
 		  tm = otm;
@@ -284,7 +343,8 @@ __mktime_internal (tp, convert, offset)
       /* Adjust time to reflect the tm_sec requested, not the normalized value.
 	 Also, repair any damage from a false match due to a leap second.  */
       t += sec_requested - sec + (sec == 0 && tm.tm_sec == 60);
-      (*convert) (&t, &tm);
+      if (! (*convert) (&t, &tm))
+	return -1;
     }
 #endif
 
@@ -334,25 +394,28 @@ static void
 print_tm (tp)
      struct tm *tp;
 {
-  printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
-	  tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
-	  tp->tm_hour, tp->tm_min, tp->tm_sec,
-	  tp->tm_yday, tp->tm_wday, tp->tm_isdst);
+  if (tp)
+    printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
+	    tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
+	    tp->tm_hour, tp->tm_min, tp->tm_sec,
+	    tp->tm_yday, tp->tm_wday, tp->tm_isdst);
+  else
+    printf ("0");
 }
 
 static int
-check_result (tk, tmk, tl, tml)
+check_result (tk, tmk, tl, lt)
      time_t tk;
      struct tm tmk;
      time_t tl;
-     struct tm tml;
+     struct tm *lt;
 {
-  if (tk != tl || not_equal_tm (&tmk, &tml))
+  if (tk != tl || !lt || not_equal_tm (&tmk, lt))
     {
       printf ("mktime (");
       print_tm (&tmk);
       printf (")\nyields (");
-      print_tm (&tml);
+      print_tm (lt);
       printf (") == %ld, should be %ld\n", (long) tl, (long) tk);
       return 1;
     }
@@ -367,6 +430,7 @@ main (argc, argv)
 {
   int status = 0;
   struct tm tm, tmk, tml;
+  struct tm *lt;
   time_t tk, tl;
   char trailer;
 
@@ -383,11 +447,16 @@ main (argc, argv)
       tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
       tmk = tm;
       tl = mktime (&tmk);
-      tml = *localtime (&tl);
+      lt = localtime (&tl);
+      if (lt)
+	{
+	  tml = *lt;
+	  lt = &tml;
+	}
       printf ("mktime returns %ld == ", (long) tl);
       print_tm (&tmk);
       printf ("\n");
-      status = check_result (tl, tmk, tl, tml);
+      status = check_result (tl, tmk, tl, lt);
     }
   else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
     {
@@ -398,19 +467,35 @@ main (argc, argv)
       if (argc == 4)
 	for (tl = from; tl <= to; tl += by)
 	  {
-	    tml = *localtime (&tl);
-	    tmk = tml;
-	    tk = mktime (&tmk);
-	    status |= check_result (tk, tmk, tl, tml);
+	    lt = localtime (&tl);
+	    if (lt)
+	      {
+		tmk = tml = *lt;
+		tk = mktime (&tmk);
+		status |= check_result (tk, tmk, tl, tml);
+	      }
+	    else
+	      {
+		printf ("localtime (%ld) yields 0\n", (long) tl);
+		status = 1;
+	      }
 	  }
       else
 	for (tl = from; tl <= to; tl += by)
 	  {
 	    /* Null benchmark.  */
-	    tml = *localtime (&tl);
-	    tmk = tml;
-	    tk = tl;
-	    status |= check_result (tk, tmk, tl, tml);
+	    lt = localtime (&tl);
+	    if (lt)
+	      {
+		tmk = tml = *lt;
+		tk = tl;
+		status |= check_result (tk, tmk, tl, tml);
+	      }
+	    else
+	      {
+		printf ("localtime (%ld) yields 0\n", (long) tl);
+		status = 1;
+	      }
 	  }
     }
   else
@@ -427,6 +512,6 @@ main (argc, argv)
 
 /*
 Local Variables:
-compile-command: "gcc -DDEBUG=1 -Wall -O -g mktime.c -o mktime"
+compile-command: "gcc -DDEBUG -D__EXTENSIONS__ -DHAVE_LIMITS_H -DHAVE_LOCALTIME_R -DSTDC_HEADERS -Wall -W -O -g mktime.c -o mktime"
 End:
 */