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