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