1 /* Convert a `struct tm' to a time_t value.
2 Copyright (C) 1993-1999, 2002, 2003, 2004 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Paul Eggert (eggert@twinsun.com).
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.
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.
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
21 /* Define this to have a standalone program to test this implementation of
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
36 #include <sys/types.h> /* Some systems define `time_t' here. */
45 /* Make it work even if the system's libc has its own mktime routine. */
46 # define mktime my_mktime
49 /* The extra casts work around common compiler bugs. */
50 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
51 /* The outer cast is needed to work around a bug in Cray C 5.0.3.0.
52 It is necessary at least when t == time_t. */
53 #define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \
54 ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0))
55 #define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t)))
58 # define TIME_T_MIN TYPE_MINIMUM (time_t)
61 # define TIME_T_MAX TYPE_MAXIMUM (time_t)
63 #define TIME_T_MIDPOINT (((TIME_T_MIN + TIME_T_MAX) >> 1) + 1)
65 /* Verify a requirement at compile-time (unlike assert, which is runtime). */
66 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
68 verify (time_t_is_integer
, (time_t) 0.5 == 0);
69 verify (twos_complement_arithmetic
, -1 == ~1 + 1);
70 verify (right_shift_propagates_sign
, -1 >> 1 == -1);
71 /* The code also assumes that signed integer overflow silently wraps
72 around, but this assumption can't be stated without causing a
73 diagnostic on some hosts. */
75 #define EPOCH_YEAR 1970
76 #define TM_YEAR_BASE 1900
77 verify (base_year_is_a_multiple_of_100
, TM_YEAR_BASE
% 100 == 0);
79 /* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
81 leapyear (long int year
)
83 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
84 Also, work even if YEAR is negative. */
88 || ((year
/ 100) & 3) == (- (TM_YEAR_BASE
/ 100) & 3)));
91 /* How many days come before each month (0-12). */
95 const unsigned short int __mon_yday
[2][13] =
98 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
100 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
105 /* Portable standalone applications should supply a "time_r.h" that
106 declares a POSIX-compliant localtime_r, for the benefit of older
107 implementations that lack localtime_r or have a nonstandard one.
108 See the gnulib time_r module for one way to implement this. */
110 # undef __localtime_r
111 # define __localtime_r localtime_r
112 # define __mktime_internal mktime_internal
115 /* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
116 (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
117 were not adjusted between the time stamps.
119 The YEAR values uses the same numbering as TP->tm_year. Values
120 need not be in the usual range. However, YEAR1 must not be less
121 than 2 * INT_MIN or greater than 2 * INT_MAX.
123 The result may overflow. It is the caller's responsibility to
127 ydhms_diff (long int year1
, long int yday1
, int hour1
, int min1
, int sec1
,
128 int year0
, int yday0
, int hour0
, int min0
, int sec0
)
130 verify (C99_integer_division
, -1 / 2 == 0);
131 verify (long_int_year_and_yday_are_wide_enough
,
132 INT_MAX
<= LONG_MAX
/ 2 || TIME_T_MAX
<= UINT_MAX
);
134 /* Compute intervening leap days correctly even if year is negative.
135 Take care to avoid integer overflow here. */
136 int a4
= (year1
>> 2) + (TM_YEAR_BASE
>> 2) - ! (year1
& 3);
137 int b4
= (year0
>> 2) + (TM_YEAR_BASE
>> 2) - ! (year0
& 3);
138 int a100
= a4
/ 25 - (a4
% 25 < 0);
139 int b100
= b4
/ 25 - (b4
% 25 < 0);
140 int a400
= a100
>> 2;
141 int b400
= b100
>> 2;
142 int intervening_leap_days
= (a4
- b4
) - (a100
- b100
) + (a400
- b400
);
144 /* Compute the desired time in time_t precision. Overflow might
146 time_t tyear1
= year1
;
147 time_t years
= tyear1
- year0
;
148 time_t days
= 365 * years
+ yday1
- yday0
+ intervening_leap_days
;
149 time_t hours
= 24 * days
+ hour1
- hour0
;
150 time_t minutes
= 60 * hours
+ min1
- min0
;
151 time_t seconds
= 60 * minutes
+ sec1
- sec0
;
156 /* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
157 assuming that *T corresponds to *TP and that no clock adjustments
158 occurred between *TP and the desired time.
159 If TP is null, return a value not equal to *T; this avoids false matches.
160 If overflow occurs, yield the minimal or maximal value, except do not
161 yield a value equal to *T. */
163 guess_time_tm (long int year
, long int yday
, int hour
, int min
, int sec
,
164 const time_t *t
, const struct tm
*tp
)
168 time_t d
= ydhms_diff (year
, yday
, hour
, min
, sec
,
169 tp
->tm_year
, tp
->tm_yday
,
170 tp
->tm_hour
, tp
->tm_min
, tp
->tm_sec
);
172 if ((t1
< *t
) == (TYPE_SIGNED (time_t) ? d
< 0 : TIME_T_MAX
/ 2 < d
))
176 /* Overflow occurred one way or another. Return the nearest result
177 that is actually in range, except don't report a zero difference
178 if the actual difference is nonzero, as that would cause a false
180 return (*t
< TIME_T_MIDPOINT
181 ? TIME_T_MIN
+ (*t
== TIME_T_MIN
)
182 : TIME_T_MAX
- (*t
== TIME_T_MAX
));
185 /* Use CONVERT to convert *T to a broken down time in *TP.
186 If *T is out of range for conversion, adjust it so that
187 it is the nearest in-range value and then convert that. */
189 ranged_convert (struct tm
*(*convert
) (const time_t *, struct tm
*),
190 time_t *t
, struct tm
*tp
)
194 if (! (r
= (*convert
) (t
, tp
)) && *t
)
200 /* BAD is a known unconvertible time_t, and OK is a known good one.
201 Use binary search to narrow the range between BAD and OK until
203 while (bad
!= ok
+ (bad
< 0 ? -1 : 1))
205 time_t mid
= *t
= (bad
< 0
206 ? bad
+ ((ok
- bad
) >> 1)
207 : ok
+ ((bad
- ok
) >> 1));
208 if ((r
= (*convert
) (t
, tp
)))
219 /* The last conversion attempt failed;
220 revert to the most recent successful attempt. */
231 /* Convert *TP to a time_t value, inverting
232 the monotonic and mostly-unit-linear conversion function CONVERT.
233 Use *OFFSET to keep track of a guess at the offset of the result,
234 compared to what the result would be for UTC without leap seconds.
235 If *OFFSET's guess is correct, only one CONVERT call is needed.
236 This function is external because it is used also by timegm.c. */
238 __mktime_internal (struct tm
*tp
,
239 struct tm
*(*convert
) (const time_t *, struct tm
*),
242 time_t t
, gt
, t0
, t1
, t2
;
245 /* The maximum number of probes (calls to CONVERT) should be enough
246 to handle any combinations of time zone rule changes, solar time,
247 leap seconds, and oscillations around a spring-forward gap.
248 POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
249 int remaining_probes
= 6;
251 /* Time requested. Copy it in case CONVERT modifies *TP; this can
252 occur if TP is localtime's returned value and CONVERT is localtime. */
253 int sec
= tp
->tm_sec
;
254 int min
= tp
->tm_min
;
255 int hour
= tp
->tm_hour
;
256 int mday
= tp
->tm_mday
;
257 int mon
= tp
->tm_mon
;
258 int year_requested
= tp
->tm_year
;
259 int isdst
= tp
->tm_isdst
;
261 /* 1 if the previous probe was DST. */
264 /* Ensure that mon is in range, and set year accordingly. */
265 int mon_remainder
= mon
% 12;
266 int negative_mon_remainder
= mon_remainder
< 0;
267 int mon_years
= mon
/ 12 - negative_mon_remainder
;
268 long int lyear_requested
= year_requested
;
269 long int year
= lyear_requested
+ mon_years
;
271 /* The other values need not be in range:
272 the remaining code handles minor overflows correctly,
273 assuming int and time_t arithmetic wraps around.
274 Major overflows are caught at the end. */
276 /* Calculate day of year from year, month, and day of month.
277 The result need not be in range. */
278 int mon_yday
= ((__mon_yday
[leapyear (year
)]
279 [mon_remainder
+ 12 * negative_mon_remainder
])
281 long int lmday
= mday
;
282 long int yday
= mon_yday
+ lmday
;
284 time_t guessed_offset
= *offset
;
286 int sec_requested
= sec
;
288 if (LEAP_SECONDS_POSSIBLE
)
290 /* Handle out-of-range seconds specially,
291 since ydhms_tm_diff assumes every minute has 60 seconds. */
298 /* Invert CONVERT by probing. First assume the same offset as last
301 t0
= ydhms_diff (year
, yday
, hour
, min
, sec
,
302 EPOCH_YEAR
- TM_YEAR_BASE
, 0, 0, 0, - guessed_offset
);
304 if (TIME_T_MAX
/ INT_MAX
/ 366 / 24 / 60 / 60 < 3)
306 /* time_t isn't large enough to rule out overflows, so check
307 for major overflows. A gross check suffices, since if t0
308 has overflowed, it is off by a multiple of TIME_T_MAX -
309 TIME_T_MIN + 1. So ignore any component of the difference
310 that is bounded by a small value. */
312 /* Approximate log base 2 of the number of time units per
313 biennium. A biennium is 2 years; use this unit instead of
314 years to avoid integer overflow. For example, 2 average
315 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
316 which is 63113904 seconds, and rint (log2 (63113904)) is
318 int ALOG2_SECONDS_PER_BIENNIUM
= 26;
319 int ALOG2_MINUTES_PER_BIENNIUM
= 20;
320 int ALOG2_HOURS_PER_BIENNIUM
= 14;
321 int ALOG2_DAYS_PER_BIENNIUM
= 10;
322 int LOG2_YEARS_PER_BIENNIUM
= 1;
324 int approx_requested_biennia
=
325 ((year_requested
>> LOG2_YEARS_PER_BIENNIUM
)
326 - ((EPOCH_YEAR
- TM_YEAR_BASE
) >> LOG2_YEARS_PER_BIENNIUM
)
327 + (mday
>> ALOG2_DAYS_PER_BIENNIUM
)
328 + (hour
>> ALOG2_HOURS_PER_BIENNIUM
)
329 + (min
>> ALOG2_MINUTES_PER_BIENNIUM
)
330 + (LEAP_SECONDS_POSSIBLE
? 0 : sec
>> ALOG2_SECONDS_PER_BIENNIUM
));
332 int approx_biennia
= t0
>> ALOG2_SECONDS_PER_BIENNIUM
;
333 int diff
= approx_biennia
- approx_requested_biennia
;
334 int abs_diff
= diff
< 0 ? - diff
: diff
;
336 /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
337 gives a positive value of 715827882. Setting a variable
338 first then doing math on it seems to work.
339 (ghazi@caip.rutgers.edu) */
340 time_t time_t_max
= TIME_T_MAX
;
341 time_t time_t_min
= TIME_T_MIN
;
342 time_t overflow_threshold
=
343 (time_t_max
/ 3 - time_t_min
/ 3) >> ALOG2_SECONDS_PER_BIENNIUM
;
345 if (overflow_threshold
< abs_diff
)
347 /* Overflow occurred. Try repairing it; this might work if
348 the time zone offset is enough to undo the overflow. */
349 time_t repaired_t0
= -1 - t0
;
350 approx_biennia
= repaired_t0
>> ALOG2_SECONDS_PER_BIENNIUM
;
351 diff
= approx_biennia
- approx_requested_biennia
;
352 abs_diff
= diff
< 0 ? - diff
: diff
;
353 if (overflow_threshold
< abs_diff
)
355 guessed_offset
+= repaired_t0
- t0
;
360 /* Repeatedly use the error to improve the guess. */
362 for (t
= t1
= t2
= t0
, dst2
= 0;
363 (gt
= guess_time_tm (year
, yday
, hour
, min
, sec
, &t
,
364 ranged_convert (convert
, &t
, &tm
)),
366 t1
= t2
, t2
= t
, t
= gt
, dst2
= tm
.tm_isdst
!= 0)
367 if (t
== t1
&& t
!= t2
370 ? dst2
<= (tm
.tm_isdst
!= 0)
371 : (isdst
!= 0) != (tm
.tm_isdst
!= 0))))
372 /* We can't possibly find a match, as we are oscillating
373 between two values. The requested time probably falls
374 within a spring-forward gap of size GT - T. Follow the common
375 practice in this case, which is to return a time that is GT - T
376 away from the requested time, preferring a time whose
377 tm_isdst differs from the requested value. (If no tm_isdst
378 was requested and only one of the two values has a nonzero
379 tm_isdst, prefer that value.) In practice, this is more
380 useful than returning -1. */
382 else if (--remaining_probes
== 0)
385 /* We have a match. Check whether tm.tm_isdst has the requested
387 if (isdst
!= tm
.tm_isdst
&& 0 <= isdst
&& 0 <= tm
.tm_isdst
)
389 /* tm.tm_isdst has the wrong value. Look for a neighboring
390 time with the right value, and use its UTC offset.
392 Heuristic: probe the adjacent timestamps in both directions,
393 looking for the desired isdst. This should work for all real
394 time zone histories in the tz database. */
396 /* Distance between probes when looking for a DST boundary. In
397 tzdata2003a, the shortest period of DST is 601200 seconds
398 (e.g., America/Recife starting 2000-10-08 01:00), and the
399 shortest period of non-DST surrounded by DST is 694800
400 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
401 minimum of these two values, so we don't miss these short
402 periods when probing. */
405 /* The longest period of DST in tzdata2003a is 536454000 seconds
406 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest
407 period of non-DST is much longer, but it makes no real sense
408 to search for more than a year of non-DST, so use the DST
410 int duration_max
= 536454000;
412 /* Search in both directions, so the maximum distance is half
413 the duration; add the stride to avoid off-by-1 problems. */
414 int delta_bound
= duration_max
/ 2 + stride
;
416 int delta
, direction
;
418 for (delta
= stride
; delta
< delta_bound
; delta
+= stride
)
419 for (direction
= -1; direction
<= 1; direction
+= 2)
421 time_t ot
= t
+ delta
* direction
;
422 if ((ot
< t
) == (direction
< 0))
425 ranged_convert (convert
, &ot
, &otm
);
426 if (otm
.tm_isdst
== isdst
)
428 /* We found the desired tm_isdst.
429 Extrapolate back to the desired time. */
430 t
= guess_time_tm (year
, yday
, hour
, min
, sec
, &ot
, &otm
);
431 ranged_convert (convert
, &t
, &tm
);
439 *offset
= guessed_offset
+ t
- t0
;
441 if (LEAP_SECONDS_POSSIBLE
&& sec_requested
!= tm
.tm_sec
)
443 /* Adjust time to reflect the tm_sec requested, not the normalized value.
444 Also, repair any damage from a false match due to a leap second. */
445 int sec_adjustment
= (sec
== 0 && tm
.tm_sec
== 60) - sec
;
446 t1
= t
+ sec_requested
;
447 t2
= t1
+ sec_adjustment
;
448 if (((t1
< t
) != (sec_requested
< 0))
449 | ((t2
< t1
) != (sec_adjustment
< 0))
450 | ! (*convert
) (&t
, &tm
))
459 /* FIXME: This should use a signed type wide enough to hold any UTC
460 offset in seconds. 'int' should be good enough for GNU code. We
461 can't fix this unilaterally though, as other modules invoke
462 __mktime_internal. */
463 static time_t localtime_offset
;
465 /* Convert *TP to a time_t value. */
467 mktime (struct tm
*tp
)
470 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
471 time zone names contained in the external variable `tzname' shall
472 be set as if the tzset() function had been called. */
476 return __mktime_internal (tp
, __localtime_r
, &localtime_offset
);
480 weak_alias (mktime
, timelocal
)
484 libc_hidden_def (mktime
)
485 libc_hidden_weak (timelocal
)
491 not_equal_tm (const struct tm
*a
, const struct tm
*b
)
493 return ((a
->tm_sec
^ b
->tm_sec
)
494 | (a
->tm_min
^ b
->tm_min
)
495 | (a
->tm_hour
^ b
->tm_hour
)
496 | (a
->tm_mday
^ b
->tm_mday
)
497 | (a
->tm_mon
^ b
->tm_mon
)
498 | (a
->tm_year
^ b
->tm_year
)
499 | (a
->tm_yday
^ b
->tm_yday
)
500 | (a
->tm_isdst
^ b
->tm_isdst
));
504 print_tm (const struct tm
*tp
)
507 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
508 tp
->tm_year
+ TM_YEAR_BASE
, tp
->tm_mon
+ 1, tp
->tm_mday
,
509 tp
->tm_hour
, tp
->tm_min
, tp
->tm_sec
,
510 tp
->tm_yday
, tp
->tm_wday
, tp
->tm_isdst
);
516 check_result (time_t tk
, struct tm tmk
, time_t tl
, const struct tm
*lt
)
518 if (tk
!= tl
|| !lt
|| not_equal_tm (&tmk
, lt
))
522 printf (")\nyields (");
524 printf (") == %ld, should be %ld\n", (long int) tk
, (long int) tl
);
532 main (int argc
, char **argv
)
535 struct tm tm
, tmk
, tml
;
540 if ((argc
== 3 || argc
== 4)
541 && (sscanf (argv
[1], "%d-%d-%d%c",
542 &tm
.tm_year
, &tm
.tm_mon
, &tm
.tm_mday
, &trailer
)
544 && (sscanf (argv
[2], "%d:%d:%d%c",
545 &tm
.tm_hour
, &tm
.tm_min
, &tm
.tm_sec
, &trailer
)
548 tm
.tm_year
-= TM_YEAR_BASE
;
550 tm
.tm_isdst
= argc
== 3 ? -1 : atoi (argv
[3]);
553 lt
= localtime (&tl
);
559 printf ("mktime returns %ld == ", (long int) tl
);
562 status
= check_result (tl
, tmk
, tl
, lt
);
564 else if (argc
== 4 || (argc
== 5 && strcmp (argv
[4], "-") == 0))
566 time_t from
= atol (argv
[1]);
567 time_t by
= atol (argv
[2]);
568 time_t to
= atol (argv
[3]);
571 for (tl
= from
; by
< 0 ? to
<= tl
: tl
<= to
; tl
= tl1
)
573 lt
= localtime (&tl
);
578 status
|= check_result (tk
, tmk
, tl
, &tml
);
582 printf ("localtime (%ld) yields 0\n", (long int) tl
);
586 if ((tl1
< tl
) != (by
< 0))
590 for (tl
= from
; by
< 0 ? to
<= tl
: tl
<= to
; tl
= tl1
)
592 /* Null benchmark. */
593 lt
= localtime (&tl
);
598 status
|= check_result (tk
, tmk
, tl
, &tml
);
602 printf ("localtime (%ld) yields 0\n", (long int) tl
);
606 if ((tl1
< tl
) != (by
< 0))
612 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
613 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
614 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
615 argv
[0], argv
[0], argv
[0]);
624 compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"