lib/mktime.c

   1 /* Convert a `struct tm' to a time_t value.
   2    Copyright (C) 1993-1999, 2002, 2003 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Paul Eggert (eggert@twinsun.com).
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation,
  18    Inc., 59 Temple Place - Suite 330, 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 STDC_HEADERS 1
  30 #endif
  31
  32 /* Assume that leap seconds are possible, unless told otherwise.
  33    If the host has a `zic' command with a `-L leapsecondfilename' option,
  34    then it supports leap seconds; otherwise it probably doesn't.  */
  35 #ifndef LEAP_SECONDS_POSSIBLE
  36 # define LEAP_SECONDS_POSSIBLE 1
  37 #endif
  38
  39 #include <sys/types.h>          /* Some systems define `time_t' here.  */
  40 #include <time.h>
  41
  42 #include <limits.h>
  43
  44 #if DEBUG
  45 # include <stdio.h>
  46 # if STDC_HEADERS
  47 #  include <stdlib.h>
  48 #  include <string.h>
  49 # endif
  50 /* Make it work even if the system's libc has its own mktime routine.  */
  51 # define mktime my_mktime
  52 #endif /* DEBUG */
  53
  54 /* The extra casts work around common compiler bugs.  */
  55 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
  56 /* The outer cast is needed to work around a bug in Cray C 5.0.3.0.
  57    It is necessary at least when t == time_t.  */
  58 #define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \
  59                               ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0))
  60 #define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t)))
  61
  62 #ifndef TIME_T_MIN
  63 # define TIME_T_MIN TYPE_MINIMUM (time_t)
  64 #endif
  65 #ifndef TIME_T_MAX
  66 # define TIME_T_MAX TYPE_MAXIMUM (time_t)
  67 #endif
  68
  69 #define TM_YEAR_BASE 1900
  70 #define EPOCH_YEAR 1970
  71
  72 #ifndef __isleap
  73 /* Nonzero if YEAR is a leap year (every 4 years,
  74    except every 100th isn't, and every 400th is).  */
  75 # define __isleap(year) \
  76   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
  77 #endif
  78
  79 /* How many days come before each month (0-12).  */
  80 #ifndef _LIBC
  81 static
  82 #endif
  83 const unsigned short int __mon_yday[2][13] =
  84   {
  85     /* Normal years.  */
  86     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
  87     /* Leap years.  */
  88     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
  89   };
  90
  91
  92 #ifdef _LIBC
  93 # define my_mktime_localtime_r __localtime_r
  94 #else
  95 /* If we're a mktime substitute in a GNU program, then prefer
  96    localtime to localtime_r, since many localtime_r implementations
  97    are buggy.  */
  98 static struct tm *
  99 my_mktime_localtime_r (const time_t *t, struct tm *tp)
 100 {
 101   struct tm *l = localtime (t);
 102   if (! l)
 103     return 0;
 104   *tp = *l;
 105   return tp;
 106 }
 107 #endif /* ! _LIBC */
 108
 109
 110 /* Yield the difference between (YEAR-YDAY HOUR:MIN:SEC) and (*TP),
 111    measured in seconds, ignoring leap seconds.
 112    YEAR uses the same numbering as TM->tm_year.
 113    All values are in range, except possibly YEAR.
 114    If TP is null, return a nonzero value.
 115    If overflow occurs, yield the low order bits of the correct answer.  */
 116 static time_t
 117 ydhms_tm_diff (int year, int yday, int hour, int min, int sec,
 118                const struct tm *tp)
 119 {
 120   if (!tp)
 121     return 1;
 122   else
 123     {
 124       /* Compute intervening leap days correctly even if year is negative.
 125          Take care to avoid int overflow.  time_t overflow is OK, since
 126          only the low order bits of the correct time_t answer are needed.
 127          Don't convert to time_t until after all divisions are done, since
 128          time_t might be unsigned.  */
 129       int a4 = (year >> 2) + (TM_YEAR_BASE >> 2) - ! (year & 3);
 130       int b4 = (tp->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (tp->tm_year & 3);
 131       int a100 = a4 / 25 - (a4 % 25 < 0);
 132       int b100 = b4 / 25 - (b4 % 25 < 0);
 133       int a400 = a100 >> 2;
 134       int b400 = b100 >> 2;
 135       int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
 136       time_t years = year - (time_t) tp->tm_year;
 137       time_t days = (365 * years + intervening_leap_days
 138                      + (yday - tp->tm_yday));
 139       return (60 * (60 * (24 * days + (hour - tp->tm_hour))
 140                     + (min - tp->tm_min))
 141               + (sec - tp->tm_sec));
 142     }
 143 }
 144
 145 /* Use CONVERT to convert *T to a broken down time in *TP.
 146    If *T is out of range for conversion, adjust it so that
 147    it is the nearest in-range value and then convert that.  */
 148 static struct tm *
 149 ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
 150                 time_t *t, struct tm *tp)
 151 {
 152   struct tm *r;
 153
 154   if (! (r = (*convert) (t, tp)) && *t)
 155     {
 156       time_t bad = *t;
 157       time_t ok = 0;
 158       struct tm tm;
 159
 160       /* BAD is a known unconvertible time_t, and OK is a known good one.
 161          Use binary search to narrow the range between BAD and OK until
 162          they differ by 1.  */
 163       while (bad != ok + (bad < 0 ? -1 : 1))
 164         {
 165           time_t mid = *t = (bad < 0
 166                              ? bad + ((ok - bad) >> 1)
 167                              : ok + ((bad - ok) >> 1));
 168           if ((r = (*convert) (t, tp)))
 169             {
 170               tm = *r;
 171               ok = mid;
 172             }
 173           else
 174             bad = mid;
 175         }
 176
 177       if (!r && ok)
 178         {
 179           /* The last conversion attempt failed;
 180              revert to the most recent successful attempt.  */
 181           *t = ok;
 182           *tp = tm;
 183           r = tp;
 184         }
 185     }
 186
 187   return r;
 188 }
 189
 190
 191 /* Convert *TP to a time_t value, inverting
 192    the monotonic and mostly-unit-linear conversion function CONVERT.
 193    Use *OFFSET to keep track of a guess at the offset of the result,
 194    compared to what the result would be for UTC without leap seconds.
 195    If *OFFSET's guess is correct, only one CONVERT call is needed.  */
 196 #ifndef _LIBC
 197 static
 198 #endif
 199 time_t
 200 __mktime_internal (struct tm *tp,
 201                    struct tm *(*convert) (const time_t *, struct tm *),
 202                    long int *offset)
 203 {
 204   time_t t, dt, t0, t1, t2;
 205   struct tm tm;
 206
 207   /* The maximum number of probes (calls to CONVERT) should be enough
 208      to handle any combinations of time zone rule changes, solar time,
 209      leap seconds, and oscillations around a spring-forward gap.
 210      POSIX.1 prohibits leap seconds, but some hosts have them anyway.  */
 211   int remaining_probes = 6;
 212
 213   /* Time requested.  Copy it in case CONVERT modifies *TP; this can
 214      occur if TP is localtime's returned value and CONVERT is localtime.  */
 215   int sec = tp->tm_sec;
 216   int min = tp->tm_min;
 217   int hour = tp->tm_hour;
 218   int mday = tp->tm_mday;
 219   int mon = tp->tm_mon;
 220   int year_requested = tp->tm_year;
 221   int isdst = tp->tm_isdst;
 222
 223   /* 1 if the previous probe was DST.  */
 224   int dst2;
 225
 226   /* Ensure that mon is in range, and set year accordingly.  */
 227   int mon_remainder = mon % 12;
 228   int negative_mon_remainder = mon_remainder < 0;
 229   int mon_years = mon / 12 - negative_mon_remainder;
 230   int year = year_requested + mon_years;
 231
 232   /* The other values need not be in range:
 233      the remaining code handles minor overflows correctly,
 234      assuming int and time_t arithmetic wraps around.
 235      Major overflows are caught at the end.  */
 236
 237   /* Calculate day of year from year, month, and day of month.
 238      The result need not be in range.  */
 239   int yday = ((__mon_yday[__isleap (year + TM_YEAR_BASE)]
 240                [mon_remainder + 12 * negative_mon_remainder])
 241               + mday - 1);
 242
 243   int sec_requested = sec;
 244
 245 #if LEAP_SECONDS_POSSIBLE
 246   /* Handle out-of-range seconds specially,
 247      since ydhms_tm_diff assumes every minute has 60 seconds.  */
 248   if (sec < 0)
 249     sec = 0;
 250   if (59 < sec)
 251     sec = 59;
 252 #endif
 253
 254   /* Invert CONVERT by probing.  First assume the same offset as last time.
 255      Then repeatedly use the error to improve the guess.  */
 256
 257   tm.tm_year = EPOCH_YEAR - TM_YEAR_BASE;
 258   tm.tm_yday = tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
 259   t0 = ydhms_tm_diff (year, yday, hour, min, sec, &tm);
 260   t = t0 + *offset;
 261   if ((t < t0) != (*offset < 0))
 262     t = t0;
 263
 264   for (t1 = t2 = t, dst2 = 0;
 265        (dt = ydhms_tm_diff (year, yday, hour, min, sec,
 266                             ranged_convert (convert, &t, &tm)));
 267        t1 = t2, t2 = t, t += dt, dst2 = tm.tm_isdst != 0)
 268     if (t == t1 && t != t2
 269         && (tm.tm_isdst < 0
 270             || (isdst < 0
 271                 ? dst2 <= (tm.tm_isdst != 0)
 272                 : (isdst != 0) != (tm.tm_isdst != 0))))
 273       /* We can't possibly find a match, as we are oscillating
 274          between two values.  The requested time probably falls
 275          within a spring-forward gap of size DT.  Follow the common
 276          practice in this case, which is to return a time that is DT
 277          away from the requested time, preferring a time whose
 278          tm_isdst differs from the requested value.  (If no tm_isdst
 279          was requested and only one of the two values has a nonzero
 280          tm_isdst, prefer that value.)  In practice, this is more
 281          useful than returning -1.  */
 282       break;
 283     else if (--remaining_probes == 0)
 284       return -1;
 285
 286   /* If we have a match, check whether tm.tm_isdst has the requested
 287      value, if any.  */
 288   if (dt == 0 && isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
 289     {
 290       /* tm.tm_isdst has the wrong value.  Look for a neighboring
 291          time with the right value, and use its UTC offset.
 292          Heuristic: probe the previous three calendar quarters (approximately),
 293          looking for the desired isdst.  This isn't perfect,
 294          but it's good enough in practice.  */
 295       int quarter = 7889238; /* seconds per average 1/4 Gregorian year */
 296       int i;
 297
 298       /* If we're too close to the time_t limit, look in future quarters.  */
 299       if (t < TIME_T_MIN + 3 * quarter)
 300         quarter = -quarter;
 301
 302       for (i = 1; i <= 3; i++)
 303         {
 304           time_t ot = t - i * quarter;
 305           struct tm otm;
 306           ranged_convert (convert, &ot, &otm);
 307           if (otm.tm_isdst == isdst)
 308             {
 309               /* We found the desired tm_isdst.
 310                  Extrapolate back to the desired time.  */
 311               t = ot + ydhms_tm_diff (year, yday, hour, min, sec, &otm);
 312               ranged_convert (convert, &t, &tm);
 313               break;
 314             }
 315         }
 316     }
 317
 318   *offset = t - t0;
 319
 320 #if LEAP_SECONDS_POSSIBLE
 321   if (sec_requested != tm.tm_sec)
 322     {
 323       /* Adjust time to reflect the tm_sec requested, not the normalized value.
 324          Also, repair any damage from a false match due to a leap second.  */
 325       t += sec_requested - sec + (sec == 0 && tm.tm_sec == 60);
 326       if (! (*convert) (&t, &tm))
 327         return -1;
 328     }
 329 #endif
 330
 331   if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
 332     {
 333       /* time_t isn't large enough to rule out overflows in ydhms_tm_diff,
 334          so check for major overflows.  A gross check suffices,
 335          since if t has overflowed, it is off by a multiple of
 336          TIME_T_MAX - TIME_T_MIN + 1.  So ignore any component of
 337          the difference that is bounded by a small value.  */
 338
 339       double dyear = (double) year_requested + mon_years - tm.tm_year;
 340       double dday = 366 * dyear + mday;
 341       double dsec = 60 * (60 * (24 * dday + hour) + min) + sec_requested;
 342
 343       /* On Irix4.0.5 cc, dividing TIME_T_MIN by 3 does not produce
 344          correct results, ie., it erroneously gives a positive value
 345          of 715827882.  Setting a variable first then doing math on it
 346          seems to work.  (ghazi@caip.rutgers.edu) */
 347
 348       const time_t time_t_max = TIME_T_MAX;
 349       const time_t time_t_min = TIME_T_MIN;
 350
 351       if (time_t_max / 3 - time_t_min / 3 < (dsec < 0 ? - dsec : dsec))
 352         return -1;
 353     }
 354
 355   *tp = tm;
 356   return t;
 357 }
 358
 359
 360 static long int localtime_offset;
 361
 362 /* Convert *TP to a time_t value.  */
 363 time_t
 364 mktime (struct tm *tp)
 365 {
 366 #ifdef _LIBC
 367   /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
 368      time zone names contained in the external variable `tzname' shall
 369      be set as if the tzset() function had been called.  */
 370   __tzset ();
 371 #endif
 372
 373   return __mktime_internal (tp, my_mktime_localtime_r, &localtime_offset);
 374 }
 375
 376 #ifdef weak_alias
 377 weak_alias (mktime, timelocal)
 378 #endif
 379
 380 #ifdef _LIBC
 381 libc_hidden_def (mktime)
 382 libc_hidden_weak (timelocal)
 383 #endif
 384 \f
 385 #if DEBUG
 386
 387 static int
 388 not_equal_tm (struct tm const *a, struct tm const *b)
 389 {
 390   return ((a->tm_sec ^ b->tm_sec)
 391           | (a->tm_min ^ b->tm_min)
 392           | (a->tm_hour ^ b->tm_hour)
 393           | (a->tm_mday ^ b->tm_mday)
 394           | (a->tm_mon ^ b->tm_mon)
 395           | (a->tm_year ^ b->tm_year)
 396           | (a->tm_mday ^ b->tm_mday)
 397           | (a->tm_yday ^ b->tm_yday)
 398           | (a->tm_isdst ^ b->tm_isdst));
 399 }
 400
 401 static void
 402 print_tm (struct tm const *tp)
 403 {
 404   if (tp)
 405     printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
 406             tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
 407             tp->tm_hour, tp->tm_min, tp->tm_sec,
 408             tp->tm_yday, tp->tm_wday, tp->tm_isdst);
 409   else
 410     printf ("0");
 411 }
 412
 413 static int
 414 check_result (time_t tk, struct tm tmk, time_t tl, struct tm const *lt)
 415 {
 416   if (tk != tl || !lt || not_equal_tm (&tmk, lt))
 417     {
 418       printf ("mktime (");
 419       print_tm (&tmk);
 420       printf (")\nyields (");
 421       print_tm (lt);
 422       printf (") == %ld, should be %ld\n", (long) tl, (long) tk);
 423       return 1;
 424     }
 425
 426   return 0;
 427 }
 428
 429 int
 430 main (int argc, char **argv)
 431 {
 432   int status = 0;
 433   struct tm tm, tmk, tml;
 434   struct tm *lt;
 435   time_t tk, tl;
 436   char trailer;
 437
 438   if ((argc == 3 || argc == 4)
 439       && (sscanf (argv[1], "%d-%d-%d%c",
 440                   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
 441           == 3)
 442       && (sscanf (argv[2], "%d:%d:%d%c",
 443                   &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
 444           == 3))
 445     {
 446       tm.tm_year -= TM_YEAR_BASE;
 447       tm.tm_mon--;
 448       tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
 449       tmk = tm;
 450       tl = mktime (&tmk);
 451       lt = localtime (&tl);
 452       if (lt)
 453         {
 454           tml = *lt;
 455           lt = &tml;
 456         }
 457       printf ("mktime returns %ld == ", (long) tl);
 458       print_tm (&tmk);
 459       printf ("\n");
 460       status = check_result (tl, tmk, tl, lt);
 461     }
 462   else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
 463     {
 464       time_t from = atol (argv[1]);
 465       time_t by = atol (argv[2]);
 466       time_t to = atol (argv[3]);
 467
 468       if (argc == 4)
 469         for (tl = from; tl <= to; tl += by)
 470           {
 471             lt = localtime (&tl);
 472             if (lt)
 473               {
 474                 tmk = tml = *lt;
 475                 tk = mktime (&tmk);
 476                 status |= check_result (tk, tmk, tl, &tml);
 477               }
 478             else
 479               {
 480                 printf ("localtime (%ld) yields 0\n", (long) tl);
 481                 status = 1;
 482               }
 483           }
 484       else
 485         for (tl = from; tl <= to; tl += by)
 486           {
 487             /* Null benchmark.  */
 488             lt = localtime (&tl);
 489             if (lt)
 490               {
 491                 tmk = tml = *lt;
 492                 tk = tl;
 493                 status |= check_result (tk, tmk, tl, &tml);
 494               }
 495             else
 496               {
 497                 printf ("localtime (%ld) yields 0\n", (long) tl);
 498                 status = 1;
 499               }
 500           }
 501     }
 502   else
 503     printf ("Usage:\
 504 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
 505 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
 506 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
 507             argv[0], argv[0], argv[0]);
 508
 509   return status;
 510 }
 511
 512 #endif /* DEBUG */
 513 \f
 514 /*
 515 Local Variables:
 516 compile-command: "gcc -DDEBUG -DSTDC_HEADERS -Wall -W -O -g mktime.c -o mktime"
 517 End:
 518 */