1 /* Convert a `struct tm' to a time_t value.
2 Copyright (C) 1993-1999, 2002, 2003 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Paul Eggert (eggert@twinsun.com).
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)
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* Define this to have a standalone program to test this implementation of
29 # define STDC_HEADERS 1
32 /* Assume that leap seconds are possible, unless told otherwise.
33 If the host has a `zic' command with a `-L leapsecondfilename' option,
34 then it supports leap seconds; otherwise it probably doesn't. */
35 #ifndef LEAP_SECONDS_POSSIBLE
36 # define LEAP_SECONDS_POSSIBLE 1
39 #include <sys/types.h> /* Some systems define `time_t' here. */
50 /* Make it work even if the system's libc has its own mktime routine. */
51 # define mktime my_mktime
54 /* The extra casts work around common compiler bugs. */
55 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
56 /* The outer cast is needed to work around a bug in Cray C 5.0.3.0.
57 It is necessary at least when t == time_t. */
58 #define TYPE_MINIMUM(t) ((t) (TYPE_SIGNED (t) \
59 ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0))
60 #define TYPE_MAXIMUM(t) ((t) (~ (t) 0 - TYPE_MINIMUM (t)))
63 # define TIME_T_MIN TYPE_MINIMUM (time_t)
66 # define TIME_T_MAX TYPE_MAXIMUM (time_t)
68 #define TIME_T_MIDPOINT (((TIME_T_MIN + TIME_T_MAX) >> 1) + 1)
70 /* Verify a requirement at compile-time (unlike assert, which is runtime). */
71 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
73 verify (time_t_is_integer, (time_t) 0.5 == 0);
74 verify (twos_complement_arithmetic, -1 == ~1 + 1);
75 verify (right_shift_propagates_sign, -1 >> 1 == -1);
76 /* The code also assumes that signed integer overflow silently wraps
77 around, but this assumption can't be stated without causing a
78 diagnostic on some hosts. */
80 #define EPOCH_YEAR 1970
81 #define TM_YEAR_BASE 1900
82 verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
84 /* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
88 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
89 Also, work even if YEAR is negative. */
93 || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
96 /* How many days come before each month (0-12). */
100 const unsigned short int __mon_yday[2][13] =
103 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
105 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
110 # define my_mktime_localtime_r __localtime_r
112 /* If we're a mktime substitute in a GNU program, then prefer
113 localtime to localtime_r, since many localtime_r implementations
116 my_mktime_localtime_r (const time_t *t, struct tm *tp)
118 struct tm *l = localtime (t);
126 /* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
127 (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
128 were not adjusted between the time stamps.
130 The YEAR values uses the same numbering as TP->tm_year. Values
131 need not be in the usual range. However, YEAR1 must not be less
132 than 2 * INT_MIN or greater than 2 * INT_MAX.
134 The result may overflow. It is the caller's responsibility to
138 ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
139 int year0, int yday0, int hour0, int min0, int sec0)
141 verify (C99_integer_division, -1 / 2 == 0);
142 verify (long_int_year_and_yday_are_wide_enough,
143 INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
145 /* Compute intervening leap days correctly even if year is negative.
146 Take care to avoid integer overflow here. */
147 int a4 = (year1 >> 2) + (TM_YEAR_BASE >> 2) - ! (year1 & 3);
148 int b4 = (year0 >> 2) + (TM_YEAR_BASE >> 2) - ! (year0 & 3);
149 int a100 = a4 / 25 - (a4 % 25 < 0);
150 int b100 = b4 / 25 - (b4 % 25 < 0);
151 int a400 = a100 >> 2;
152 int b400 = b100 >> 2;
153 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
155 /* Compute the desired time in time_t precision. Overflow might
157 time_t tyear1 = year1;
158 time_t years = tyear1 - year0;
159 time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;
160 time_t hours = 24 * days + hour1 - hour0;
161 time_t minutes = 60 * hours + min1 - min0;
162 time_t seconds = 60 * minutes + sec1 - sec0;
167 /* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
168 assuming that *T corresponds to *TP and that no clock adjustments
169 occurred between *TP and the desired time.
170 If TP is null, return a value not equal to *T; this avoids false matches.
171 If overflow occurs, yield the minimal or maximal value, except do not
172 yield a value equal to *T. */
174 guess_time_tm (long int year, long int yday, int hour, int min, int sec,
175 const time_t *t, const struct tm *tp)
179 time_t d = ydhms_diff (year, yday, hour, min, sec,
180 tp->tm_year, tp->tm_yday,
181 tp->tm_hour, tp->tm_min, tp->tm_sec);
183 if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
187 /* Overflow occurred one way or another. Return the nearest result
188 that is actually in range, except don't report a zero difference
189 if the actual difference is nonzero, as that would cause a false
191 return (*t < TIME_T_MIDPOINT
192 ? TIME_T_MIN + (*t == TIME_T_MIN)
193 : TIME_T_MAX - (*t == TIME_T_MAX));
196 /* Use CONVERT to convert *T to a broken down time in *TP.
197 If *T is out of range for conversion, adjust it so that
198 it is the nearest in-range value and then convert that. */
200 ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
201 time_t *t, struct tm *tp)
205 if (! (r = (*convert) (t, tp)) && *t)
211 /* BAD is a known unconvertible time_t, and OK is a known good one.
212 Use binary search to narrow the range between BAD and OK until
214 while (bad != ok + (bad < 0 ? -1 : 1))
216 time_t mid = *t = (bad < 0
217 ? bad + ((ok - bad) >> 1)
218 : ok + ((bad - ok) >> 1));
219 if ((r = (*convert) (t, tp)))
230 /* The last conversion attempt failed;
231 revert to the most recent successful attempt. */
242 /* Convert *TP to a time_t value, inverting
243 the monotonic and mostly-unit-linear conversion function CONVERT.
244 Use *OFFSET to keep track of a guess at the offset of the result,
245 compared to what the result would be for UTC without leap seconds.
246 If *OFFSET's guess is correct, only one CONVERT call is needed. */
251 __mktime_internal (struct tm *tp,
252 struct tm *(*convert) (const time_t *, struct tm *),
255 time_t t, gt, t0, t1, t2;
258 /* The maximum number of probes (calls to CONVERT) should be enough
259 to handle any combinations of time zone rule changes, solar time,
260 leap seconds, and oscillations around a spring-forward gap.
261 POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
262 int remaining_probes = 6;
264 /* Time requested. Copy it in case CONVERT modifies *TP; this can
265 occur if TP is localtime's returned value and CONVERT is localtime. */
266 int sec = tp->tm_sec;
267 int min = tp->tm_min;
268 int hour = tp->tm_hour;
269 int mday = tp->tm_mday;
270 int mon = tp->tm_mon;
271 int year_requested = tp->tm_year;
272 int isdst = tp->tm_isdst;
274 /* 1 if the previous probe was DST. */
277 /* Ensure that mon is in range, and set year accordingly. */
278 int mon_remainder = mon % 12;
279 int negative_mon_remainder = mon_remainder < 0;
280 int mon_years = mon / 12 - negative_mon_remainder;
281 long int lyear_requested = year_requested;
282 long int year = lyear_requested + mon_years;
284 /* The other values need not be in range:
285 the remaining code handles minor overflows correctly,
286 assuming int and time_t arithmetic wraps around.
287 Major overflows are caught at the end. */
289 /* Calculate day of year from year, month, and day of month.
290 The result need not be in range. */
291 int mon_yday = ((__mon_yday[leapyear (year)]
292 [mon_remainder + 12 * negative_mon_remainder])
294 long int lmday = mday;
295 long int yday = mon_yday + lmday;
297 time_t guessed_offset = *offset;
299 int sec_requested = sec;
301 if (LEAP_SECONDS_POSSIBLE)
303 /* Handle out-of-range seconds specially,
304 since ydhms_tm_diff assumes every minute has 60 seconds. */
311 /* Invert CONVERT by probing. First assume the same offset as last
314 t0 = ydhms_diff (year, yday, hour, min, sec,
315 EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
317 if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
319 /* time_t isn't large enough to rule out overflows, so check
320 for major overflows. A gross check suffices, since if t0
321 has overflowed, it is off by a multiple of TIME_T_MAX -
322 TIME_T_MIN + 1. So ignore any component of the difference
323 that is bounded by a small value. */
325 /* Approximate log base 2 of the number of time units per
326 biennium. A biennium is 2 years; use this unit instead of
327 years to avoid integer overflow. For example, 2 average
328 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
329 which is 63113904 seconds, and rint (log2 (63113904)) is
331 int ALOG2_SECONDS_PER_BIENNIUM = 26;
332 int ALOG2_MINUTES_PER_BIENNIUM = 20;
333 int ALOG2_HOURS_PER_BIENNIUM = 14;
334 int ALOG2_DAYS_PER_BIENNIUM = 10;
335 int LOG2_YEARS_PER_BIENNIUM = 1;
337 int approx_requested_biennia =
338 ((year_requested >> LOG2_YEARS_PER_BIENNIUM)
339 - ((EPOCH_YEAR - TM_YEAR_BASE) >> LOG2_YEARS_PER_BIENNIUM)
340 + (mday >> ALOG2_DAYS_PER_BIENNIUM)
341 + (hour >> ALOG2_HOURS_PER_BIENNIUM)
342 + (min >> ALOG2_MINUTES_PER_BIENNIUM)
343 + (LEAP_SECONDS_POSSIBLE ? 0 : sec >> ALOG2_SECONDS_PER_BIENNIUM));
345 int approx_biennia = t0 >> ALOG2_SECONDS_PER_BIENNIUM;
346 int diff = approx_biennia - approx_requested_biennia;
347 int abs_diff = diff < 0 ? - diff : diff;
349 /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
350 gives a positive value of 715827882. Setting a variable
351 first then doing math on it seems to work.
352 (ghazi@caip.rutgers.edu) */
353 time_t time_t_max = TIME_T_MAX;
354 time_t time_t_min = TIME_T_MIN;
355 time_t overflow_threshold =
356 (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
358 if (overflow_threshold < abs_diff)
360 /* Overflow occurred. Try repairing it; this might work if
361 the time zone offset is enough to undo the overflow. */
362 time_t repaired_t0 = -1 - t0;
363 approx_biennia = repaired_t0 >> ALOG2_SECONDS_PER_BIENNIUM;
364 diff = approx_biennia - approx_requested_biennia;
365 abs_diff = diff < 0 ? - diff : diff;
366 if (overflow_threshold < abs_diff)
368 guessed_offset += repaired_t0 - t0;
373 /* Repeatedly use the error to improve the guess. */
375 for (t = t1 = t2 = t0, dst2 = 0;
376 (gt = guess_time_tm (year, yday, hour, min, sec, &t,
377 ranged_convert (convert, &t, &tm)),
379 t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
380 if (t == t1 && t != t2
383 ? dst2 <= (tm.tm_isdst != 0)
384 : (isdst != 0) != (tm.tm_isdst != 0))))
385 /* We can't possibly find a match, as we are oscillating
386 between two values. The requested time probably falls
387 within a spring-forward gap of size GT - T. Follow the common
388 practice in this case, which is to return a time that is GT - T
389 away from the requested time, preferring a time whose
390 tm_isdst differs from the requested value. (If no tm_isdst
391 was requested and only one of the two values has a nonzero
392 tm_isdst, prefer that value.) In practice, this is more
393 useful than returning -1. */
395 else if (--remaining_probes == 0)
398 /* We have a match. Check whether tm.tm_isdst has the requested
400 if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
402 /* tm.tm_isdst has the wrong value. Look for a neighboring
403 time with the right value, and use its UTC offset.
405 Heuristic: probe the adjacent timestamps in both directions,
406 looking for the desired isdst. This should work for all real
407 time zone histories in the tz database. */
409 /* Distance between probes when looking for a DST boundary. In
410 tzdata2003a, the shortest period of DST is 601200 seconds
411 (e.g., America/Recife starting 2000-10-08 01:00), and the
412 shortest period of non-DST surrounded by DST is 694800
413 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
414 minimum of these two values, so we don't miss these short
415 periods when probing. */
418 /* The longest period of DST in tzdata2003a is 536454000 seconds
419 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest
420 period of non-DST is much longer, but it makes no real sense
421 to search for more than a year of non-DST, so use the DST
423 int duration_max = 536454000;
425 /* Search in both directions, so the maximum distance is half
426 the duration; add the stride to avoid off-by-1 problems. */
427 int delta_bound = duration_max / 2 + stride;
429 int delta, direction;
431 for (delta = stride; delta < delta_bound; delta += stride)
432 for (direction = -1; direction <= 1; direction += 2)
434 time_t ot = t + delta * direction;
435 if ((ot < t) == (direction < 0))
438 ranged_convert (convert, &ot, &otm);
439 if (otm.tm_isdst == isdst)
441 /* We found the desired tm_isdst.
442 Extrapolate back to the desired time. */
443 t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
444 ranged_convert (convert, &t, &tm);
452 *offset = guessed_offset + t - t0;
454 if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
456 /* Adjust time to reflect the tm_sec requested, not the normalized value.
457 Also, repair any damage from a false match due to a leap second. */
458 int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
459 t1 = t + sec_requested;
460 t2 = t1 + sec_adjustment;
461 if (((t1 < t) != (sec_requested < 0))
462 | ((t2 < t1) != (sec_adjustment < 0))
463 | ! (*convert) (&t, &tm))
472 /* FIXME: This should use a signed type wide enough to hold any UTC
473 offset in seconds. 'int' should be good enough for GNU code. We
474 can't fix this unilaterally though, as other modules invoke
475 __mktime_internal. */
476 static time_t localtime_offset;
478 /* Convert *TP to a time_t value. */
480 mktime (struct tm *tp)
483 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
484 time zone names contained in the external variable `tzname' shall
485 be set as if the tzset() function had been called. */
489 return __mktime_internal (tp, my_mktime_localtime_r, &localtime_offset);
493 weak_alias (mktime, timelocal)
497 libc_hidden_def (mktime)
498 libc_hidden_weak (timelocal)
504 not_equal_tm (const struct tm *a, const struct tm *b)
506 return ((a->tm_sec ^ b->tm_sec)
507 | (a->tm_min ^ b->tm_min)
508 | (a->tm_hour ^ b->tm_hour)
509 | (a->tm_mday ^ b->tm_mday)
510 | (a->tm_mon ^ b->tm_mon)
511 | (a->tm_year ^ b->tm_year)
512 | (a->tm_mday ^ b->tm_mday)
513 | (a->tm_yday ^ b->tm_yday)
514 | (a->tm_isdst ^ b->tm_isdst));
518 print_tm (const struct tm *tp)
521 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
522 tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
523 tp->tm_hour, tp->tm_min, tp->tm_sec,
524 tp->tm_yday, tp->tm_wday, tp->tm_isdst);
530 check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
532 if (tk != tl || !lt || not_equal_tm (&tmk, lt))
536 printf (")\nyields (");
538 printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
546 main (int argc, char **argv)
549 struct tm tm, tmk, tml;
554 if ((argc == 3 || argc == 4)
555 && (sscanf (argv[1], "%d-%d-%d%c",
556 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
558 && (sscanf (argv[2], "%d:%d:%d%c",
559 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
562 tm.tm_year -= TM_YEAR_BASE;
564 tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
567 lt = localtime (&tl);
573 printf ("mktime returns %ld == ", (long int) tl);
576 status = check_result (tl, tmk, tl, lt);
578 else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
580 time_t from = atol (argv[1]);
581 time_t by = atol (argv[2]);
582 time_t to = atol (argv[3]);
585 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
587 lt = localtime (&tl);
592 status |= check_result (tk, tmk, tl, &tml);
596 printf ("localtime (%ld) yields 0\n", (long int) tl);
600 if ((tl1 < tl) != (by < 0))
604 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
606 /* Null benchmark. */
607 lt = localtime (&tl);
612 status |= check_result (tk, tmk, tl, &tml);
616 printf ("localtime (%ld) yields 0\n", (long int) tl);
620 if ((tl1 < tl) != (by < 0))
626 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
627 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
628 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
629 argv[0], argv[0], argv[0]);
638 compile-command: "gcc -DDEBUG -DSTDC_HEADERS -Wall -W -O -g mktime.c -o mktime"