1
/* Convert a `struct tm' to a time_t value.
2
Copyright (C) 1993-1999, 2002-2005, 2006, 2007 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 Lesser 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 Lesser General Public License for more details.
16
You should have received a copy of the GNU Lesser General Public License along
17
with this program; if not, write to the Free Software Foundation,
18
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
20
/* Define this to have a standalone program to test this implementation of
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
39
#include <string.h> /* For the real memcpy prototype. */
44
/* Make it work even if the system's libc has its own mktime routine. */
45
# define mktime my_mktime
48
/* Shift A right by B bits portably, by dividing A by 2**B and
49
truncating towards minus infinity. A and B should be free of side
50
effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
51
INT_BITS is the number of useful bits in an int. GNU code can
52
assume that INT_BITS is at least 32.
54
ISO C99 says that A >> B is implementation-defined if A < 0. Some
55
implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
56
right in the usual way when A < 0, so SHR falls back on division if
57
ordinary A >> B doesn't seem to be the usual signed shift. */
61
: (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
63
/* The extra casts in the following macros work around compiler bugs,
64
e.g., in Cray C 5.0.3.0. */
66
/* True if the arithmetic type T is an integer type. bool counts as
68
#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
70
/* True if negative values of the signed integer type T use two's
71
complement, ones' complement, or signed magnitude representation,
72
respectively. Much GNU code assumes two's complement, but some
73
people like to be portable to all possible C hosts. */
74
#define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)
75
#define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)
76
#define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
78
/* True if the arithmetic type T is signed. */
79
#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
81
/* The maximum and minimum values for the integer type T. These
82
macros have undefined behavior if T is signed and has padding bits.
83
If this is a problem for you, please let us know how to fix it for
85
#define TYPE_MINIMUM(t) \
86
((t) (! TYPE_SIGNED (t) \
88
: TYPE_SIGNED_MAGNITUDE (t) \
90
: ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
91
#define TYPE_MAXIMUM(t) \
92
((t) (! TYPE_SIGNED (t) \
94
: ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
97
# define TIME_T_MIN TYPE_MINIMUM (time_t)
100
# define TIME_T_MAX TYPE_MAXIMUM (time_t)
102
#define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
104
/* Verify a requirement at compile-time (unlike assert, which is runtime). */
105
#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
107
verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
108
verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
109
/* The code also assumes that signed integer overflow silently wraps
110
around, but this assumption can't be stated without causing a
111
diagnostic on some hosts. */
113
#define EPOCH_YEAR 1970
114
#define TM_YEAR_BASE 1900
115
verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
117
/* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
119
leapyear (long int year)
121
/* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
122
Also, work even if YEAR is negative. */
126
|| ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
129
/* How many days come before each month (0-12). */
133
const unsigned short int __mon_yday[2][13] =
136
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
138
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
143
/* Portable standalone applications should supply a <time.h> that
144
declares a POSIX-compliant localtime_r, for the benefit of older
145
implementations that lack localtime_r or have a nonstandard one.
146
See the gnulib time_r module for one way to implement this. */
147
# undef __localtime_r
148
# define __localtime_r localtime_r
149
# define __mktime_internal mktime_internal
152
/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
153
(YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
154
were not adjusted between the time stamps.
156
The YEAR values uses the same numbering as TP->tm_year. Values
157
need not be in the usual range. However, YEAR1 must not be less
158
than 2 * INT_MIN or greater than 2 * INT_MAX.
160
The result may overflow. It is the caller's responsibility to
164
ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
165
int year0, int yday0, int hour0, int min0, int sec0)
167
verify (C99_integer_division, -1 / 2 == 0);
168
verify (long_int_year_and_yday_are_wide_enough,
169
INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
171
/* Compute intervening leap days correctly even if year is negative.
172
Take care to avoid integer overflow here. */
173
int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3);
174
int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3);
175
int a100 = a4 / 25 - (a4 % 25 < 0);
176
int b100 = b4 / 25 - (b4 % 25 < 0);
177
int a400 = SHR (a100, 2);
178
int b400 = SHR (b100, 2);
179
int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
181
/* Compute the desired time in time_t precision. Overflow might
183
time_t tyear1 = year1;
184
time_t years = tyear1 - year0;
185
time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;
186
time_t hours = 24 * days + hour1 - hour0;
187
time_t minutes = 60 * hours + min1 - min0;
188
time_t seconds = 60 * minutes + sec1 - sec0;
193
/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
194
assuming that *T corresponds to *TP and that no clock adjustments
195
occurred between *TP and the desired time.
196
If TP is null, return a value not equal to *T; this avoids false matches.
197
If overflow occurs, yield the minimal or maximal value, except do not
198
yield a value equal to *T. */
200
guess_time_tm (long int year, long int yday, int hour, int min, int sec,
201
const time_t *t, const struct tm *tp)
205
time_t d = ydhms_diff (year, yday, hour, min, sec,
206
tp->tm_year, tp->tm_yday,
207
tp->tm_hour, tp->tm_min, tp->tm_sec);
209
if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
213
/* Overflow occurred one way or another. Return the nearest result
214
that is actually in range, except don't report a zero difference
215
if the actual difference is nonzero, as that would cause a false
216
match; and don't oscillate between two values, as that would
217
confuse the spring-forward gap detector. */
218
return (*t < TIME_T_MIDPOINT
219
? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
220
: (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
223
/* Use CONVERT to convert *T to a broken down time in *TP.
224
If *T is out of range for conversion, adjust it so that
225
it is the nearest in-range value and then convert that. */
227
ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
228
time_t *t, struct tm *tp)
230
struct tm *r = convert (t, tp);
237
/* BAD is a known unconvertible time_t, and OK is a known good one.
238
Use binary search to narrow the range between BAD and OK until
240
while (bad != ok + (bad < 0 ? -1 : 1))
242
time_t mid = *t = (bad < 0
243
? bad + ((ok - bad) >> 1)
244
: ok + ((bad - ok) >> 1));
254
/* The last conversion attempt failed;
255
revert to the most recent successful attempt. */
265
/* Convert *TP to a time_t value, inverting
266
the monotonic and mostly-unit-linear conversion function CONVERT.
267
Use *OFFSET to keep track of a guess at the offset of the result,
268
compared to what the result would be for UTC without leap seconds.
269
If *OFFSET's guess is correct, only one CONVERT call is needed.
270
This function is external because it is used also by timegm.c. */
272
__mktime_internal (struct tm *tp,
273
struct tm *(*convert) (const time_t *, struct tm *),
276
time_t t, gt, t0, t1, t2;
279
/* The maximum number of probes (calls to CONVERT) should be enough
280
to handle any combinations of time zone rule changes, solar time,
281
leap seconds, and oscillations around a spring-forward gap.
282
POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
283
int remaining_probes = 6;
285
/* Time requested. Copy it in case CONVERT modifies *TP; this can
286
occur if TP is localtime's returned value and CONVERT is localtime. */
287
int sec = tp->tm_sec;
288
int min = tp->tm_min;
289
int hour = tp->tm_hour;
290
int mday = tp->tm_mday;
291
int mon = tp->tm_mon;
292
int year_requested = tp->tm_year;
293
int isdst = tp->tm_isdst;
295
/* 1 if the previous probe was DST. */
298
/* Ensure that mon is in range, and set year accordingly. */
299
int mon_remainder = mon % 12;
300
int negative_mon_remainder = mon_remainder < 0;
301
int mon_years = mon / 12 - negative_mon_remainder;
302
long int lyear_requested = year_requested;
303
long int year = lyear_requested + mon_years;
305
/* The other values need not be in range:
306
the remaining code handles minor overflows correctly,
307
assuming int and time_t arithmetic wraps around.
308
Major overflows are caught at the end. */
310
/* Calculate day of year from year, month, and day of month.
311
The result need not be in range. */
312
int mon_yday = ((__mon_yday[leapyear (year)]
313
[mon_remainder + 12 * negative_mon_remainder])
315
long int lmday = mday;
316
long int yday = mon_yday + lmday;
318
time_t guessed_offset = *offset;
320
int sec_requested = sec;
322
if (LEAP_SECONDS_POSSIBLE)
324
/* Handle out-of-range seconds specially,
325
since ydhms_tm_diff assumes every minute has 60 seconds. */
332
/* Invert CONVERT by probing. First assume the same offset as last
335
t0 = ydhms_diff (year, yday, hour, min, sec,
336
EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
338
if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
340
/* time_t isn't large enough to rule out overflows, so check
341
for major overflows. A gross check suffices, since if t0
342
has overflowed, it is off by a multiple of TIME_T_MAX -
343
TIME_T_MIN + 1. So ignore any component of the difference
344
that is bounded by a small value. */
346
/* Approximate log base 2 of the number of time units per
347
biennium. A biennium is 2 years; use this unit instead of
348
years to avoid integer overflow. For example, 2 average
349
Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
350
which is 63113904 seconds, and rint (log2 (63113904)) is
352
int ALOG2_SECONDS_PER_BIENNIUM = 26;
353
int ALOG2_MINUTES_PER_BIENNIUM = 20;
354
int ALOG2_HOURS_PER_BIENNIUM = 14;
355
int ALOG2_DAYS_PER_BIENNIUM = 10;
356
int LOG2_YEARS_PER_BIENNIUM = 1;
358
int approx_requested_biennia =
359
(SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
360
- SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
361
+ SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
362
+ SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
363
+ SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
364
+ (LEAP_SECONDS_POSSIBLE
366
: SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
368
int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
369
int diff = approx_biennia - approx_requested_biennia;
370
int abs_diff = diff < 0 ? - diff : diff;
372
/* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
373
gives a positive value of 715827882. Setting a variable
374
first then doing math on it seems to work.
375
(ghazi@caip.rutgers.edu) */
376
time_t time_t_max = TIME_T_MAX;
377
time_t time_t_min = TIME_T_MIN;
378
time_t overflow_threshold =
379
(time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
381
if (overflow_threshold < abs_diff)
383
/* Overflow occurred. Try repairing it; this might work if
384
the time zone offset is enough to undo the overflow. */
385
time_t repaired_t0 = -1 - t0;
386
approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
387
diff = approx_biennia - approx_requested_biennia;
388
abs_diff = diff < 0 ? - diff : diff;
389
if (overflow_threshold < abs_diff)
391
guessed_offset += repaired_t0 - t0;
396
/* Repeatedly use the error to improve the guess. */
398
for (t = t1 = t2 = t0, dst2 = 0;
399
(gt = guess_time_tm (year, yday, hour, min, sec, &t,
400
ranged_convert (convert, &t, &tm)),
402
t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
403
if (t == t1 && t != t2
406
? dst2 <= (tm.tm_isdst != 0)
407
: (isdst != 0) != (tm.tm_isdst != 0))))
408
/* We can't possibly find a match, as we are oscillating
409
between two values. The requested time probably falls
410
within a spring-forward gap of size GT - T. Follow the common
411
practice in this case, which is to return a time that is GT - T
412
away from the requested time, preferring a time whose
413
tm_isdst differs from the requested value. (If no tm_isdst
414
was requested and only one of the two values has a nonzero
415
tm_isdst, prefer that value.) In practice, this is more
416
useful than returning -1. */
418
else if (--remaining_probes == 0)
421
/* We have a match. Check whether tm.tm_isdst has the requested
423
if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
425
/* tm.tm_isdst has the wrong value. Look for a neighboring
426
time with the right value, and use its UTC offset.
428
Heuristic: probe the adjacent timestamps in both directions,
429
looking for the desired isdst. This should work for all real
430
time zone histories in the tz database. */
432
/* Distance between probes when looking for a DST boundary. In
433
tzdata2003a, the shortest period of DST is 601200 seconds
434
(e.g., America/Recife starting 2000-10-08 01:00), and the
435
shortest period of non-DST surrounded by DST is 694800
436
seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
437
minimum of these two values, so we don't miss these short
438
periods when probing. */
441
/* The longest period of DST in tzdata2003a is 536454000 seconds
442
(e.g., America/Jujuy starting 1946-10-01 01:00). The longest
443
period of non-DST is much longer, but it makes no real sense
444
to search for more than a year of non-DST, so use the DST
446
int duration_max = 536454000;
448
/* Search in both directions, so the maximum distance is half
449
the duration; add the stride to avoid off-by-1 problems. */
450
int delta_bound = duration_max / 2 + stride;
452
int delta, direction;
454
for (delta = stride; delta < delta_bound; delta += stride)
455
for (direction = -1; direction <= 1; direction += 2)
457
time_t ot = t + delta * direction;
458
if ((ot < t) == (direction < 0))
461
ranged_convert (convert, &ot, &otm);
462
if (otm.tm_isdst == isdst)
464
/* We found the desired tm_isdst.
465
Extrapolate back to the desired time. */
466
t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
467
ranged_convert (convert, &t, &tm);
475
*offset = guessed_offset + t - t0;
477
if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
479
/* Adjust time to reflect the tm_sec requested, not the normalized value.
480
Also, repair any damage from a false match due to a leap second. */
481
int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
482
t1 = t + sec_requested;
483
t2 = t1 + sec_adjustment;
484
if (((t1 < t) != (sec_requested < 0))
485
| ((t2 < t1) != (sec_adjustment < 0))
486
| ! convert (&t2, &tm))
496
/* FIXME: This should use a signed type wide enough to hold any UTC
497
offset in seconds. 'int' should be good enough for GNU code. We
498
can't fix this unilaterally though, as other modules invoke
499
__mktime_internal. */
500
static time_t localtime_offset;
502
/* Convert *TP to a time_t value. */
504
mktime (struct tm *tp)
507
/* POSIX.1 8.1.1 requires that whenever mktime() is called, the
508
time zone names contained in the external variable `tzname' shall
509
be set as if the tzset() function had been called. */
513
return __mktime_internal (tp, __localtime_r, &localtime_offset);
517
weak_alias (mktime, timelocal)
521
libc_hidden_def (mktime)
522
libc_hidden_weak (timelocal)
528
not_equal_tm (const struct tm *a, const struct tm *b)
530
return ((a->tm_sec ^ b->tm_sec)
531
| (a->tm_min ^ b->tm_min)
532
| (a->tm_hour ^ b->tm_hour)
533
| (a->tm_mday ^ b->tm_mday)
534
| (a->tm_mon ^ b->tm_mon)
535
| (a->tm_year ^ b->tm_year)
536
| (a->tm_yday ^ b->tm_yday)
537
| (a->tm_isdst ^ b->tm_isdst));
541
print_tm (const struct tm *tp)
544
printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
545
tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
546
tp->tm_hour, tp->tm_min, tp->tm_sec,
547
tp->tm_yday, tp->tm_wday, tp->tm_isdst);
553
check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
555
if (tk != tl || !lt || not_equal_tm (&tmk, lt))
559
printf (")\nyields (");
561
printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
569
main (int argc, char **argv)
572
struct tm tm, tmk, tml;
577
if ((argc == 3 || argc == 4)
578
&& (sscanf (argv[1], "%d-%d-%d%c",
579
&tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
581
&& (sscanf (argv[2], "%d:%d:%d%c",
582
&tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
585
tm.tm_year -= TM_YEAR_BASE;
587
tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
590
lt = localtime (&tl);
596
printf ("mktime returns %ld == ", (long int) tl);
599
status = check_result (tl, tmk, tl, lt);
601
else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
603
time_t from = atol (argv[1]);
604
time_t by = atol (argv[2]);
605
time_t to = atol (argv[3]);
608
for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
610
lt = localtime (&tl);
615
status |= check_result (tk, tmk, tl, &tml);
619
printf ("localtime (%ld) yields 0\n", (long int) tl);
623
if ((tl1 < tl) != (by < 0))
627
for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
629
/* Null benchmark. */
630
lt = localtime (&tl);
635
status |= check_result (tk, tmk, tl, &tml);
639
printf ("localtime (%ld) yields 0\n", (long int) tl);
643
if ((tl1 < tl) != (by < 0))
649
\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
650
\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
651
\t%s FROM BY TO - # Do not test those values (for benchmark).\n",
652
argv[0], argv[0], argv[0]);
661
compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"
added
removed
gnulib/mktime.c
