1 /* -*- buffer-read-only: t -*- vi: set ro: */
2 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
3 /* Convert a `struct tm' to a time_t value.
4 Copyright (C) 1993-1999, 2002-2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of the GNU C Library.
6 Contributed by Paul Eggert <eggert@twinsun.com>.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation,
20 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
22 /* Define this to have a standalone program to test this implementation of
30 /* Assume that leap seconds are possible, unless told otherwise.
31 If the host has a `zic' command with a `-L leapsecondfilename' option,
32 then it supports leap seconds; otherwise it probably doesn't. */
33 #ifndef LEAP_SECONDS_POSSIBLE
34 # define LEAP_SECONDS_POSSIBLE 1
41 #include <string.h> /* For the real memcpy prototype. */
46 /* Make it work even if the system's libc has its own mktime routine. */
47 # define mktime my_mktime
50 /* Shift A right by B bits portably, by dividing A by 2**B and
51 truncating towards minus infinity. A and B should be free of side
52 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
53 INT_BITS is the number of useful bits in an int. GNU code can
54 assume that INT_BITS is at least 32.
56 ISO C99 says that A >> B is implementation-defined if A < 0. Some
57 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
58 right in the usual way when A < 0, so SHR falls back on division if
59 ordinary A >> B doesn't seem to be the usual signed shift. */
63 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
65 /* The extra casts in the following macros work around compiler bugs,
66 e.g., in Cray C 5.0.3.0. */
68 /* True if the arithmetic type T is an integer type. bool counts as
70 #define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
72 /* True if negative values of the signed integer type T use two's
73 complement, ones' complement, or signed magnitude representation,
74 respectively. Much GNU code assumes two's complement, but some
75 people like to be portable to all possible C hosts. */
76 #define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)
77 #define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)
78 #define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
80 /* True if the arithmetic type T is signed. */
81 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
83 /* The maximum and minimum values for the integer type T. These
84 macros have undefined behavior if T is signed and has padding bits.
85 If this is a problem for you, please let us know how to fix it for
87 #define TYPE_MINIMUM(t) \
88 ((t) (! TYPE_SIGNED (t) \
90 : TYPE_SIGNED_MAGNITUDE (t) \
92 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
93 #define TYPE_MAXIMUM(t) \
94 ((t) (! TYPE_SIGNED (t) \
96 : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
99 # define TIME_T_MIN TYPE_MINIMUM (time_t)
102 # define TIME_T_MAX TYPE_MAXIMUM (time_t)
104 #define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
106 /* Verify a requirement at compile-time (unlike assert, which is runtime). */
107 #define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
109 verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
110 verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
111 /* The code also assumes that signed integer overflow silently wraps
112 around, but this assumption can't be stated without causing a
113 diagnostic on some hosts. */
115 #define EPOCH_YEAR 1970
116 #define TM_YEAR_BASE 1900
117 verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
119 /* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
121 leapyear (long int year)
123 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
124 Also, work even if YEAR is negative. */
128 || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
131 /* How many days come before each month (0-12). */
135 const unsigned short int __mon_yday[2][13] =
138 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
140 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
145 /* Portable standalone applications should supply a <time.h> that
146 declares a POSIX-compliant localtime_r, for the benefit of older
147 implementations that lack localtime_r or have a nonstandard one.
148 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
218 match; and don't oscillate between two values, as that would
219 confuse the spring-forward gap detector. */
220 return (*t < TIME_T_MIDPOINT
221 ? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
222 : (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
225 /* Use CONVERT to convert *T to a broken down time in *TP.
226 If *T is out of range for conversion, adjust it so that
227 it is the nearest in-range value and then convert that. */
229 ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
230 time_t *t, struct tm *tp)
232 struct tm *r = convert (t, tp);
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));
256 /* The last conversion attempt failed;
257 revert to the most recent successful attempt. */
267 /* Convert *TP to a time_t value, inverting
268 the monotonic and mostly-unit-linear conversion function CONVERT.
269 Use *OFFSET to keep track of a guess at the offset of the result,
270 compared to what the result would be for UTC without leap seconds.
271 If *OFFSET's guess is correct, only one CONVERT call is needed.
272 This function is external because it is used also by timegm.c. */
274 __mktime_internal (struct tm *tp,
275 struct tm *(*convert) (const time_t *, struct tm *),
278 time_t t, gt, t0, t1, t2;
281 /* The maximum number of probes (calls to CONVERT) should be enough
282 to handle any combinations of time zone rule changes, solar time,
283 leap seconds, and oscillations around a spring-forward gap.
284 POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
285 int remaining_probes = 6;
287 /* Time requested. Copy it in case CONVERT modifies *TP; this can
288 occur if TP is localtime's returned value and CONVERT is localtime. */
289 int sec = tp->tm_sec;
290 int min = tp->tm_min;
291 int hour = tp->tm_hour;
292 int mday = tp->tm_mday;
293 int mon = tp->tm_mon;
294 int year_requested = tp->tm_year;
295 /* Normalize the value. */
296 int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))
297 | (tp->tm_isdst != 0));
299 /* 1 if the previous probe was DST. */
302 /* Ensure that mon is in range, and set year accordingly. */
303 int mon_remainder = mon % 12;
304 int negative_mon_remainder = mon_remainder < 0;
305 int mon_years = mon / 12 - negative_mon_remainder;
306 long int lyear_requested = year_requested;
307 long int year = lyear_requested + mon_years;
309 /* The other values need not be in range:
310 the remaining code handles minor overflows correctly,
311 assuming int and time_t arithmetic wraps around.
312 Major overflows are caught at the end. */
314 /* Calculate day of year from year, month, and day of month.
315 The result need not be in range. */
316 int mon_yday = ((__mon_yday[leapyear (year)]
317 [mon_remainder + 12 * negative_mon_remainder])
319 long int lmday = mday;
320 long int yday = mon_yday + lmday;
322 time_t guessed_offset = *offset;
324 int sec_requested = sec;
326 if (LEAP_SECONDS_POSSIBLE)
328 /* Handle out-of-range seconds specially,
329 since ydhms_tm_diff assumes every minute has 60 seconds. */
336 /* Invert CONVERT by probing. First assume the same offset as last
339 t0 = ydhms_diff (year, yday, hour, min, sec,
340 EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
342 if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
344 /* time_t isn't large enough to rule out overflows, so check
345 for major overflows. A gross check suffices, since if t0
346 has overflowed, it is off by a multiple of TIME_T_MAX -
347 TIME_T_MIN + 1. So ignore any component of the difference
348 that is bounded by a small value. */
350 /* Approximate log base 2 of the number of time units per
351 biennium. A biennium is 2 years; use this unit instead of
352 years to avoid integer overflow. For example, 2 average
353 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
354 which is 63113904 seconds, and rint (log2 (63113904)) is
356 int ALOG2_SECONDS_PER_BIENNIUM = 26;
357 int ALOG2_MINUTES_PER_BIENNIUM = 20;
358 int ALOG2_HOURS_PER_BIENNIUM = 14;
359 int ALOG2_DAYS_PER_BIENNIUM = 10;
360 int LOG2_YEARS_PER_BIENNIUM = 1;
362 int approx_requested_biennia =
363 (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
364 - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
365 + SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
366 + SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
367 + SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
368 + (LEAP_SECONDS_POSSIBLE
370 : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
372 int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
373 int diff = approx_biennia - approx_requested_biennia;
374 int abs_diff = diff < 0 ? - diff : diff;
376 /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
377 gives a positive value of 715827882. Setting a variable
378 first then doing math on it seems to work.
379 (ghazi@caip.rutgers.edu) */
380 time_t time_t_max = TIME_T_MAX;
381 time_t time_t_min = TIME_T_MIN;
382 time_t overflow_threshold =
383 (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
385 if (overflow_threshold < abs_diff)
387 /* Overflow occurred. Try repairing it; this might work if
388 the time zone offset is enough to undo the overflow. */
389 time_t repaired_t0 = -1 - t0;
390 approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
391 diff = approx_biennia - approx_requested_biennia;
392 abs_diff = diff < 0 ? - diff : diff;
393 if (overflow_threshold < abs_diff)
395 guessed_offset += repaired_t0 - t0;
400 /* Repeatedly use the error to improve the guess. */
402 for (t = t1 = t2 = t0, dst2 = 0;
403 (gt = guess_time_tm (year, yday, hour, min, sec, &t,
404 ranged_convert (convert, &t, &tm)),
406 t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
407 if (t == t1 && t != t2
410 ? dst2 <= (tm.tm_isdst != 0)
411 : (isdst != 0) != (tm.tm_isdst != 0))))
412 /* We can't possibly find a match, as we are oscillating
413 between two values. The requested time probably falls
414 within a spring-forward gap of size GT - T. Follow the common
415 practice in this case, which is to return a time that is GT - T
416 away from the requested time, preferring a time whose
417 tm_isdst differs from the requested value. (If no tm_isdst
418 was requested and only one of the two values has a nonzero
419 tm_isdst, prefer that value.) In practice, this is more
420 useful than returning -1. */
422 else if (--remaining_probes == 0)
425 /* We have a match. Check whether tm.tm_isdst has the requested
427 if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
429 /* tm.tm_isdst has the wrong value. Look for a neighboring
430 time with the right value, and use its UTC offset.
432 Heuristic: probe the adjacent timestamps in both directions,
433 looking for the desired isdst. This should work for all real
434 time zone histories in the tz database. */
436 /* Distance between probes when looking for a DST boundary. In
437 tzdata2003a, the shortest period of DST is 601200 seconds
438 (e.g., America/Recife starting 2000-10-08 01:00), and the
439 shortest period of non-DST surrounded by DST is 694800
440 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
441 minimum of these two values, so we don't miss these short
442 periods when probing. */
445 /* The longest period of DST in tzdata2003a is 536454000 seconds
446 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest
447 period of non-DST is much longer, but it makes no real sense
448 to search for more than a year of non-DST, so use the DST
450 int duration_max = 536454000;
452 /* Search in both directions, so the maximum distance is half
453 the duration; add the stride to avoid off-by-1 problems. */
454 int delta_bound = duration_max / 2 + stride;
456 int delta, direction;
458 for (delta = stride; delta < delta_bound; delta += stride)
459 for (direction = -1; direction <= 1; direction += 2)
461 time_t ot = t + delta * direction;
462 if ((ot < t) == (direction < 0))
465 ranged_convert (convert, &ot, &otm);
466 if (otm.tm_isdst == isdst)
468 /* We found the desired tm_isdst.
469 Extrapolate back to the desired time. */
470 t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
471 ranged_convert (convert, &t, &tm);
479 *offset = guessed_offset + t - t0;
481 if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
483 /* Adjust time to reflect the tm_sec requested, not the normalized value.
484 Also, repair any damage from a false match due to a leap second. */
485 int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
486 t1 = t + sec_requested;
487 t2 = t1 + sec_adjustment;
488 if (((t1 < t) != (sec_requested < 0))
489 | ((t2 < t1) != (sec_adjustment < 0))
490 | ! convert (&t2, &tm))
500 /* FIXME: This should use a signed type wide enough to hold any UTC
501 offset in seconds. 'int' should be good enough for GNU code. We
502 can't fix this unilaterally though, as other modules invoke
503 __mktime_internal. */
504 static time_t localtime_offset;
506 /* Convert *TP to a time_t value. */
508 mktime (struct tm *tp)
511 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
512 time zone names contained in the external variable `tzname' shall
513 be set as if the tzset() function had been called. */
517 return __mktime_internal (tp, __localtime_r, &localtime_offset);
521 weak_alias (mktime, timelocal)
525 libc_hidden_def (mktime)
526 libc_hidden_weak (timelocal)
532 not_equal_tm (const struct tm *a, const struct tm *b)
534 return ((a->tm_sec ^ b->tm_sec)
535 | (a->tm_min ^ b->tm_min)
536 | (a->tm_hour ^ b->tm_hour)
537 | (a->tm_mday ^ b->tm_mday)
538 | (a->tm_mon ^ b->tm_mon)
539 | (a->tm_year ^ b->tm_year)
540 | (a->tm_yday ^ b->tm_yday)
541 | (a->tm_isdst ^ b->tm_isdst));
545 print_tm (const struct tm *tp)
548 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
549 tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
550 tp->tm_hour, tp->tm_min, tp->tm_sec,
551 tp->tm_yday, tp->tm_wday, tp->tm_isdst);
557 check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
559 if (tk != tl || !lt || not_equal_tm (&tmk, lt))
563 printf (")\nyields (");
565 printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
573 main (int argc, char **argv)
576 struct tm tm, tmk, tml;
581 if ((argc == 3 || argc == 4)
582 && (sscanf (argv[1], "%d-%d-%d%c",
583 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
585 && (sscanf (argv[2], "%d:%d:%d%c",
586 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
589 tm.tm_year -= TM_YEAR_BASE;
591 tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
594 lt = localtime (&tl);
600 printf ("mktime returns %ld == ", (long int) tl);
603 status = check_result (tl, tmk, tl, lt);
605 else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
607 time_t from = atol (argv[1]);
608 time_t by = atol (argv[2]);
609 time_t to = atol (argv[3]);
612 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
614 lt = localtime (&tl);
619 status |= check_result (tk, tmk, tl, &tml);
623 printf ("localtime (%ld) yields 0\n", (long int) tl);
627 if ((tl1 < tl) != (by < 0))
631 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
633 /* Null benchmark. */
634 lt = localtime (&tl);
639 status |= check_result (tk, tmk, tl, &tml);
643 printf ("localtime (%ld) yields 0\n", (long int) tl);
647 if ((tl1 < tl) != (by < 0))
653 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
654 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
655 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
656 argv[0], argv[0], argv[0]);
665 compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"