time/mktime.c

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