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-2007, 2009-2010 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
152
# include "mktime-internal.h"
155
/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
156
(YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
157
were not adjusted between the time stamps.
159
The YEAR values uses the same numbering as TP->tm_year. Values
160
need not be in the usual range. However, YEAR1 must not be less
161
than 2 * INT_MIN or greater than 2 * INT_MAX.
163
The result may overflow. It is the caller's responsibility to
167
ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
168
int year0, int yday0, int hour0, int min0, int sec0)
170
verify (C99_integer_division, -1 / 2 == 0);
171
#if 0 /* This assertion fails on 32-bit systems with 64-bit time_t, such as
173
verify (long_int_year_and_yday_are_wide_enough,
174
INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
177
/* Compute intervening leap days correctly even if year is negative.
178
Take care to avoid integer overflow here. */
179
int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3);
180
int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3);
181
int a100 = a4 / 25 - (a4 % 25 < 0);
182
int b100 = b4 / 25 - (b4 % 25 < 0);
183
int a400 = SHR (a100, 2);
184
int b400 = SHR (b100, 2);
185
int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
187
/* Compute the desired time in time_t precision. Overflow might
189
time_t tyear1 = year1;
190
time_t years = tyear1 - year0;
191
time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;
192
time_t hours = 24 * days + hour1 - hour0;
193
time_t minutes = 60 * hours + min1 - min0;
194
time_t seconds = 60 * minutes + sec1 - sec0;
199
/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
200
assuming that *T corresponds to *TP and that no clock adjustments
201
occurred between *TP and the desired time.
202
If TP is null, return a value not equal to *T; this avoids false matches.
203
If overflow occurs, yield the minimal or maximal value, except do not
204
yield a value equal to *T. */
206
guess_time_tm (long int year, long int yday, int hour, int min, int sec,
207
const time_t *t, const struct tm *tp)
211
time_t d = ydhms_diff (year, yday, hour, min, sec,
212
tp->tm_year, tp->tm_yday,
213
tp->tm_hour, tp->tm_min, tp->tm_sec);
215
if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
219
/* Overflow occurred one way or another. Return the nearest result
220
that is actually in range, except don't report a zero difference
221
if the actual difference is nonzero, as that would cause a false
222
match; and don't oscillate between two values, as that would
223
confuse the spring-forward gap detector. */
224
return (*t < TIME_T_MIDPOINT
225
? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
226
: (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
229
/* Use CONVERT to convert *T to a broken down time in *TP.
230
If *T is out of range for conversion, adjust it so that
231
it is the nearest in-range value and then convert that. */
233
ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
234
time_t *t, struct tm *tp)
236
struct tm *r = convert (t, tp);
243
/* BAD is a known unconvertible time_t, and OK is a known good one.
244
Use binary search to narrow the range between BAD and OK until
246
while (bad != ok + (bad < 0 ? -1 : 1))
248
time_t mid = *t = (bad < 0
249
? bad + ((ok - bad) >> 1)
250
: ok + ((bad - ok) >> 1));
260
/* The last conversion attempt failed;
261
revert to the most recent successful attempt. */
271
/* Convert *TP to a time_t value, inverting
272
the monotonic and mostly-unit-linear conversion function CONVERT.
273
Use *OFFSET to keep track of a guess at the offset of the result,
274
compared to what the result would be for UTC without leap seconds.
275
If *OFFSET's guess is correct, only one CONVERT call is needed.
276
This function is external because it is used also by timegm.c. */
278
__mktime_internal (struct tm *tp,
279
struct tm *(*convert) (const time_t *, struct tm *),
282
time_t t, gt, t0, t1, t2;
285
/* The maximum number of probes (calls to CONVERT) should be enough
286
to handle any combinations of time zone rule changes, solar time,
287
leap seconds, and oscillations around a spring-forward gap.
288
POSIX.1 prohibits leap seconds, but some hosts have them anyway. */
289
int remaining_probes = 6;
291
/* Time requested. Copy it in case CONVERT modifies *TP; this can
292
occur if TP is localtime's returned value and CONVERT is localtime. */
293
int sec = tp->tm_sec;
294
int min = tp->tm_min;
295
int hour = tp->tm_hour;
296
int mday = tp->tm_mday;
297
int mon = tp->tm_mon;
298
int year_requested = tp->tm_year;
299
/* Normalize the value. */
300
int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))
301
| (tp->tm_isdst != 0));
303
/* 1 if the previous probe was DST. */
306
/* Ensure that mon is in range, and set year accordingly. */
307
int mon_remainder = mon % 12;
308
int negative_mon_remainder = mon_remainder < 0;
309
int mon_years = mon / 12 - negative_mon_remainder;
310
long int lyear_requested = year_requested;
311
long int year = lyear_requested + mon_years;
313
/* The other values need not be in range:
314
the remaining code handles minor overflows correctly,
315
assuming int and time_t arithmetic wraps around.
316
Major overflows are caught at the end. */
318
/* Calculate day of year from year, month, and day of month.
319
The result need not be in range. */
320
int mon_yday = ((__mon_yday[leapyear (year)]
321
[mon_remainder + 12 * negative_mon_remainder])
323
long int lmday = mday;
324
long int yday = mon_yday + lmday;
326
time_t guessed_offset = *offset;
328
int sec_requested = sec;
330
if (LEAP_SECONDS_POSSIBLE)
332
/* Handle out-of-range seconds specially,
333
since ydhms_tm_diff assumes every minute has 60 seconds. */
340
/* Invert CONVERT by probing. First assume the same offset as last
343
t0 = ydhms_diff (year, yday, hour, min, sec,
344
EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
346
if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
348
/* time_t isn't large enough to rule out overflows, so check
349
for major overflows. A gross check suffices, since if t0
350
has overflowed, it is off by a multiple of TIME_T_MAX -
351
TIME_T_MIN + 1. So ignore any component of the difference
352
that is bounded by a small value. */
354
/* Approximate log base 2 of the number of time units per
355
biennium. A biennium is 2 years; use this unit instead of
356
years to avoid integer overflow. For example, 2 average
357
Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
358
which is 63113904 seconds, and rint (log2 (63113904)) is
360
int ALOG2_SECONDS_PER_BIENNIUM = 26;
361
int ALOG2_MINUTES_PER_BIENNIUM = 20;
362
int ALOG2_HOURS_PER_BIENNIUM = 14;
363
int ALOG2_DAYS_PER_BIENNIUM = 10;
364
int LOG2_YEARS_PER_BIENNIUM = 1;
366
int approx_requested_biennia =
367
(SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
368
- SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
369
+ SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
370
+ SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
371
+ SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
372
+ (LEAP_SECONDS_POSSIBLE
374
: SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
376
int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
377
int diff = approx_biennia - approx_requested_biennia;
378
int abs_diff = diff < 0 ? - diff : diff;
380
/* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
381
gives a positive value of 715827882. Setting a variable
382
first then doing math on it seems to work.
383
(ghazi@caip.rutgers.edu) */
384
time_t time_t_max = TIME_T_MAX;
385
time_t time_t_min = TIME_T_MIN;
386
time_t overflow_threshold =
387
(time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
389
if (overflow_threshold < abs_diff)
391
/* Overflow occurred. Try repairing it; this might work if
392
the time zone offset is enough to undo the overflow. */
393
time_t repaired_t0 = -1 - t0;
394
approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
395
diff = approx_biennia - approx_requested_biennia;
396
abs_diff = diff < 0 ? - diff : diff;
397
if (overflow_threshold < abs_diff)
399
guessed_offset += repaired_t0 - t0;
404
/* Repeatedly use the error to improve the guess. */
406
for (t = t1 = t2 = t0, dst2 = 0;
407
(gt = guess_time_tm (year, yday, hour, min, sec, &t,
408
ranged_convert (convert, &t, &tm)),
410
t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
411
if (t == t1 && t != t2
414
? dst2 <= (tm.tm_isdst != 0)
415
: (isdst != 0) != (tm.tm_isdst != 0))))
416
/* We can't possibly find a match, as we are oscillating
417
between two values. The requested time probably falls
418
within a spring-forward gap of size GT - T. Follow the common
419
practice in this case, which is to return a time that is GT - T
420
away from the requested time, preferring a time whose
421
tm_isdst differs from the requested value. (If no tm_isdst
422
was requested and only one of the two values has a nonzero
423
tm_isdst, prefer that value.) In practice, this is more
424
useful than returning -1. */
426
else if (--remaining_probes == 0)
429
/* We have a match. Check whether tm.tm_isdst has the requested
431
if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
433
/* tm.tm_isdst has the wrong value. Look for a neighboring
434
time with the right value, and use its UTC offset.
436
Heuristic: probe the adjacent timestamps in both directions,
437
looking for the desired isdst. This should work for all real
438
time zone histories in the tz database. */
440
/* Distance between probes when looking for a DST boundary. In
441
tzdata2003a, the shortest period of DST is 601200 seconds
442
(e.g., America/Recife starting 2000-10-08 01:00), and the
443
shortest period of non-DST surrounded by DST is 694800
444
seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
445
minimum of these two values, so we don't miss these short
446
periods when probing. */
449
/* The longest period of DST in tzdata2003a is 536454000 seconds
450
(e.g., America/Jujuy starting 1946-10-01 01:00). The longest
451
period of non-DST is much longer, but it makes no real sense
452
to search for more than a year of non-DST, so use the DST
454
int duration_max = 536454000;
456
/* Search in both directions, so the maximum distance is half
457
the duration; add the stride to avoid off-by-1 problems. */
458
int delta_bound = duration_max / 2 + stride;
460
int delta, direction;
462
for (delta = stride; delta < delta_bound; delta += stride)
463
for (direction = -1; direction <= 1; direction += 2)
465
time_t ot = t + delta * direction;
466
if ((ot < t) == (direction < 0))
469
ranged_convert (convert, &ot, &otm);
470
if (otm.tm_isdst == isdst)
472
/* We found the desired tm_isdst.
473
Extrapolate back to the desired time. */
474
t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
475
ranged_convert (convert, &t, &tm);
483
*offset = guessed_offset + t - t0;
485
if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
487
/* Adjust time to reflect the tm_sec requested, not the normalized value.
488
Also, repair any damage from a false match due to a leap second. */
489
int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
490
t1 = t + sec_requested;
491
t2 = t1 + sec_adjustment;
492
if (((t1 < t) != (sec_requested < 0))
493
| ((t2 < t1) != (sec_adjustment < 0))
494
| ! convert (&t2, &tm))
504
/* FIXME: This should use a signed type wide enough to hold any UTC
505
offset in seconds. 'int' should be good enough for GNU code. We
506
can't fix this unilaterally though, as other modules invoke
507
__mktime_internal. */
508
static time_t localtime_offset;
510
/* Convert *TP to a time_t value. */
512
mktime (struct tm *tp)
515
/* POSIX.1 8.1.1 requires that whenever mktime() is called, the
516
time zone names contained in the external variable `tzname' shall
517
be set as if the tzset() function had been called. */
521
return __mktime_internal (tp, __localtime_r, &localtime_offset);
525
weak_alias (mktime, timelocal)
529
libc_hidden_def (mktime)
530
libc_hidden_weak (timelocal)
536
not_equal_tm (const struct tm *a, const struct tm *b)
538
return ((a->tm_sec ^ b->tm_sec)
539
| (a->tm_min ^ b->tm_min)
540
| (a->tm_hour ^ b->tm_hour)
541
| (a->tm_mday ^ b->tm_mday)
542
| (a->tm_mon ^ b->tm_mon)
543
| (a->tm_year ^ b->tm_year)
544
| (a->tm_yday ^ b->tm_yday)
545
| (a->tm_isdst ^ b->tm_isdst));
549
print_tm (const struct tm *tp)
552
printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
553
tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
554
tp->tm_hour, tp->tm_min, tp->tm_sec,
555
tp->tm_yday, tp->tm_wday, tp->tm_isdst);
561
check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
563
if (tk != tl || !lt || not_equal_tm (&tmk, lt))
567
printf (")\nyields (");
569
printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
577
main (int argc, char **argv)
580
struct tm tm, tmk, tml;
585
if ((argc == 3 || argc == 4)
586
&& (sscanf (argv[1], "%d-%d-%d%c",
587
&tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
589
&& (sscanf (argv[2], "%d:%d:%d%c",
590
&tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
593
tm.tm_year -= TM_YEAR_BASE;
595
tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
598
lt = localtime (&tl);
604
printf ("mktime returns %ld == ", (long int) tl);
607
status = check_result (tl, tmk, tl, lt);
609
else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
611
time_t from = atol (argv[1]);
612
time_t by = atol (argv[2]);
613
time_t to = atol (argv[3]);
616
for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
618
lt = localtime (&tl);
623
status |= check_result (tk, tmk, tl, &tml);
627
printf ("localtime (%ld) yields 0\n", (long int) tl);
631
if ((tl1 < tl) != (by < 0))
635
for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
637
/* Null benchmark. */
638
lt = localtime (&tl);
643
status |= check_result (tk, tmk, tl, &tml);
647
printf ("localtime (%ld) yields 0\n", (long int) tl);
651
if ((tl1 < tl) != (by < 0))
657
\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
658
\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
659
\t%s FROM BY TO - # Do not test those values (for benchmark).\n",
660
argv[0], argv[0], argv[0]);
669
compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"
added
removed
lib/mktime.c
