time/mktime.c

   1 /* Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Paul Eggert (eggert@twinsun.com).
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 /* Define this to have a standalone program to test this implementation of
  21    mktime.  */
  22 /* #define DEBUG 1 */
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #ifdef _LIBC
  29 # define HAVE_LIMITS_H 1
  30 # define HAVE_LOCALTIME_R 1
  31 # define STDC_HEADERS 1
  32 #endif
  33
  34 /* Assume that leap seconds are possible, unless told otherwise.
  35    If the host has a `zic' command with a `-L leapsecondfilename' option,
  36    then it supports leap seconds; otherwise it probably doesn't.  */
  37 #ifndef LEAP_SECONDS_POSSIBLE
  38 # define LEAP_SECONDS_POSSIBLE 1
  39 #endif
  40
  41 #include <sys/types.h>          /* Some systems define `time_t' here.  */
  42 #include <time.h>
  43
  44 #if HAVE_LIMITS_H
  45 # include <limits.h>
  46 #endif
  47
  48 #if DEBUG
  49 # include <stdio.h>
  50 # if STDC_HEADERS
  51 #  include <stdlib.h>
  52 # endif
  53 /* Make it work even if the system's libc has its own mktime routine.  */
  54 # define mktime my_mktime
  55 #endif /* DEBUG */
  56
  57 #ifndef __P
  58 # if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
  59 #  define __P(args) args
  60 # else
  61 #  define __P(args) ()
  62 # endif  /* GCC.  */
  63 #endif  /* Not __P.  */
  64
  65 #ifndef CHAR_BIT
  66 # define CHAR_BIT 8
  67 #endif
  68
  69 #ifndef INT_MIN
  70 # define INT_MIN (~0 << (sizeof (int) * CHAR_BIT - 1))
  71 #endif
  72 #ifndef INT_MAX
  73 # define INT_MAX (~0 - INT_MIN)
  74 #endif
  75
  76 #ifndef TIME_T_MIN
  77 /* The outer cast to time_t works around a bug in Cray C 5.0.3.0.  */
  78 # define TIME_T_MIN ((time_t) \
  79                     (0 < (time_t) -1 ? (time_t) 0 \
  80                      : ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1)))
  81 #endif
  82 #ifndef TIME_T_MAX
  83 # define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
  84 #endif
  85
  86 #define TM_YEAR_BASE 1900
  87 #define EPOCH_YEAR 1970
  88
  89 #ifndef __isleap
  90 /* Nonzero if YEAR is a leap year (every 4 years,
  91    except every 100th isn't, and every 400th is).  */
  92 # define __isleap(year) \
  93   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
  94 #endif
  95
  96 /* How many days come before each month (0-12).  */
  97 const unsigned short int __mon_yday[2][13] =
  98   {
  99     /* Normal years.  */
 100     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
 101     /* Leap years.  */
 102     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
 103   };
 104
 105 static time_t ydhms_tm_diff __P ((int, int, int, int, int, const struct tm *));
 106 time_t __mktime_internal __P ((struct tm *,
 107                                struct tm *(*) (const time_t *, struct tm *),
 108                                time_t *));
 109
 110
 111 #ifdef _LIBC
 112 # define localtime_r __localtime_r
 113 #else
 114 # if ! HAVE_LOCALTIME_R && ! defined localtime_r
 115 /* Approximate localtime_r as best we can in its absence.  */
 116 #  define localtime_r my_mktime_localtime_r
 117 static struct tm *localtime_r __P ((const time_t *, struct tm *));
 118 static struct tm *
 119 localtime_r (t, tp)
 120      const time_t *t;
 121      struct tm *tp;
 122 {
 123   struct tm *l = localtime (t);
 124   if (! l)
 125     return 0;
 126   *tp = *l;
 127   return tp;
 128 }
 129 # endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
 130 #endif /* ! _LIBC */
 131
 132
 133 /* Yield the difference between (YEAR-YDAY HOUR:MIN:SEC) and (*TP),
 134    measured in seconds, ignoring leap seconds.
 135    YEAR uses the same numbering as TM->tm_year.
 136    All values are in range, except possibly YEAR.
 137    If overflow occurs, yield the low order bits of the correct answer.  */
 138 static time_t
 139 ydhms_tm_diff (year, yday, hour, min, sec, tp)
 140      int year, yday, hour, min, sec;
 141      const struct tm *tp;
 142 {
 143   /* Compute intervening leap days correctly even if year is negative.
 144      Take care to avoid int overflow.  time_t overflow is OK, since
 145      only the low order bits of the correct time_t answer are needed.
 146      Don't convert to time_t until after all divisions are done, since
 147      time_t might be unsigned.  */
 148   int a4 = (year >> 2) + (TM_YEAR_BASE >> 2) - ! (year & 3);
 149   int b4 = (tp->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (tp->tm_year & 3);
 150   int a100 = a4 / 25 - (a4 % 25 < 0);
 151   int b100 = b4 / 25 - (b4 % 25 < 0);
 152   int a400 = a100 >> 2;
 153   int b400 = b100 >> 2;
 154   int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
 155   time_t years = year - (time_t) tp->tm_year;
 156   time_t days = (365 * years + intervening_leap_days
 157                  + (yday - tp->tm_yday));
 158   return (60 * (60 * (24 * days + (hour - tp->tm_hour))
 159                 + (min - tp->tm_min))
 160           + (sec - tp->tm_sec));
 161 }
 162
 163
 164 static time_t localtime_offset;
 165
 166 /* Convert *TP to a time_t value.  */
 167 time_t
 168 mktime (tp)
 169      struct tm *tp;
 170 {
 171 #ifdef _LIBC
 172   /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
 173      time zone names contained in the external variable `tzname' shall
 174      be set as if the tzset() function had been called.  */
 175   __tzset ();
 176 #endif
 177
 178   return __mktime_internal (tp, localtime_r, &localtime_offset);
 179 }
 180
 181 /* Convert *TP to a time_t value, inverting
 182    the monotonic and mostly-unit-linear conversion function CONVERT.
 183    Use *OFFSET to keep track of a guess at the offset of the result,
 184    compared to what the result would be for UTC without leap seconds.
 185    If *OFFSET's guess is correct, only one CONVERT call is needed.  */
 186 time_t
 187 __mktime_internal (tp, convert, offset)
 188      struct tm *tp;
 189      struct tm *(*convert) __P ((const time_t *, struct tm *));
 190      time_t *offset;
 191 {
 192   time_t t, dt, t0;
 193   struct tm tm;
 194
 195   /* The maximum number of probes (calls to CONVERT) should be enough
 196      to handle any combinations of time zone rule changes, solar time,
 197      and leap seconds.  Posix.1 prohibits leap seconds, but some hosts
 198      have them anyway.  */
 199   int remaining_probes = 4;
 200
 201   /* Time requested.  Copy it in case CONVERT modifies *TP; this can
 202      occur if TP is localtime's returned value and CONVERT is localtime.  */
 203   int sec = tp->tm_sec;
 204   int min = tp->tm_min;
 205   int hour = tp->tm_hour;
 206   int mday = tp->tm_mday;
 207   int mon = tp->tm_mon;
 208   int year_requested = tp->tm_year;
 209   int isdst = tp->tm_isdst;
 210
 211   /* Ensure that mon is in range, and set year accordingly.  */
 212   int mon_remainder = mon % 12;
 213   int negative_mon_remainder = mon_remainder < 0;
 214   int mon_years = mon / 12 - negative_mon_remainder;
 215   int year = year_requested + mon_years;
 216
 217   /* The other values need not be in range:
 218      the remaining code handles minor overflows correctly,
 219      assuming int and time_t arithmetic wraps around.
 220      Major overflows are caught at the end.  */
 221
 222   /* Calculate day of year from year, month, and day of month.
 223      The result need not be in range.  */
 224   int yday = ((__mon_yday[__isleap (year + TM_YEAR_BASE)]
 225                [mon_remainder + 12 * negative_mon_remainder])
 226               + mday - 1);
 227
 228 #if LEAP_SECONDS_POSSIBLE
 229   /* Handle out-of-range seconds specially,
 230      since ydhms_tm_diff assumes every minute has 60 seconds.  */
 231   int sec_requested = sec;
 232   if (sec < 0)
 233     sec = 0;
 234   if (59 < sec)
 235     sec = 59;
 236 #endif
 237
 238   /* Invert CONVERT by probing.  First assume the same offset as last time.
 239      Then repeatedly use the error to improve the guess.  */
 240
 241   tm.tm_year = EPOCH_YEAR - TM_YEAR_BASE;
 242   tm.tm_yday = tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
 243   t0 = ydhms_tm_diff (year, yday, hour, min, sec, &tm);
 244
 245   for (t = t0 + *offset;
 246        (dt = ydhms_tm_diff (year, yday, hour, min, sec, (*convert) (&t, &tm)));
 247        t += dt)
 248     if (--remaining_probes == 0)
 249       return -1;
 250
 251   /* Check whether tm.tm_isdst has the requested value, if any.  */
 252   if (0 <= isdst && 0 <= tm.tm_isdst)
 253     {
 254       int dst_diff = (isdst != 0) - (tm.tm_isdst != 0);
 255       if (dst_diff)
 256         {
 257           /* Move two hours in the direction indicated by the disagreement,
 258              probe some more, and switch to a new time if found.
 259              The largest known fallback due to daylight savings is two hours:
 260              once, in Newfoundland, 1988-10-30 02:00 -> 00:00.  */
 261           time_t ot = t - 2 * 60 * 60 * dst_diff;
 262           while (--remaining_probes != 0)
 263             {
 264               struct tm otm;
 265               if (! (dt = ydhms_tm_diff (year, yday, hour, min, sec,
 266                                          (*convert) (&ot, &otm))))
 267                 {
 268                   t = ot;
 269                   tm = otm;
 270                   break;
 271                 }
 272               if ((ot += dt) == t)
 273                 break;  /* Avoid a redundant probe.  */
 274             }
 275         }
 276     }
 277
 278   *offset = t - t0;
 279
 280 #if LEAP_SECONDS_POSSIBLE
 281   if (sec_requested != tm.tm_sec)
 282     {
 283       /* Adjust time to reflect the tm_sec requested, not the normalized value.
 284          Also, repair any damage from a false match due to a leap second.  */
 285       t += sec_requested - sec + (sec == 0 && tm.tm_sec == 60);
 286       (*convert) (&t, &tm);
 287     }
 288 #endif
 289
 290   if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
 291     {
 292       /* time_t isn't large enough to rule out overflows in ydhms_tm_diff,
 293          so check for major overflows.  A gross check suffices,
 294          since if t has overflowed, it is off by a multiple of
 295          TIME_T_MAX - TIME_T_MIN + 1.  So ignore any component of
 296          the difference that is bounded by a small value.  */
 297
 298       double dyear = (double) year_requested + mon_years - tm.tm_year;
 299       double dday = 366 * dyear + mday;
 300       double dsec = 60 * (60 * (24 * dday + hour) + min) + sec_requested;
 301
 302       if (TIME_T_MAX / 3 - TIME_T_MIN / 3 < (dsec < 0 ? - dsec : dsec))
 303         return -1;
 304     }
 305
 306   *tp = tm;
 307   return t;
 308 }
 309
 310 #ifdef weak_alias
 311 weak_alias (mktime, timelocal)
 312 #endif
 313 \f
 314 #if DEBUG
 315
 316 static int
 317 not_equal_tm (a, b)
 318      struct tm *a;
 319      struct tm *b;
 320 {
 321   return ((a->tm_sec ^ b->tm_sec)
 322           | (a->tm_min ^ b->tm_min)
 323           | (a->tm_hour ^ b->tm_hour)
 324           | (a->tm_mday ^ b->tm_mday)
 325           | (a->tm_mon ^ b->tm_mon)
 326           | (a->tm_year ^ b->tm_year)
 327           | (a->tm_mday ^ b->tm_mday)
 328           | (a->tm_yday ^ b->tm_yday)
 329           | (a->tm_isdst ^ b->tm_isdst));
 330 }
 331
 332 static void
 333 print_tm (tp)
 334      struct tm *tp;
 335 {
 336   printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
 337           tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
 338           tp->tm_hour, tp->tm_min, tp->tm_sec,
 339           tp->tm_yday, tp->tm_wday, tp->tm_isdst);
 340 }
 341
 342 static int
 343 check_result (tk, tmk, tl, tml)
 344      time_t tk;
 345      struct tm tmk;
 346      time_t tl;
 347      struct tm tml;
 348 {
 349   if (tk != tl || not_equal_tm (&tmk, &tml))
 350     {
 351       printf ("mktime (");
 352       print_tm (&tmk);
 353       printf (")\nyields (");
 354       print_tm (&tml);
 355       printf (") == %ld, should be %ld\n", (long) tl, (long) tk);
 356       return 1;
 357     }
 358
 359   return 0;
 360 }
 361
 362 int
 363 main (argc, argv)
 364      int argc;
 365      char **argv;
 366 {
 367   int status = 0;
 368   struct tm tm, tmk, tml;
 369   time_t tk, tl;
 370   char trailer;
 371
 372   if ((argc == 3 || argc == 4)
 373       && (sscanf (argv[1], "%d-%d-%d%c",
 374                   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
 375           == 3)
 376       && (sscanf (argv[2], "%d:%d:%d%c",
 377                   &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
 378           == 3))
 379     {
 380       tm.tm_year -= TM_YEAR_BASE;
 381       tm.tm_mon--;
 382       tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
 383       tmk = tm;
 384       tl = mktime (&tmk);
 385       tml = *localtime (&tl);
 386       printf ("mktime returns %ld == ", (long) tl);
 387       print_tm (&tmk);
 388       printf ("\n");
 389       status = check_result (tl, tmk, tl, tml);
 390     }
 391   else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
 392     {
 393       time_t from = atol (argv[1]);
 394       time_t by = atol (argv[2]);
 395       time_t to = atol (argv[3]);
 396
 397       if (argc == 4)
 398         for (tl = from; tl <= to; tl += by)
 399           {
 400             tml = *localtime (&tl);
 401             tmk = tml;
 402             tk = mktime (&tmk);
 403             status |= check_result (tk, tmk, tl, tml);
 404           }
 405       else
 406         for (tl = from; tl <= to; tl += by)
 407           {
 408             /* Null benchmark.  */
 409             tml = *localtime (&tl);
 410             tmk = tml;
 411             tk = tl;
 412             status |= check_result (tk, tmk, tl, tml);
 413           }
 414     }
 415   else
 416     printf ("Usage:\
 417 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
 418 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
 419 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
 420             argv[0], argv[0], argv[0]);
 421
 422   return status;
 423 }
 424
 425 #endif /* DEBUG */
 426 \f
 427 /*
 428 Local Variables:
 429 compile-command: "gcc -DDEBUG=1 -Wall -O -g mktime.c -o mktime"
 430 End:
 431 */