1 /* Convert a `struct tm' to a time_t value.
2 Copyright (C) 1993-1999, 2002, 2003, 2004, 2005 Free Software Foundation,
4 This file is part of the GNU C Library.
5 Contributed by Paul Eggert (eggert@twinsun.com).
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License along
18 with this program; if not, write to the Free Software Foundation,
19 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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 /* 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.
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. */
62 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
64 /* The extra casts in the following macros work around compiler bugs,
65 e.g., in Cray C 5.0.3.0. */
67 /* True if the arithmetic type T is an integer type. bool counts as
69 #define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
71 /* True if negative values of the signed integer type T use twos
72 complement, ones complement, or signed magnitude representation,
73 respectively. Much GNU code assumes twos 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)
79 /* True if the arithmetic type T is signed. */
80 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
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
86 #define TYPE_MINIMUM(t) \
87 ((t) (! TYPE_SIGNED (t) \
89 : TYPE_SIGNED_MAGNITUDE (t) \
91 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
92 #define TYPE_MAXIMUM(t) \
93 ((t) (! TYPE_SIGNED (t) \
95 : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
98 # define TIME_T_MIN TYPE_MINIMUM (time_t)
101 # define TIME_T_MAX TYPE_MAXIMUM (time_t)
103 #define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
105 /* Verify a requirement at compile-time (unlike assert, which is runtime). */
106 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
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. */
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);
118 /* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
120 leapyear (long int year)
122 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
123 Also, work even if YEAR is negative. */
127 || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
130 /* How many days come before each month (0-12). */
134 const unsigned short int __mon_yday[2][13] =
137 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
139 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
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. */
149 # undef __localtime_r
150 # define __localtime_r localtime_r
151 # define __mktime_internal mktime_internal
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.
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.
162 The result may overflow. It is the caller's responsibility to
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)
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);
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);
183 /* Compute the desired time in time_t precision. Overflow might
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;
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. */
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)
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);
211 if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
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
219 return (*t < TIME_T_MIDPOINT
220 ? TIME_T_MIN + (*t == TIME_T_MIN)
221 : TIME_T_MAX - (*t == TIME_T_MAX));
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. */
228 ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
229 time_t *t, struct tm *tp)
233 if (! (r = (*convert) (t, tp)) && *t)
239 /* BAD is a known unconvertible time_t, and OK is a known good one.
240 Use binary search to narrow the range between BAD and OK until
242 while (bad != ok + (bad < 0 ? -1 : 1))
244 time_t mid = *t = (bad < 0
245 ? bad + ((ok - bad) >> 1)
246 : ok + ((bad - ok) >> 1));
247 if ((r = (*convert) (t, tp)))
258 /* The last conversion attempt failed;
259 revert to the most recent successful attempt. */
270 /* Convert *TP to a time_t value, inverting
271 the monotonic and mostly-unit-linear conversion function CONVERT.
272 Use *OFFSET to keep track of a guess at the offset of the result,
273 compared to what the result would be for UTC without leap seconds.
274 If *OFFSET's guess is correct, only one CONVERT call is needed.
275 This function is external because it is used also by timegm.c. */
277 __mktime_internal (struct tm *tp,
278 struct tm *(*convert) (const time_t *, struct tm *),
281 time_t t, gt, t0, t1, t2;
284 /* The maximum number of probes (calls to CONVERT) should be enough
285 to handle any combinations of time zone rule changes, solar time,
286 leap seconds, and oscillations around a spring-forward gap.
287 POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
288 int remaining_probes = 6;
290 /* Time requested. Copy it in case CONVERT modifies *TP; this can
291 occur if TP is localtime's returned value and CONVERT is localtime. */
292 int sec = tp->tm_sec;
293 int min = tp->tm_min;
294 int hour = tp->tm_hour;
295 int mday = tp->tm_mday;
296 int mon = tp->tm_mon;
297 int year_requested = tp->tm_year;
298 int isdst = tp->tm_isdst;
300 /* 1 if the previous probe was DST. */
303 /* Ensure that mon is in range, and set year accordingly. */
304 int mon_remainder = mon % 12;
305 int negative_mon_remainder = mon_remainder < 0;
306 int mon_years = mon / 12 - negative_mon_remainder;
307 long int lyear_requested = year_requested;
308 long int year = lyear_requested + mon_years;
310 /* The other values need not be in range:
311 the remaining code handles minor overflows correctly,
312 assuming int and time_t arithmetic wraps around.
313 Major overflows are caught at the end. */
315 /* Calculate day of year from year, month, and day of month.
316 The result need not be in range. */
317 int mon_yday = ((__mon_yday[leapyear (year)]
318 [mon_remainder + 12 * negative_mon_remainder])
320 long int lmday = mday;
321 long int yday = mon_yday + lmday;
323 time_t guessed_offset = *offset;
325 int sec_requested = sec;
327 if (LEAP_SECONDS_POSSIBLE)
329 /* Handle out-of-range seconds specially,
330 since ydhms_tm_diff assumes every minute has 60 seconds. */
337 /* Invert CONVERT by probing. First assume the same offset as last
340 t0 = ydhms_diff (year, yday, hour, min, sec,
341 EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
343 if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
345 /* time_t isn't large enough to rule out overflows, so check
346 for major overflows. A gross check suffices, since if t0
347 has overflowed, it is off by a multiple of TIME_T_MAX -
348 TIME_T_MIN + 1. So ignore any component of the difference
349 that is bounded by a small value. */
351 /* Approximate log base 2 of the number of time units per
352 biennium. A biennium is 2 years; use this unit instead of
353 years to avoid integer overflow. For example, 2 average
354 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
355 which is 63113904 seconds, and rint (log2 (63113904)) is
357 int ALOG2_SECONDS_PER_BIENNIUM = 26;
358 int ALOG2_MINUTES_PER_BIENNIUM = 20;
359 int ALOG2_HOURS_PER_BIENNIUM = 14;
360 int ALOG2_DAYS_PER_BIENNIUM = 10;
361 int LOG2_YEARS_PER_BIENNIUM = 1;
363 int approx_requested_biennia =
364 (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
365 - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
366 + SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
367 + SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
368 + SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
369 + (LEAP_SECONDS_POSSIBLE
371 : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
373 int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
374 int diff = approx_biennia - approx_requested_biennia;
375 int abs_diff = diff < 0 ? - diff : diff;
377 /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
378 gives a positive value of 715827882. Setting a variable
379 first then doing math on it seems to work.
380 (ghazi@caip.rutgers.edu) */
381 time_t time_t_max = TIME_T_MAX;
382 time_t time_t_min = TIME_T_MIN;
383 time_t overflow_threshold =
384 (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
386 if (overflow_threshold < abs_diff)
388 /* Overflow occurred. Try repairing it; this might work if
389 the time zone offset is enough to undo the overflow. */
390 time_t repaired_t0 = -1 - t0;
391 approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
392 diff = approx_biennia - approx_requested_biennia;
393 abs_diff = diff < 0 ? - diff : diff;
394 if (overflow_threshold < abs_diff)
396 guessed_offset += repaired_t0 - t0;
401 /* Repeatedly use the error to improve the guess. */
403 for (t = t1 = t2 = t0, dst2 = 0;
404 (gt = guess_time_tm (year, yday, hour, min, sec, &t,
405 ranged_convert (convert, &t, &tm)),
407 t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
408 if (t == t1 && t != t2
411 ? dst2 <= (tm.tm_isdst != 0)
412 : (isdst != 0) != (tm.tm_isdst != 0))))
413 /* We can't possibly find a match, as we are oscillating
414 between two values. The requested time probably falls
415 within a spring-forward gap of size GT - T. Follow the common
416 practice in this case, which is to return a time that is GT - T
417 away from the requested time, preferring a time whose
418 tm_isdst differs from the requested value. (If no tm_isdst
419 was requested and only one of the two values has a nonzero
420 tm_isdst, prefer that value.) In practice, this is more
421 useful than returning -1. */
423 else if (--remaining_probes == 0)
426 /* We have a match. Check whether tm.tm_isdst has the requested
428 if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
430 /* tm.tm_isdst has the wrong value. Look for a neighboring
431 time with the right value, and use its UTC offset.
433 Heuristic: probe the adjacent timestamps in both directions,
434 looking for the desired isdst. This should work for all real
435 time zone histories in the tz database. */
437 /* Distance between probes when looking for a DST boundary. In
438 tzdata2003a, the shortest period of DST is 601200 seconds
439 (e.g., America/Recife starting 2000-10-08 01:00), and the
440 shortest period of non-DST surrounded by DST is 694800
441 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
442 minimum of these two values, so we don't miss these short
443 periods when probing. */
446 /* The longest period of DST in tzdata2003a is 536454000 seconds
447 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest
448 period of non-DST is much longer, but it makes no real sense
449 to search for more than a year of non-DST, so use the DST
451 int duration_max = 536454000;
453 /* Search in both directions, so the maximum distance is half
454 the duration; add the stride to avoid off-by-1 problems. */
455 int delta_bound = duration_max / 2 + stride;
457 int delta, direction;
459 for (delta = stride; delta < delta_bound; delta += stride)
460 for (direction = -1; direction <= 1; direction += 2)
462 time_t ot = t + delta * direction;
463 if ((ot < t) == (direction < 0))
466 ranged_convert (convert, &ot, &otm);
467 if (otm.tm_isdst == isdst)
469 /* We found the desired tm_isdst.
470 Extrapolate back to the desired time. */
471 t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
472 ranged_convert (convert, &t, &tm);
480 *offset = guessed_offset + t - t0;
482 if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
484 /* Adjust time to reflect the tm_sec requested, not the normalized value.
485 Also, repair any damage from a false match due to a leap second. */
486 int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
487 t1 = t + sec_requested;
488 t2 = t1 + sec_adjustment;
489 if (((t1 < t) != (sec_requested < 0))
490 | ((t2 < t1) != (sec_adjustment < 0))
491 | ! (*convert) (&t2, &tm))
501 /* FIXME: This should use a signed type wide enough to hold any UTC
502 offset in seconds. 'int' should be good enough for GNU code. We
503 can't fix this unilaterally though, as other modules invoke
504 __mktime_internal. */
505 static time_t localtime_offset;
507 /* Convert *TP to a time_t value. */
509 mktime (struct tm *tp)
512 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
513 time zone names contained in the external variable `tzname' shall
514 be set as if the tzset() function had been called. */
518 return __mktime_internal (tp, __localtime_r, &localtime_offset);
522 weak_alias (mktime, timelocal)
526 libc_hidden_def (mktime)
527 libc_hidden_weak (timelocal)
533 not_equal_tm (const struct tm *a, const struct tm *b)
535 return ((a->tm_sec ^ b->tm_sec)
536 | (a->tm_min ^ b->tm_min)
537 | (a->tm_hour ^ b->tm_hour)
538 | (a->tm_mday ^ b->tm_mday)
539 | (a->tm_mon ^ b->tm_mon)
540 | (a->tm_year ^ b->tm_year)
541 | (a->tm_yday ^ b->tm_yday)
542 | (a->tm_isdst ^ b->tm_isdst));
546 print_tm (const struct tm *tp)
549 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
550 tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
551 tp->tm_hour, tp->tm_min, tp->tm_sec,
552 tp->tm_yday, tp->tm_wday, tp->tm_isdst);
558 check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
560 if (tk != tl || !lt || not_equal_tm (&tmk, lt))
564 printf (")\nyields (");
566 printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
574 main (int argc, char **argv)
577 struct tm tm, tmk, tml;
582 if ((argc == 3 || argc == 4)
583 && (sscanf (argv[1], "%d-%d-%d%c",
584 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
586 && (sscanf (argv[2], "%d:%d:%d%c",
587 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
590 tm.tm_year -= TM_YEAR_BASE;
592 tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
595 lt = localtime (&tl);
601 printf ("mktime returns %ld == ", (long int) tl);
604 status = check_result (tl, tmk, tl, lt);
606 else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
608 time_t from = atol (argv[1]);
609 time_t by = atol (argv[2]);
610 time_t to = atol (argv[3]);
613 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
615 lt = localtime (&tl);
620 status |= check_result (tk, tmk, tl, &tml);
624 printf ("localtime (%ld) yields 0\n", (long int) tl);
628 if ((tl1 < tl) != (by < 0))
632 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
634 /* Null benchmark. */
635 lt = localtime (&tl);
640 status |= check_result (tk, tmk, tl, &tml);
644 printf ("localtime (%ld) yields 0\n", (long int) tl);
648 if ((tl1 < tl) != (by < 0))
654 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
655 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
656 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
657 argv[0], argv[0], argv[0]);
666 compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"