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. */
24
/* Assume that leap seconds are possible, unless told otherwise.
25
If the host has a `zic' command with a `-L leapsecondfilename' option,
26
then it supports leap seconds; otherwise it probably doesn't. */
27
#ifndef LEAP_SECONDS_POSSIBLE
28
# define LEAP_SECONDS_POSSIBLE 1
35
#include <string.h> /* For the real memcpy prototype. */
38
/* Shift A right by B bits portably, by dividing A by 2**B and
39
truncating towards minus infinity. A and B should be free of side
40
effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
41
INT_BITS is the number of useful bits in an int. GNU code can
42
assume that INT_BITS is at least 32.
44
ISO C99 says that A >> B is implementation-defined if A < 0. Some
45
implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
46
right in the usual way when A < 0, so SHR falls back on division if
47
ordinary A >> B doesn't seem to be the usual signed shift. */
51
: (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
53
/* The extra casts in the following macros work around compiler bugs,
54
e.g., in Cray C 5.0.3.0. */
56
/* True if the arithmetic type T is an integer type. bool counts as
58
#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
60
/* True if negative values of the signed integer type T use two's
61
complement, ones' complement, or signed magnitude representation,
62
respectively. Much GNU code assumes two's complement, but some
63
people like to be portable to all possible C hosts. */
64
#define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)
65
#define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)
66
#define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
68
/* True if the arithmetic type T is signed. */
69
#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
71
/* The maximum and minimum values for the integer type T. These
72
macros have undefined behavior if T is signed and has padding bits.
73
If this is a problem for you, please let us know how to fix it for
75
#define TYPE_MINIMUM(t) \
76
((t) (! TYPE_SIGNED (t) \
78
: TYPE_SIGNED_MAGNITUDE (t) \
80
: ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
81
#define TYPE_MAXIMUM(t) \
82
((t) (! TYPE_SIGNED (t) \
84
: ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
87
# define TIME_T_MIN TYPE_MINIMUM (time_t)
90
# define TIME_T_MAX TYPE_MAXIMUM (time_t)
92
#define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
94
/* Verify a requirement at compile-time (unlike assert, which is runtime). */
95
#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
97
verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
98
verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
99
/* The code also assumes that signed integer overflow silently wraps
100
around, but this assumption can't be stated without causing a
101
diagnostic on some hosts. */
103
#define EPOCH_YEAR 1970
104
#define TM_YEAR_BASE 1900
105
verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
107
/* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
109
leapyear (long int year)
111
/* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
112
Also, work even if YEAR is negative. */
116
|| ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
119
/* How many days come before each month (0-12). */
123
const unsigned short int __mon_yday[2][13] =
126
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
128
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
133
/* Portable standalone applications should supply a <time.h> that
134
declares a POSIX-compliant localtime_r, for the benefit of older
135
implementations that lack localtime_r or have a nonstandard one.
136
See the gnulib time_r module for one way to implement this. */
137
# undef __localtime_r
138
# define __localtime_r localtime_r
139
# define __mktime_internal mktime_internal
142
/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
143
(YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
144
were not adjusted between the time stamps.
146
The YEAR values uses the same numbering as TP->tm_year. Values
147
need not be in the usual range. However, YEAR1 must not be less
148
than 2 * INT_MIN or greater than 2 * INT_MAX.
150
The result may overflow. It is the caller's responsibility to
154
ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
155
int year0, int yday0, int hour0, int min0, int sec0)
157
verify (C99_integer_division, -1 / 2 == 0);
158
verify (long_int_year_and_yday_are_wide_enough,
159
INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
161
/* Compute intervening leap days correctly even if year is negative.
162
Take care to avoid integer overflow here. */
163
int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3);
164
int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3);
165
int a100 = a4 / 25 - (a4 % 25 < 0);
166
int b100 = b4 / 25 - (b4 % 25 < 0);
167
int a400 = SHR (a100, 2);
168
int b400 = SHR (b100, 2);
169
int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
171
/* Compute the desired time in time_t precision. Overflow might
173
time_t tyear1 = year1;
174
time_t years = tyear1 - year0;
175
time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;
176
time_t hours = 24 * days + hour1 - hour0;
177
time_t minutes = 60 * hours + min1 - min0;
178
time_t seconds = 60 * minutes + sec1 - sec0;
183
/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
184
assuming that *T corresponds to *TP and that no clock adjustments
185
occurred between *TP and the desired time.
186
If TP is null, return a value not equal to *T; this avoids false matches.
187
If overflow occurs, yield the minimal or maximal value, except do not
188
yield a value equal to *T. */
190
guess_time_tm (long int year, long int yday, int hour, int min, int sec,
191
const time_t *t, const struct tm *tp)
195
time_t d = ydhms_diff (year, yday, hour, min, sec,
196
tp->tm_year, tp->tm_yday,
197
tp->tm_hour, tp->tm_min, tp->tm_sec);
199
if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
203
/* Overflow occurred one way or another. Return the nearest result
204
that is actually in range, except don't report a zero difference
205
if the actual difference is nonzero, as that would cause a false
206
match; and don't oscillate between two values, as that would
207
confuse the spring-forward gap detector. */
208
return (*t < TIME_T_MIDPOINT
209
? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
210
: (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
213
/* Use CONVERT to convert *T to a broken down time in *TP.
214
If *T is out of range for conversion, adjust it so that
215
it is the nearest in-range value and then convert that. */
217
ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
218
time_t *t, struct tm *tp)
220
struct tm *r = convert (t, tp);
227
/* BAD is a known unconvertible time_t, and OK is a known good one.
228
Use binary search to narrow the range between BAD and OK until
230
while (bad != ok + (bad < 0 ? -1 : 1))
232
time_t mid = *t = (bad < 0
233
? bad + ((ok - bad) >> 1)
234
: ok + ((bad - ok) >> 1));
244
/* The last conversion attempt failed;
245
revert to the most recent successful attempt. */
256
__mktime_internal (struct tm *tp,
257
struct tm *(*convert) (const time_t *, struct tm *),
259
/* Convert *TP to a time_t value, inverting
260
the monotonic and mostly-unit-linear conversion function CONVERT.
261
Use *OFFSET to keep track of a guess at the offset of the result,
262
compared to what the result would be for UTC without leap seconds.
263
If *OFFSET's guess is correct, only one CONVERT call is needed.
264
This function is external because it is used also by timegm.c. */
266
__mktime_internal (struct tm *tp,
267
struct tm *(*convert) (const time_t *, struct tm *),
270
time_t t, gt, t0, t1, t2;
273
/* The maximum number of probes (calls to CONVERT) should be enough
274
to handle any combinations of time zone rule changes, solar time,
275
leap seconds, and oscillations around a spring-forward gap.
276
POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
277
int remaining_probes = 6;
279
/* Time requested. Copy it in case CONVERT modifies *TP; this can
280
occur if TP is localtime's returned value and CONVERT is localtime. */
281
int sec = tp->tm_sec;
282
int min = tp->tm_min;
283
int hour = tp->tm_hour;
284
int mday = tp->tm_mday;
285
int mon = tp->tm_mon;
286
int year_requested = tp->tm_year;
287
/* Normalize the value. */
288
int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))
289
| (tp->tm_isdst != 0));
291
/* 1 if the previous probe was DST. */
294
/* Ensure that mon is in range, and set year accordingly. */
295
int mon_remainder = mon % 12;
296
int negative_mon_remainder = mon_remainder < 0;
297
int mon_years = mon / 12 - negative_mon_remainder;
298
long int lyear_requested = year_requested;
299
long int year = lyear_requested + mon_years;
301
/* The other values need not be in range:
302
the remaining code handles minor overflows correctly,
303
assuming int and time_t arithmetic wraps around.
304
Major overflows are caught at the end. */
306
/* Calculate day of year from year, month, and day of month.
307
The result need not be in range. */
308
int mon_yday = ((__mon_yday[leapyear (year)]
309
[mon_remainder + 12 * negative_mon_remainder])
311
long int lmday = mday;
312
long int yday = mon_yday + lmday;
314
time_t guessed_offset = *offset;
316
int sec_requested = sec;
318
if (LEAP_SECONDS_POSSIBLE)
320
/* Handle out-of-range seconds specially,
321
since ydhms_tm_diff assumes every minute has 60 seconds. */
328
/* Invert CONVERT by probing. First assume the same offset as last
331
t0 = ydhms_diff (year, yday, hour, min, sec,
332
EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
334
if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
336
/* time_t isn't large enough to rule out overflows, so check
337
for major overflows. A gross check suffices, since if t0
338
has overflowed, it is off by a multiple of TIME_T_MAX -
339
TIME_T_MIN + 1. So ignore any component of the difference
340
that is bounded by a small value. */
342
/* Approximate log base 2 of the number of time units per
343
biennium. A biennium is 2 years; use this unit instead of
344
years to avoid integer overflow. For example, 2 average
345
Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
346
which is 63113904 seconds, and rint (log2 (63113904)) is
348
int ALOG2_SECONDS_PER_BIENNIUM = 26;
349
int ALOG2_MINUTES_PER_BIENNIUM = 20;
350
int ALOG2_HOURS_PER_BIENNIUM = 14;
351
int ALOG2_DAYS_PER_BIENNIUM = 10;
352
int LOG2_YEARS_PER_BIENNIUM = 1;
354
int approx_requested_biennia =
355
(SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
356
- SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
357
+ SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
358
+ SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
359
+ SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
360
+ (LEAP_SECONDS_POSSIBLE
362
: SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
364
int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
365
int diff = approx_biennia - approx_requested_biennia;
366
int abs_diff = diff < 0 ? - diff : diff;
368
/* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
369
gives a positive value of 715827882. Setting a variable
370
first then doing math on it seems to work.
371
(ghazi@caip.rutgers.edu) */
372
time_t time_t_max = TIME_T_MAX;
373
time_t time_t_min = TIME_T_MIN;
374
time_t overflow_threshold =
375
(time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
377
if (overflow_threshold < abs_diff)
379
/* Overflow occurred. Try repairing it; this might work if
380
the time zone offset is enough to undo the overflow. */
381
time_t repaired_t0 = -1 - t0;
382
approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
383
diff = approx_biennia - approx_requested_biennia;
384
abs_diff = diff < 0 ? - diff : diff;
385
if (overflow_threshold < abs_diff)
387
guessed_offset += repaired_t0 - t0;
392
/* Repeatedly use the error to improve the guess. */
394
for (t = t1 = t2 = t0, dst2 = 0;
395
(gt = guess_time_tm (year, yday, hour, min, sec, &t,
396
ranged_convert (convert, &t, &tm)),
398
t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
399
if (t == t1 && t != t2
402
? dst2 <= (tm.tm_isdst != 0)
403
: (isdst != 0) != (tm.tm_isdst != 0))))
404
/* We can't possibly find a match, as we are oscillating
405
between two values. The requested time probably falls
406
within a spring-forward gap of size GT - T. Follow the common
407
practice in this case, which is to return a time that is GT - T
408
away from the requested time, preferring a time whose
409
tm_isdst differs from the requested value. (If no tm_isdst
410
was requested and only one of the two values has a nonzero
411
tm_isdst, prefer that value.) In practice, this is more
412
useful than returning -1. */
414
else if (--remaining_probes == 0)
417
/* We have a match. Check whether tm.tm_isdst has the requested
419
if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
421
/* tm.tm_isdst has the wrong value. Look for a neighboring
422
time with the right value, and use its UTC offset.
424
Heuristic: probe the adjacent timestamps in both directions,
425
looking for the desired isdst. This should work for all real
426
time zone histories in the tz database. */
428
/* Distance between probes when looking for a DST boundary. In
429
tzdata2003a, the shortest period of DST is 601200 seconds
430
(e.g., America/Recife starting 2000-10-08 01:00), and the
431
shortest period of non-DST surrounded by DST is 694800
432
seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
433
minimum of these two values, so we don't miss these short
434
periods when probing. */
437
/* The longest period of DST in tzdata2003a is 536454000 seconds
438
(e.g., America/Jujuy starting 1946-10-01 01:00). The longest
439
period of non-DST is much longer, but it makes no real sense
440
to search for more than a year of non-DST, so use the DST
442
int duration_max = 536454000;
444
/* Search in both directions, so the maximum distance is half
445
the duration; add the stride to avoid off-by-1 problems. */
446
int delta_bound = duration_max / 2 + stride;
448
int delta, direction;
450
for (delta = stride; delta < delta_bound; delta += stride)
451
for (direction = -1; direction <= 1; direction += 2)
453
time_t ot = t + delta * direction;
454
if ((ot < t) == (direction < 0))
457
ranged_convert (convert, &ot, &otm);
458
if (otm.tm_isdst == isdst)
460
/* We found the desired tm_isdst.
461
Extrapolate back to the desired time. */
462
t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
463
ranged_convert (convert, &t, &tm);
471
*offset = guessed_offset + t - t0;
473
if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
475
/* Adjust time to reflect the tm_sec requested, not the normalized value.
476
Also, repair any damage from a false match due to a leap second. */
477
int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
478
t1 = t + sec_requested;
479
t2 = t1 + sec_adjustment;
480
if (((t1 < t) != (sec_requested < 0))
481
| ((t2 < t1) != (sec_adjustment < 0))
482
| ! convert (&t2, &tm))
492
/* FIXME: This should use a signed type wide enough to hold any UTC
493
offset in seconds. 'int' should be good enough for GNU code. We
494
can't fix this unilaterally though, as other modules invoke
495
__mktime_internal. */
496
static time_t localtime_offset;
498
/* Convert *TP to a time_t value. */
500
mktime (struct tm *tp)
503
/* POSIX.1 8.1.1 requires that whenever mktime() is called, the
504
time zone names contained in the external variable `tzname' shall
505
be set as if the tzset() function had been called. */
509
return __mktime_internal (tp, __localtime_r, &localtime_offset);
513
weak_alias (mktime, timelocal)
517
libc_hidden_def (mktime)
518
libc_hidden_weak (timelocal)
added
removed
gnulib/mktime.c
