gl/mktime.c

   1 /* Convert a `struct tm' to a time_t value.
   2    Copyright (C) 1993-1999, 2002-2005, 2006, 2007 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 3, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
  19
  20 /* Define this to have a standalone program to test this implementation of
  21    mktime.  */
  22 /* #define DEBUG 1 */
  23
  24 #ifndef _LIBC
  25 # include <config.h>
  26 #endif
  27
  28 /* Assume that leap seconds are possible, unless told otherwise.
  29    If the host has a `zic' command with a `-L leapsecondfilename' option,
  30    then it supports leap seconds; otherwise it probably doesn't.  */
  31 #ifndef LEAP_SECONDS_POSSIBLE
  32 # define LEAP_SECONDS_POSSIBLE 1
  33 #endif
  34
  35 #include <time.h>
  36
  37 #include <limits.h>
  38
  39 #include <string.h>             /* For the real memcpy prototype.  */
  40
  41 #if DEBUG
  42 # include <stdio.h>
  43 # include <stdlib.h>
  44 /* Make it work even if the system's libc has its own mktime routine.  */
  45 # define mktime my_mktime
  46 #endif /* DEBUG */
  47
  48 /* Shift A right by B bits portably, by dividing A by 2**B and
  49    truncating towards minus infinity.  A and B should be free of side
  50    effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
  51    INT_BITS is the number of useful bits in an int.  GNU code can
  52    assume that INT_BITS is at least 32.
  53
  54    ISO C99 says that A >> B is implementation-defined if A < 0.  Some
  55    implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
  56    right in the usual way when A < 0, so SHR falls back on division if
  57    ordinary A >> B doesn't seem to be the usual signed shift.  */
  58 #define SHR(a, b)       \
  59   (-1 >> 1 == -1        \
  60    ? (a) >> (b)         \
  61    : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
  62
  63 /* The extra casts in the following macros work around compiler bugs,
  64    e.g., in Cray C 5.0.3.0.  */
  65
  66 /* True if the arithmetic type T is an integer type.  bool counts as
  67    an integer.  */
  68 #define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
  69
  70 /* True if negative values of the signed integer type T use two's
  71    complement, ones' complement, or signed magnitude representation,
  72    respectively.  Much GNU code assumes two's complement, but some
  73    people like to be portable to all possible C hosts.  */
  74 #define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)
  75 #define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)
  76 #define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
  77
  78 /* True if the arithmetic type T is signed.  */
  79 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
  80
  81 /* The maximum and minimum values for the integer type T.  These
  82    macros have undefined behavior if T is signed and has padding bits.
  83    If this is a problem for you, please let us know how to fix it for
  84    your host.  */
  85 #define TYPE_MINIMUM(t) \
  86   ((t) (! TYPE_SIGNED (t) \
  87         ? (t) 0 \
  88         : TYPE_SIGNED_MAGNITUDE (t) \
  89         ? ~ (t) 0 \
  90         : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
  91 #define TYPE_MAXIMUM(t) \
  92   ((t) (! TYPE_SIGNED (t) \
  93         ? (t) -1 \
  94         : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
  95
  96 #ifndef TIME_T_MIN
  97 # define TIME_T_MIN TYPE_MINIMUM (time_t)
  98 #endif
  99 #ifndef TIME_T_MAX
 100 # define TIME_T_MAX TYPE_MAXIMUM (time_t)
 101 #endif
 102 #define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
 103
 104 /* Verify a requirement at compile-time (unlike assert, which is runtime).  */
 105 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
 106
 107 verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
 108 verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
 109 /* The code also assumes that signed integer overflow silently wraps
 110    around, but this assumption can't be stated without causing a
 111    diagnostic on some hosts.  */
 112
 113 #define EPOCH_YEAR 1970
 114 #define TM_YEAR_BASE 1900
 115 verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
 116
 117 /* Return 1 if YEAR + TM_YEAR_BASE is a leap year.  */
 118 static inline int
 119 leapyear (long int year)
 120 {
 121   /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
 122      Also, work even if YEAR is negative.  */
 123   return
 124     ((year & 3) == 0
 125      && (year % 100 != 0
 126          || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
 127 }
 128
 129 /* How many days come before each month (0-12).  */
 130 #ifndef _LIBC
 131 static
 132 #endif
 133 const unsigned short int __mon_yday[2][13] =
 134   {
 135     /* Normal years.  */
 136     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
 137     /* Leap years.  */
 138     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
 139   };
 140
 141
 142 #ifndef _LIBC
 143 /* Portable standalone applications should supply a <time.h> that
 144    declares a POSIX-compliant localtime_r, for the benefit of older
 145    implementations that lack localtime_r or have a nonstandard one.
 146    See the gnulib time_r module for one way to implement this.  */
 147 # undef __localtime_r
 148 # define __localtime_r localtime_r
 149 # define __mktime_internal mktime_internal
 150 #endif
 151
 152 /* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
 153    (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
 154    were not adjusted between the time stamps.
 155
 156    The YEAR values uses the same numbering as TP->tm_year.  Values
 157    need not be in the usual range.  However, YEAR1 must not be less
 158    than 2 * INT_MIN or greater than 2 * INT_MAX.
 159
 160    The result may overflow.  It is the caller's responsibility to
 161    detect overflow.  */
 162
 163 static inline time_t
 164 ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
 165             int year0, int yday0, int hour0, int min0, int sec0)
 166 {
 167   verify (C99_integer_division, -1 / 2 == 0);
 168   verify (long_int_year_and_yday_are_wide_enough,
 169           INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
 170
 171   /* Compute intervening leap days correctly even if year is negative.
 172      Take care to avoid integer overflow here.  */
 173   int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3);
 174   int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3);
 175   int a100 = a4 / 25 - (a4 % 25 < 0);
 176   int b100 = b4 / 25 - (b4 % 25 < 0);
 177   int a400 = SHR (a100, 2);
 178   int b400 = SHR (b100, 2);
 179   int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
 180
 181   /* Compute the desired time in time_t precision.  Overflow might
 182      occur here.  */
 183   time_t tyear1 = year1;
 184   time_t years = tyear1 - year0;
 185   time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;
 186   time_t hours = 24 * days + hour1 - hour0;
 187   time_t minutes = 60 * hours + min1 - min0;
 188   time_t seconds = 60 * minutes + sec1 - sec0;
 189   return seconds;
 190 }
 191
 192
 193 /* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
 194    assuming that *T corresponds to *TP and that no clock adjustments
 195    occurred between *TP and the desired time.
 196    If TP is null, return a value not equal to *T; this avoids false matches.
 197    If overflow occurs, yield the minimal or maximal value, except do not
 198    yield a value equal to *T.  */
 199 static time_t
 200 guess_time_tm (long int year, long int yday, int hour, int min, int sec,
 201                const time_t *t, const struct tm *tp)
 202 {
 203   if (tp)
 204     {
 205       time_t d = ydhms_diff (year, yday, hour, min, sec,
 206                              tp->tm_year, tp->tm_yday,
 207                              tp->tm_hour, tp->tm_min, tp->tm_sec);
 208       time_t t1 = *t + d;
 209       if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
 210         return t1;
 211     }
 212
 213   /* Overflow occurred one way or another.  Return the nearest result
 214      that is actually in range, except don't report a zero difference
 215      if the actual difference is nonzero, as that would cause a false
 216      match; and don't oscillate between two values, as that would
 217      confuse the spring-forward gap detector.  */
 218   return (*t < TIME_T_MIDPOINT
 219           ? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
 220           : (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
 221 }
 222
 223 /* Use CONVERT to convert *T to a broken down time in *TP.
 224    If *T is out of range for conversion, adjust it so that
 225    it is the nearest in-range value and then convert that.  */
 226 static struct tm *
 227 ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
 228                 time_t *t, struct tm *tp)
 229 {
 230   struct tm *r = convert (t, tp);
 231
 232   if (!r && *t)
 233     {
 234       time_t bad = *t;
 235       time_t ok = 0;
 236
 237       /* BAD is a known unconvertible time_t, and OK is a known good one.
 238          Use binary search to narrow the range between BAD and OK until
 239          they differ by 1.  */
 240       while (bad != ok + (bad < 0 ? -1 : 1))
 241         {
 242           time_t mid = *t = (bad < 0
 243                              ? bad + ((ok - bad) >> 1)
 244                              : ok + ((bad - ok) >> 1));
 245           r = convert (t, tp);
 246           if (r)
 247             ok = mid;
 248           else
 249             bad = mid;
 250         }
 251
 252       if (!r && ok)
 253         {
 254           /* The last conversion attempt failed;
 255              revert to the most recent successful attempt.  */
 256           *t = ok;
 257           r = convert (t, tp);
 258         }
 259     }
 260
 261   return r;
 262 }
 263
 264
 265 /* Convert *TP to a time_t value, inverting
 266    the monotonic and mostly-unit-linear conversion function CONVERT.
 267    Use *OFFSET to keep track of a guess at the offset of the result,
 268    compared to what the result would be for UTC without leap seconds.
 269    If *OFFSET's guess is correct, only one CONVERT call is needed.
 270    This function is external because it is used also by timegm.c.  */
 271 time_t
 272 __mktime_internal (struct tm *tp,
 273                    struct tm *(*convert) (const time_t *, struct tm *),
 274                    time_t *offset)
 275 {
 276   time_t t, gt, t0, t1, t2;
 277   struct tm tm;
 278
 279   /* The maximum number of probes (calls to CONVERT) should be enough
 280      to handle any combinations of time zone rule changes, solar time,
 281      leap seconds, and oscillations around a spring-forward gap.
 282      POSIX.1 prohibits leap seconds, but some hosts have them anyway.  */
 283   int remaining_probes = 6;
 284
 285   /* Time requested.  Copy it in case CONVERT modifies *TP; this can
 286      occur if TP is localtime's returned value and CONVERT is localtime.  */
 287   int sec = tp->tm_sec;
 288   int min = tp->tm_min;
 289   int hour = tp->tm_hour;
 290   int mday = tp->tm_mday;
 291   int mon = tp->tm_mon;
 292   int year_requested = tp->tm_year;
 293   /* Normalize the value.  */
 294   int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))
 295                | (tp->tm_isdst != 0));
 296
 297   /* 1 if the previous probe was DST.  */
 298   int dst2;
 299
 300   /* Ensure that mon is in range, and set year accordingly.  */
 301   int mon_remainder = mon % 12;
 302   int negative_mon_remainder = mon_remainder < 0;
 303   int mon_years = mon / 12 - negative_mon_remainder;
 304   long int lyear_requested = year_requested;
 305   long int year = lyear_requested + mon_years;
 306
 307   /* The other values need not be in range:
 308      the remaining code handles minor overflows correctly,
 309      assuming int and time_t arithmetic wraps around.
 310      Major overflows are caught at the end.  */
 311
 312   /* Calculate day of year from year, month, and day of month.
 313      The result need not be in range.  */
 314   int mon_yday = ((__mon_yday[leapyear (year)]
 315                    [mon_remainder + 12 * negative_mon_remainder])
 316                   - 1);
 317   long int lmday = mday;
 318   long int yday = mon_yday + lmday;
 319
 320   time_t guessed_offset = *offset;
 321
 322   int sec_requested = sec;
 323
 324   if (LEAP_SECONDS_POSSIBLE)
 325     {
 326       /* Handle out-of-range seconds specially,
 327          since ydhms_tm_diff assumes every minute has 60 seconds.  */
 328       if (sec < 0)
 329         sec = 0;
 330       if (59 < sec)
 331         sec = 59;
 332     }
 333
 334   /* Invert CONVERT by probing.  First assume the same offset as last
 335      time.  */
 336
 337   t0 = ydhms_diff (year, yday, hour, min, sec,
 338                    EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
 339
 340   if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
 341     {
 342       /* time_t isn't large enough to rule out overflows, so check
 343          for major overflows.  A gross check suffices, since if t0
 344          has overflowed, it is off by a multiple of TIME_T_MAX -
 345          TIME_T_MIN + 1.  So ignore any component of the difference
 346          that is bounded by a small value.  */
 347
 348       /* Approximate log base 2 of the number of time units per
 349          biennium.  A biennium is 2 years; use this unit instead of
 350          years to avoid integer overflow.  For example, 2 average
 351          Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
 352          which is 63113904 seconds, and rint (log2 (63113904)) is
 353          26.  */
 354       int ALOG2_SECONDS_PER_BIENNIUM = 26;
 355       int ALOG2_MINUTES_PER_BIENNIUM = 20;
 356       int ALOG2_HOURS_PER_BIENNIUM = 14;
 357       int ALOG2_DAYS_PER_BIENNIUM = 10;
 358       int LOG2_YEARS_PER_BIENNIUM = 1;
 359
 360       int approx_requested_biennia =
 361         (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
 362          - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
 363          + SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
 364          + SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
 365          + SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
 366          + (LEAP_SECONDS_POSSIBLE
 367             ? 0
 368             : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
 369
 370       int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
 371       int diff = approx_biennia - approx_requested_biennia;
 372       int abs_diff = diff < 0 ? - diff : diff;
 373
 374       /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
 375          gives a positive value of 715827882.  Setting a variable
 376          first then doing math on it seems to work.
 377          (ghazi@caip.rutgers.edu) */
 378       time_t time_t_max = TIME_T_MAX;
 379       time_t time_t_min = TIME_T_MIN;
 380       time_t overflow_threshold =
 381         (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
 382
 383       if (overflow_threshold < abs_diff)
 384         {
 385           /* Overflow occurred.  Try repairing it; this might work if
 386              the time zone offset is enough to undo the overflow.  */
 387           time_t repaired_t0 = -1 - t0;
 388           approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
 389           diff = approx_biennia - approx_requested_biennia;
 390           abs_diff = diff < 0 ? - diff : diff;
 391           if (overflow_threshold < abs_diff)
 392             return -1;
 393           guessed_offset += repaired_t0 - t0;
 394           t0 = repaired_t0;
 395         }
 396     }
 397
 398   /* Repeatedly use the error to improve the guess.  */
 399
 400   for (t = t1 = t2 = t0, dst2 = 0;
 401        (gt = guess_time_tm (year, yday, hour, min, sec, &t,
 402                             ranged_convert (convert, &t, &tm)),
 403         t != gt);
 404        t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
 405     if (t == t1 && t != t2
 406         && (tm.tm_isdst < 0
 407             || (isdst < 0
 408                 ? dst2 <= (tm.tm_isdst != 0)
 409                 : (isdst != 0) != (tm.tm_isdst != 0))))
 410       /* We can't possibly find a match, as we are oscillating
 411          between two values.  The requested time probably falls
 412          within a spring-forward gap of size GT - T.  Follow the common
 413          practice in this case, which is to return a time that is GT - T
 414          away from the requested time, preferring a time whose
 415          tm_isdst differs from the requested value.  (If no tm_isdst
 416          was requested and only one of the two values has a nonzero
 417          tm_isdst, prefer that value.)  In practice, this is more
 418          useful than returning -1.  */
 419       goto offset_found;
 420     else if (--remaining_probes == 0)
 421       return -1;
 422
 423   /* We have a match.  Check whether tm.tm_isdst has the requested
 424      value, if any.  */
 425   if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
 426     {
 427       /* tm.tm_isdst has the wrong value.  Look for a neighboring
 428          time with the right value, and use its UTC offset.
 429
 430          Heuristic: probe the adjacent timestamps in both directions,
 431          looking for the desired isdst.  This should work for all real
 432          time zone histories in the tz database.  */
 433
 434       /* Distance between probes when looking for a DST boundary.  In
 435          tzdata2003a, the shortest period of DST is 601200 seconds
 436          (e.g., America/Recife starting 2000-10-08 01:00), and the
 437          shortest period of non-DST surrounded by DST is 694800
 438          seconds (Africa/Tunis starting 1943-04-17 01:00).  Use the
 439          minimum of these two values, so we don't miss these short
 440          periods when probing.  */
 441       int stride = 601200;
 442
 443       /* The longest period of DST in tzdata2003a is 536454000 seconds
 444          (e.g., America/Jujuy starting 1946-10-01 01:00).  The longest
 445          period of non-DST is much longer, but it makes no real sense
 446          to search for more than a year of non-DST, so use the DST
 447          max.  */
 448       int duration_max = 536454000;
 449
 450       /* Search in both directions, so the maximum distance is half
 451          the duration; add the stride to avoid off-by-1 problems.  */
 452       int delta_bound = duration_max / 2 + stride;
 453
 454       int delta, direction;
 455
 456       for (delta = stride; delta < delta_bound; delta += stride)
 457         for (direction = -1; direction <= 1; direction += 2)
 458           {
 459             time_t ot = t + delta * direction;
 460             if ((ot < t) == (direction < 0))
 461               {
 462                 struct tm otm;
 463                 ranged_convert (convert, &ot, &otm);
 464                 if (otm.tm_isdst == isdst)
 465                   {
 466                     /* We found the desired tm_isdst.
 467                        Extrapolate back to the desired time.  */
 468                     t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
 469                     ranged_convert (convert, &t, &tm);
 470                     goto offset_found;
 471                   }
 472               }
 473           }
 474     }
 475
 476  offset_found:
 477   *offset = guessed_offset + t - t0;
 478
 479   if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
 480     {
 481       /* Adjust time to reflect the tm_sec requested, not the normalized value.
 482          Also, repair any damage from a false match due to a leap second.  */
 483       int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
 484       t1 = t + sec_requested;
 485       t2 = t1 + sec_adjustment;
 486       if (((t1 < t) != (sec_requested < 0))
 487           | ((t2 < t1) != (sec_adjustment < 0))
 488           | ! convert (&t2, &tm))
 489         return -1;
 490       t = t2;
 491     }
 492
 493   *tp = tm;
 494   return t;
 495 }
 496
 497
 498 /* FIXME: This should use a signed type wide enough to hold any UTC
 499    offset in seconds.  'int' should be good enough for GNU code.  We
 500    can't fix this unilaterally though, as other modules invoke
 501    __mktime_internal.  */
 502 static time_t localtime_offset;
 503
 504 /* Convert *TP to a time_t value.  */
 505 time_t
 506 mktime (struct tm *tp)
 507 {
 508 #ifdef _LIBC
 509   /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
 510      time zone names contained in the external variable `tzname' shall
 511      be set as if the tzset() function had been called.  */
 512   __tzset ();
 513 #endif
 514
 515   return __mktime_internal (tp, __localtime_r, &localtime_offset);
 516 }
 517
 518 #ifdef weak_alias
 519 weak_alias (mktime, timelocal)
 520 #endif
 521
 522 #ifdef _LIBC
 523 libc_hidden_def (mktime)
 524 libc_hidden_weak (timelocal)
 525 #endif
 526 \f
 527 #if DEBUG
 528
 529 static int
 530 not_equal_tm (const struct tm *a, const struct tm *b)
 531 {
 532   return ((a->tm_sec ^ b->tm_sec)
 533           | (a->tm_min ^ b->tm_min)
 534           | (a->tm_hour ^ b->tm_hour)
 535           | (a->tm_mday ^ b->tm_mday)
 536           | (a->tm_mon ^ b->tm_mon)
 537           | (a->tm_year ^ b->tm_year)
 538           | (a->tm_yday ^ b->tm_yday)
 539           | (a->tm_isdst ^ b->tm_isdst));
 540 }
 541
 542 static void
 543 print_tm (const struct tm *tp)
 544 {
 545   if (tp)
 546     printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
 547             tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
 548             tp->tm_hour, tp->tm_min, tp->tm_sec,
 549             tp->tm_yday, tp->tm_wday, tp->tm_isdst);
 550   else
 551     printf ("0");
 552 }
 553
 554 static int
 555 check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
 556 {
 557   if (tk != tl || !lt || not_equal_tm (&tmk, lt))
 558     {
 559       printf ("mktime (");
 560       print_tm (lt);
 561       printf (")\nyields (");
 562       print_tm (&tmk);
 563       printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
 564       return 1;
 565     }
 566
 567   return 0;
 568 }
 569
 570 int
 571 main (int argc, char **argv)
 572 {
 573   int status = 0;
 574   struct tm tm, tmk, tml;
 575   struct tm *lt;
 576   time_t tk, tl, tl1;
 577   char trailer;
 578
 579   if ((argc == 3 || argc == 4)
 580       && (sscanf (argv[1], "%d-%d-%d%c",
 581                   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
 582           == 3)
 583       && (sscanf (argv[2], "%d:%d:%d%c",
 584                   &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
 585           == 3))
 586     {
 587       tm.tm_year -= TM_YEAR_BASE;
 588       tm.tm_mon--;
 589       tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
 590       tmk = tm;
 591       tl = mktime (&tmk);
 592       lt = localtime (&tl);
 593       if (lt)
 594         {
 595           tml = *lt;
 596           lt = &tml;
 597         }
 598       printf ("mktime returns %ld == ", (long int) tl);
 599       print_tm (&tmk);
 600       printf ("\n");
 601       status = check_result (tl, tmk, tl, lt);
 602     }
 603   else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
 604     {
 605       time_t from = atol (argv[1]);
 606       time_t by = atol (argv[2]);
 607       time_t to = atol (argv[3]);
 608
 609       if (argc == 4)
 610         for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
 611           {
 612             lt = localtime (&tl);
 613             if (lt)
 614               {
 615                 tmk = tml = *lt;
 616                 tk = mktime (&tmk);
 617                 status |= check_result (tk, tmk, tl, &tml);
 618               }
 619             else
 620               {
 621                 printf ("localtime (%ld) yields 0\n", (long int) tl);
 622                 status = 1;
 623               }
 624             tl1 = tl + by;
 625             if ((tl1 < tl) != (by < 0))
 626               break;
 627           }
 628       else
 629         for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
 630           {
 631             /* Null benchmark.  */
 632             lt = localtime (&tl);
 633             if (lt)
 634               {
 635                 tmk = tml = *lt;
 636                 tk = tl;
 637                 status |= check_result (tk, tmk, tl, &tml);
 638               }
 639             else
 640               {
 641                 printf ("localtime (%ld) yields 0\n", (long int) tl);
 642                 status = 1;
 643               }
 644             tl1 = tl + by;
 645             if ((tl1 < tl) != (by < 0))
 646               break;
 647           }
 648     }
 649   else
 650     printf ("Usage:\
 651 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
 652 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
 653 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
 654             argv[0], argv[0], argv[0]);
 655
 656   return status;
 657 }
 658
 659 #endif /* DEBUG */
 660 \f
 661 /*
 662 Local Variables:
 663 compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"
 664 End:
 665 */