summaryrefslogtreecommitdiffstats
path: root/gl/mktime.c
diff options
context:
space:
mode:
authorHolger Weiss <holger@zedat.fu-berlin.de>2013-08-19 21:27:12 (GMT)
committerHolger Weiss <holger@zedat.fu-berlin.de>2013-08-19 21:27:12 (GMT)
commit26fbe7f1e68bb0c96da32491efcf3696fe6c299b (patch)
treec4d95289187a64e9c7517bf73d8208026c3d2fb3 /gl/mktime.c
parent5f79e3e9f62ca5487d9881973149136ba1d19d3e (diff)
downloadmonitoring-plugins-26fbe7f1e68bb0c96da32491efcf3696fe6c299b.tar.gz
Sync with the latest Gnulib code (6f2d632)
Diffstat (limited to 'gl/mktime.c')
-rw-r--r--gl/mktime.c544
1 files changed, 308 insertions, 236 deletions
diff --git a/gl/mktime.c b/gl/mktime.c
index b0324b8..e660a23 100644
--- a/gl/mktime.c
+++ b/gl/mktime.c
@@ -1,21 +1,21 @@
1/* Convert a `struct tm' to a time_t value. 1/* Convert a 'struct tm' to a time_t value.
2 Copyright (C) 1993-1999, 2002-2007, 2009-2010 Free Software Foundation, Inc. 2 Copyright (C) 1993-2013 Free Software Foundation, Inc.
3 This file is part of the GNU C Library. 3 This file is part of the GNU C Library.
4 Contributed by Paul Eggert <eggert@twinsun.com>. 4 Contributed by Paul Eggert <eggert@twinsun.com>.
5 5
6 This program is free software; you can redistribute it and/or modify 6 The GNU C Library is free software; you can redistribute it and/or
7 it under the terms of the GNU General Public License as published by 7 modify it under the terms of the GNU General Public
8 the Free Software Foundation; either version 3, or (at your option) 8 License as published by the Free Software Foundation; either
9 any later version. 9 version 3 of the License, or (at your option) any later version.
10 10
11 This program is distributed in the hope that it will be useful, 11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 GNU General Public License for more details. 14 General Public License for more details.
15 15
16 You should have received a copy of the GNU General Public License along 16 You should have received a copy of the GNU General Public
17 with this program; if not, write to the Free Software Foundation, 17 License along with the GNU C Library; if not, see
18 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ 18 <http://www.gnu.org/licenses/>. */
19 19
20/* Define this to have a standalone program to test this implementation of 20/* Define this to have a standalone program to test this implementation of
21 mktime. */ 21 mktime. */
@@ -26,7 +26,7 @@
26#endif 26#endif
27 27
28/* Assume that leap seconds are possible, unless told otherwise. 28/* Assume that leap seconds are possible, unless told otherwise.
29 If the host has a `zic' command with a `-L leapsecondfilename' option, 29 If the host has a 'zic' command with a '-L leapsecondfilename' option,
30 then it supports leap seconds; otherwise it probably doesn't. */ 30 then it supports leap seconds; otherwise it probably doesn't. */
31#ifndef LEAP_SECONDS_POSSIBLE 31#ifndef LEAP_SECONDS_POSSIBLE
32# define LEAP_SECONDS_POSSIBLE 1 32# define LEAP_SECONDS_POSSIBLE 1
@@ -36,15 +36,49 @@
36 36
37#include <limits.h> 37#include <limits.h>
38 38
39#include <string.h> /* For the real memcpy prototype. */ 39#include <string.h> /* For the real memcpy prototype. */
40 40
41#if DEBUG 41#if DEBUG
42# include <stdio.h> 42# include <stdio.h>
43# include <stdlib.h> 43# include <stdlib.h>
44/* Make it work even if the system's libc has its own mktime routine. */ 44/* Make it work even if the system's libc has its own mktime routine. */
45# undef mktime
45# define mktime my_mktime 46# define mktime my_mktime
46#endif /* DEBUG */ 47#endif /* DEBUG */
47 48
49/* Some of the code in this file assumes that signed integer overflow
50 silently wraps around. This assumption can't easily be programmed
51 around, nor can it be checked for portably at compile-time or
52 easily eliminated at run-time.
53
54 Define WRAPV to 1 if the assumption is valid and if
55 #pragma GCC optimize ("wrapv")
56 does not trigger GCC bug 51793
57 <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51793>.
58 Otherwise, define it to 0; this forces the use of slower code that,
59 while not guaranteed by the C Standard, works on all production
60 platforms that we know about. */
61#ifndef WRAPV
62# if (((__GNUC__ == 4 && 4 <= __GNUC_MINOR__) || 4 < __GNUC__) \
63 && defined __GLIBC__)
64# pragma GCC optimize ("wrapv")
65# define WRAPV 1
66# else
67# define WRAPV 0
68# endif
69#endif
70
71/* Verify a requirement at compile-time (unlike assert, which is runtime). */
72#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
73
74/* A signed type that is at least one bit wider than int. */
75#if INT_MAX <= LONG_MAX / 2
76typedef long int long_int;
77#else
78typedef long long int long_int;
79#endif
80verify (long_int_is_wide_enough, INT_MAX == INT_MAX * (long_int) 2 / 2);
81
48/* Shift A right by B bits portably, by dividing A by 2**B and 82/* 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 83 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 84 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
@@ -55,9 +89,11 @@
55 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift 89 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 90 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. */ 91 ordinary A >> B doesn't seem to be the usual signed shift. */
58#define SHR(a, b) \ 92#define SHR(a, b) \
59 (-1 >> 1 == -1 \ 93 ((-1 >> 1 == -1 \
60 ? (a) >> (b) \ 94 && (long_int) -1 >> 1 == -1 \
95 && ((time_t) -1 >> 1 == -1 || ! TYPE_SIGNED (time_t))) \
96 ? (a) >> (b) \
61 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0)) 97 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
62 98
63/* The extra casts in the following macros work around compiler bugs, 99/* The extra casts in the following macros work around compiler bugs,
@@ -68,12 +104,8 @@
68#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1) 104#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
69 105
70/* True if negative values of the signed integer type T use two's 106/* True if negative values of the signed integer type T use two's
71 complement, ones' complement, or signed magnitude representation, 107 complement, or if T is an unsigned integer type. */
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) 108#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)
77 109
78/* True if the arithmetic type T is signed. */ 110/* True if the arithmetic type T is signed. */
79#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1)) 111#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
@@ -84,14 +116,12 @@
84 your host. */ 116 your host. */
85#define TYPE_MINIMUM(t) \ 117#define TYPE_MINIMUM(t) \
86 ((t) (! TYPE_SIGNED (t) \ 118 ((t) (! TYPE_SIGNED (t) \
87 ? (t) 0 \ 119 ? (t) 0 \
88 : TYPE_SIGNED_MAGNITUDE (t) \ 120 : ~ TYPE_MAXIMUM (t)))
89 ? ~ (t) 0 \
90 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
91#define TYPE_MAXIMUM(t) \ 121#define TYPE_MAXIMUM(t) \
92 ((t) (! TYPE_SIGNED (t) \ 122 ((t) (! TYPE_SIGNED (t) \
93 ? (t) -1 \ 123 ? (t) -1 \
94 : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))) 124 : ((((t) 1 << (sizeof (t) * CHAR_BIT - 2)) - 1) * 2 + 1)))
95 125
96#ifndef TIME_T_MIN 126#ifndef TIME_T_MIN
97# define TIME_T_MIN TYPE_MINIMUM (time_t) 127# define TIME_T_MIN TYPE_MINIMUM (time_t)
@@ -101,29 +131,26 @@
101#endif 131#endif
102#define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1) 132#define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
103 133
104/* Verify a requirement at compile-time (unlike assert, which is runtime). */
105#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
106
107verify (time_t_is_integer, TYPE_IS_INTEGER (time_t)); 134verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
108verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int)); 135verify (twos_complement_arithmetic,
109/* The code also assumes that signed integer overflow silently wraps 136 (TYPE_TWOS_COMPLEMENT (int)
110 around, but this assumption can't be stated without causing a 137 && TYPE_TWOS_COMPLEMENT (long_int)
111 diagnostic on some hosts. */ 138 && TYPE_TWOS_COMPLEMENT (time_t)));
112 139
113#define EPOCH_YEAR 1970 140#define EPOCH_YEAR 1970
114#define TM_YEAR_BASE 1900 141#define TM_YEAR_BASE 1900
115verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0); 142verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
116 143
117/* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */ 144/* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */
118static inline int 145static int
119leapyear (long int year) 146leapyear (long_int year)
120{ 147{
121 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow. 148 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
122 Also, work even if YEAR is negative. */ 149 Also, work even if YEAR is negative. */
123 return 150 return
124 ((year & 3) == 0 151 ((year & 3) == 0
125 && (year % 100 != 0 152 && (year % 100 != 0
126 || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3))); 153 || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
127} 154}
128 155
129/* How many days come before each month (0-12). */ 156/* How many days come before each month (0-12). */
@@ -150,6 +177,14 @@ const unsigned short int __mon_yday[2][13] =
150# include "mktime-internal.h" 177# include "mktime-internal.h"
151#endif 178#endif
152 179
180/* Return 1 if the values A and B differ according to the rules for
181 tm_isdst: A and B differ if one is zero and the other positive. */
182static int
183isdst_differ (int a, int b)
184{
185 return (!a != !b) && (0 <= a) && (0 <= b);
186}
187
153/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) - 188/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
154 (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks 189 (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
155 were not adjusted between the time stamps. 190 were not adjusted between the time stamps.
@@ -161,16 +196,11 @@ const unsigned short int __mon_yday[2][13] =
161 The result may overflow. It is the caller's responsibility to 196 The result may overflow. It is the caller's responsibility to
162 detect overflow. */ 197 detect overflow. */
163 198
164static inline time_t 199static time_t
165ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1, 200ydhms_diff (long_int year1, long_int yday1, int hour1, int min1, int sec1,
166 int year0, int yday0, int hour0, int min0, int sec0) 201 int year0, int yday0, int hour0, int min0, int sec0)
167{ 202{
168 verify (C99_integer_division, -1 / 2 == 0); 203 verify (C99_integer_division, -1 / 2 == 0);
169#if 0 /* This assertion fails on 32-bit systems with 64-bit time_t, such as
170 NetBSD 5 on i386. */
171 verify (long_int_year_and_yday_are_wide_enough,
172 INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
173#endif
174 204
175 /* Compute intervening leap days correctly even if year is negative. 205 /* Compute intervening leap days correctly even if year is negative.
176 Take care to avoid integer overflow here. */ 206 Take care to avoid integer overflow here. */
@@ -193,6 +223,53 @@ ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
193 return seconds; 223 return seconds;
194} 224}
195 225
226/* Return the average of A and B, even if A + B would overflow. */
227static time_t
228time_t_avg (time_t a, time_t b)
229{
230 return SHR (a, 1) + SHR (b, 1) + (a & b & 1);
231}
232
233/* Return 1 if A + B does not overflow. If time_t is unsigned and if
234 B's top bit is set, assume that the sum represents A - -B, and
235 return 1 if the subtraction does not wrap around. */
236static int
237time_t_add_ok (time_t a, time_t b)
238{
239 if (! TYPE_SIGNED (time_t))
240 {
241 time_t sum = a + b;
242 return (sum < a) == (TIME_T_MIDPOINT <= b);
243 }
244 else if (WRAPV)
245 {
246 time_t sum = a + b;
247 return (sum < a) == (b < 0);
248 }
249 else
250 {
251 time_t avg = time_t_avg (a, b);
252 return TIME_T_MIN / 2 <= avg && avg <= TIME_T_MAX / 2;
253 }
254}
255
256/* Return 1 if A + B does not overflow. */
257static int
258time_t_int_add_ok (time_t a, int b)
259{
260 verify (int_no_wider_than_time_t, INT_MAX <= TIME_T_MAX);
261 if (WRAPV)
262 {
263 time_t sum = a + b;
264 return (sum < a) == (b < 0);
265 }
266 else
267 {
268 int a_odd = a & 1;
269 time_t avg = SHR (a, 1) + (SHR (b, 1) + (a_odd & b));
270 return TIME_T_MIN / 2 <= avg && avg <= TIME_T_MAX / 2;
271 }
272}
196 273
197/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC), 274/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
198 assuming that *T corresponds to *TP and that no clock adjustments 275 assuming that *T corresponds to *TP and that no clock adjustments
@@ -201,17 +278,16 @@ ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
201 If overflow occurs, yield the minimal or maximal value, except do not 278 If overflow occurs, yield the minimal or maximal value, except do not
202 yield a value equal to *T. */ 279 yield a value equal to *T. */
203static time_t 280static time_t
204guess_time_tm (long int year, long int yday, int hour, int min, int sec, 281guess_time_tm (long_int year, long_int yday, int hour, int min, int sec,
205 const time_t *t, const struct tm *tp) 282 const time_t *t, const struct tm *tp)
206{ 283{
207 if (tp) 284 if (tp)
208 { 285 {
209 time_t d = ydhms_diff (year, yday, hour, min, sec, 286 time_t d = ydhms_diff (year, yday, hour, min, sec,
210 tp->tm_year, tp->tm_yday, 287 tp->tm_year, tp->tm_yday,
211 tp->tm_hour, tp->tm_min, tp->tm_sec); 288 tp->tm_hour, tp->tm_min, tp->tm_sec);
212 time_t t1 = *t + d; 289 if (time_t_add_ok (*t, d))
213 if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d)) 290 return *t + d;
214 return t1;
215 } 291 }
216 292
217 /* Overflow occurred one way or another. Return the nearest result 293 /* Overflow occurred one way or another. Return the nearest result
@@ -220,8 +296,8 @@ guess_time_tm (long int year, long int yday, int hour, int min, int sec,
220 match; and don't oscillate between two values, as that would 296 match; and don't oscillate between two values, as that would
221 confuse the spring-forward gap detector. */ 297 confuse the spring-forward gap detector. */
222 return (*t < TIME_T_MIDPOINT 298 return (*t < TIME_T_MIDPOINT
223 ? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN) 299 ? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
224 : (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX)); 300 : (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
225} 301}
226 302
227/* Use CONVERT to convert *T to a broken down time in *TP. 303/* Use CONVERT to convert *T to a broken down time in *TP.
@@ -229,7 +305,7 @@ guess_time_tm (long int year, long int yday, int hour, int min, int sec,
229 it is the nearest in-range value and then convert that. */ 305 it is the nearest in-range value and then convert that. */
230static struct tm * 306static struct tm *
231ranged_convert (struct tm *(*convert) (const time_t *, struct tm *), 307ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
232 time_t *t, struct tm *tp) 308 time_t *t, struct tm *tp)
233{ 309{
234 struct tm *r = convert (t, tp); 310 struct tm *r = convert (t, tp);
235 311
@@ -239,27 +315,25 @@ ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
239 time_t ok = 0; 315 time_t ok = 0;
240 316
241 /* BAD is a known unconvertible time_t, and OK is a known good one. 317 /* BAD is a known unconvertible time_t, and OK is a known good one.
242 Use binary search to narrow the range between BAD and OK until 318 Use binary search to narrow the range between BAD and OK until
243 they differ by 1. */ 319 they differ by 1. */
244 while (bad != ok + (bad < 0 ? -1 : 1)) 320 while (bad != ok + (bad < 0 ? -1 : 1))
245 { 321 {
246 time_t mid = *t = (bad < 0 322 time_t mid = *t = time_t_avg (ok, bad);
247 ? bad + ((ok - bad) >> 1) 323 r = convert (t, tp);
248 : ok + ((bad - ok) >> 1)); 324 if (r)
249 r = convert (t, tp); 325 ok = mid;
250 if (r) 326 else
251 ok = mid; 327 bad = mid;
252 else 328 }
253 bad = mid;
254 }
255 329
256 if (!r && ok) 330 if (!r && ok)
257 { 331 {
258 /* The last conversion attempt failed; 332 /* The last conversion attempt failed;
259 revert to the most recent successful attempt. */ 333 revert to the most recent successful attempt. */
260 *t = ok; 334 *t = ok;
261 r = convert (t, tp); 335 r = convert (t, tp);
262 } 336 }
263 } 337 }
264 338
265 return r; 339 return r;
@@ -274,8 +348,8 @@ ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
274 This function is external because it is used also by timegm.c. */ 348 This function is external because it is used also by timegm.c. */
275time_t 349time_t
276__mktime_internal (struct tm *tp, 350__mktime_internal (struct tm *tp,
277 struct tm *(*convert) (const time_t *, struct tm *), 351 struct tm *(*convert) (const time_t *, struct tm *),
278 time_t *offset) 352 time_t *offset)
279{ 353{
280 time_t t, gt, t0, t1, t2; 354 time_t t, gt, t0, t1, t2;
281 struct tm tm; 355 struct tm tm;
@@ -294,9 +368,7 @@ __mktime_internal (struct tm *tp,
294 int mday = tp->tm_mday; 368 int mday = tp->tm_mday;
295 int mon = tp->tm_mon; 369 int mon = tp->tm_mon;
296 int year_requested = tp->tm_year; 370 int year_requested = tp->tm_year;
297 /* Normalize the value. */ 371 int isdst = tp->tm_isdst;
298 int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))
299 | (tp->tm_isdst != 0));
300 372
301 /* 1 if the previous probe was DST. */ 373 /* 1 if the previous probe was DST. */
302 int dst2; 374 int dst2;
@@ -305,8 +377,8 @@ __mktime_internal (struct tm *tp,
305 int mon_remainder = mon % 12; 377 int mon_remainder = mon % 12;
306 int negative_mon_remainder = mon_remainder < 0; 378 int negative_mon_remainder = mon_remainder < 0;
307 int mon_years = mon / 12 - negative_mon_remainder; 379 int mon_years = mon / 12 - negative_mon_remainder;
308 long int lyear_requested = year_requested; 380 long_int lyear_requested = year_requested;
309 long int year = lyear_requested + mon_years; 381 long_int year = lyear_requested + mon_years;
310 382
311 /* The other values need not be in range: 383 /* The other values need not be in range:
312 the remaining code handles minor overflows correctly, 384 the remaining code handles minor overflows correctly,
@@ -316,10 +388,10 @@ __mktime_internal (struct tm *tp,
316 /* Calculate day of year from year, month, and day of month. 388 /* Calculate day of year from year, month, and day of month.
317 The result need not be in range. */ 389 The result need not be in range. */
318 int mon_yday = ((__mon_yday[leapyear (year)] 390 int mon_yday = ((__mon_yday[leapyear (year)]
319 [mon_remainder + 12 * negative_mon_remainder]) 391 [mon_remainder + 12 * negative_mon_remainder])
320 - 1); 392 - 1);
321 long int lmday = mday; 393 long_int lmday = mday;
322 long int yday = mon_yday + lmday; 394 long_int yday = mon_yday + lmday;
323 395
324 time_t guessed_offset = *offset; 396 time_t guessed_offset = *offset;
325 397
@@ -328,33 +400,33 @@ __mktime_internal (struct tm *tp,
328 if (LEAP_SECONDS_POSSIBLE) 400 if (LEAP_SECONDS_POSSIBLE)
329 { 401 {
330 /* Handle out-of-range seconds specially, 402 /* Handle out-of-range seconds specially,
331 since ydhms_tm_diff assumes every minute has 60 seconds. */ 403 since ydhms_tm_diff assumes every minute has 60 seconds. */
332 if (sec < 0) 404 if (sec < 0)
333 sec = 0; 405 sec = 0;
334 if (59 < sec) 406 if (59 < sec)
335 sec = 59; 407 sec = 59;
336 } 408 }
337 409
338 /* Invert CONVERT by probing. First assume the same offset as last 410 /* Invert CONVERT by probing. First assume the same offset as last
339 time. */ 411 time. */
340 412
341 t0 = ydhms_diff (year, yday, hour, min, sec, 413 t0 = ydhms_diff (year, yday, hour, min, sec,
342 EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset); 414 EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
343 415
344 if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3) 416 if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
345 { 417 {
346 /* time_t isn't large enough to rule out overflows, so check 418 /* time_t isn't large enough to rule out overflows, so check
347 for major overflows. A gross check suffices, since if t0 419 for major overflows. A gross check suffices, since if t0
348 has overflowed, it is off by a multiple of TIME_T_MAX - 420 has overflowed, it is off by a multiple of TIME_T_MAX -
349 TIME_T_MIN + 1. So ignore any component of the difference 421 TIME_T_MIN + 1. So ignore any component of the difference
350 that is bounded by a small value. */ 422 that is bounded by a small value. */
351 423
352 /* Approximate log base 2 of the number of time units per 424 /* Approximate log base 2 of the number of time units per
353 biennium. A biennium is 2 years; use this unit instead of 425 biennium. A biennium is 2 years; use this unit instead of
354 years to avoid integer overflow. For example, 2 average 426 years to avoid integer overflow. For example, 2 average
355 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds, 427 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
356 which is 63113904 seconds, and rint (log2 (63113904)) is 428 which is 63113904 seconds, and rint (log2 (63113904)) is
357 26. */ 429 26. */
358 int ALOG2_SECONDS_PER_BIENNIUM = 26; 430 int ALOG2_SECONDS_PER_BIENNIUM = 26;
359 int ALOG2_MINUTES_PER_BIENNIUM = 20; 431 int ALOG2_MINUTES_PER_BIENNIUM = 20;
360 int ALOG2_HOURS_PER_BIENNIUM = 14; 432 int ALOG2_HOURS_PER_BIENNIUM = 14;
@@ -362,119 +434,117 @@ __mktime_internal (struct tm *tp,
362 int LOG2_YEARS_PER_BIENNIUM = 1; 434 int LOG2_YEARS_PER_BIENNIUM = 1;
363 435
364 int approx_requested_biennia = 436 int approx_requested_biennia =
365 (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM) 437 (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
366 - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM) 438 - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
367 + SHR (mday, ALOG2_DAYS_PER_BIENNIUM) 439 + SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
368 + SHR (hour, ALOG2_HOURS_PER_BIENNIUM) 440 + SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
369 + SHR (min, ALOG2_MINUTES_PER_BIENNIUM) 441 + SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
370 + (LEAP_SECONDS_POSSIBLE 442 + (LEAP_SECONDS_POSSIBLE
371 ? 0 443 ? 0
372 : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM))); 444 : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
373 445
374 int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM); 446 int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
375 int diff = approx_biennia - approx_requested_biennia; 447 int diff = approx_biennia - approx_requested_biennia;
376 int abs_diff = diff < 0 ? - diff : diff; 448 int approx_abs_diff = diff < 0 ? -1 - diff : diff;
377 449
378 /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously 450 /* IRIX 4.0.5 cc miscalculates TIME_T_MIN / 3: it erroneously
379 gives a positive value of 715827882. Setting a variable 451 gives a positive value of 715827882. Setting a variable
380 first then doing math on it seems to work. 452 first then doing math on it seems to work.
381 (ghazi@caip.rutgers.edu) */ 453 (ghazi@caip.rutgers.edu) */
382 time_t time_t_max = TIME_T_MAX; 454 time_t time_t_max = TIME_T_MAX;
383 time_t time_t_min = TIME_T_MIN; 455 time_t time_t_min = TIME_T_MIN;
384 time_t overflow_threshold = 456 time_t overflow_threshold =
385 (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM; 457 (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
386 458
387 if (overflow_threshold < abs_diff) 459 if (overflow_threshold < approx_abs_diff)
388 { 460 {
389 /* Overflow occurred. Try repairing it; this might work if 461 /* Overflow occurred. Try repairing it; this might work if
390 the time zone offset is enough to undo the overflow. */ 462 the time zone offset is enough to undo the overflow. */
391 time_t repaired_t0 = -1 - t0; 463 time_t repaired_t0 = -1 - t0;
392 approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM); 464 approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
393 diff = approx_biennia - approx_requested_biennia; 465 diff = approx_biennia - approx_requested_biennia;
394 abs_diff = diff < 0 ? - diff : diff; 466 approx_abs_diff = diff < 0 ? -1 - diff : diff;
395 if (overflow_threshold < abs_diff) 467 if (overflow_threshold < approx_abs_diff)
396 return -1; 468 return -1;
397 guessed_offset += repaired_t0 - t0; 469 guessed_offset += repaired_t0 - t0;
398 t0 = repaired_t0; 470 t0 = repaired_t0;
399 } 471 }
400 } 472 }
401 473
402 /* Repeatedly use the error to improve the guess. */ 474 /* Repeatedly use the error to improve the guess. */
403 475
404 for (t = t1 = t2 = t0, dst2 = 0; 476 for (t = t1 = t2 = t0, dst2 = 0;
405 (gt = guess_time_tm (year, yday, hour, min, sec, &t, 477 (gt = guess_time_tm (year, yday, hour, min, sec, &t,
406 ranged_convert (convert, &t, &tm)), 478 ranged_convert (convert, &t, &tm)),
407 t != gt); 479 t != gt);
408 t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0) 480 t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
409 if (t == t1 && t != t2 481 if (t == t1 && t != t2
410 && (tm.tm_isdst < 0 482 && (tm.tm_isdst < 0
411 || (isdst < 0 483 || (isdst < 0
412 ? dst2 <= (tm.tm_isdst != 0) 484 ? dst2 <= (tm.tm_isdst != 0)
413 : (isdst != 0) != (tm.tm_isdst != 0)))) 485 : (isdst != 0) != (tm.tm_isdst != 0))))
414 /* We can't possibly find a match, as we are oscillating 486 /* We can't possibly find a match, as we are oscillating
415 between two values. The requested time probably falls 487 between two values. The requested time probably falls
416 within a spring-forward gap of size GT - T. Follow the common 488 within a spring-forward gap of size GT - T. Follow the common
417 practice in this case, which is to return a time that is GT - T 489 practice in this case, which is to return a time that is GT - T
418 away from the requested time, preferring a time whose 490 away from the requested time, preferring a time whose
419 tm_isdst differs from the requested value. (If no tm_isdst 491 tm_isdst differs from the requested value. (If no tm_isdst
420 was requested and only one of the two values has a nonzero 492 was requested and only one of the two values has a nonzero
421 tm_isdst, prefer that value.) In practice, this is more 493 tm_isdst, prefer that value.) In practice, this is more
422 useful than returning -1. */ 494 useful than returning -1. */
423 goto offset_found; 495 goto offset_found;
424 else if (--remaining_probes == 0) 496 else if (--remaining_probes == 0)
425 return -1; 497 return -1;
426 498
427 /* We have a match. Check whether tm.tm_isdst has the requested 499 /* We have a match. Check whether tm.tm_isdst has the requested
428 value, if any. */ 500 value, if any. */
429 if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst) 501 if (isdst_differ (isdst, tm.tm_isdst))
430 { 502 {
431 /* tm.tm_isdst has the wrong value. Look for a neighboring 503 /* tm.tm_isdst has the wrong value. Look for a neighboring
432 time with the right value, and use its UTC offset. 504 time with the right value, and use its UTC offset.
433 505
434 Heuristic: probe the adjacent timestamps in both directions, 506 Heuristic: probe the adjacent timestamps in both directions,
435 looking for the desired isdst. This should work for all real 507 looking for the desired isdst. This should work for all real
436 time zone histories in the tz database. */ 508 time zone histories in the tz database. */
437 509
438 /* Distance between probes when looking for a DST boundary. In 510 /* Distance between probes when looking for a DST boundary. In
439 tzdata2003a, the shortest period of DST is 601200 seconds 511 tzdata2003a, the shortest period of DST is 601200 seconds
440 (e.g., America/Recife starting 2000-10-08 01:00), and the 512 (e.g., America/Recife starting 2000-10-08 01:00), and the
441 shortest period of non-DST surrounded by DST is 694800 513 shortest period of non-DST surrounded by DST is 694800
442 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the 514 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the
443 minimum of these two values, so we don't miss these short 515 minimum of these two values, so we don't miss these short
444 periods when probing. */ 516 periods when probing. */
445 int stride = 601200; 517 int stride = 601200;
446 518
447 /* The longest period of DST in tzdata2003a is 536454000 seconds 519 /* The longest period of DST in tzdata2003a is 536454000 seconds
448 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest 520 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest
449 period of non-DST is much longer, but it makes no real sense 521 period of non-DST is much longer, but it makes no real sense
450 to search for more than a year of non-DST, so use the DST 522 to search for more than a year of non-DST, so use the DST
451 max. */ 523 max. */
452 int duration_max = 536454000; 524 int duration_max = 536454000;
453 525
454 /* Search in both directions, so the maximum distance is half 526 /* Search in both directions, so the maximum distance is half
455 the duration; add the stride to avoid off-by-1 problems. */ 527 the duration; add the stride to avoid off-by-1 problems. */
456 int delta_bound = duration_max / 2 + stride; 528 int delta_bound = duration_max / 2 + stride;
457 529
458 int delta, direction; 530 int delta, direction;
459 531
460 for (delta = stride; delta < delta_bound; delta += stride) 532 for (delta = stride; delta < delta_bound; delta += stride)
461 for (direction = -1; direction <= 1; direction += 2) 533 for (direction = -1; direction <= 1; direction += 2)
462 { 534 if (time_t_int_add_ok (t, delta * direction))
463 time_t ot = t + delta * direction; 535 {
464 if ((ot < t) == (direction < 0)) 536 time_t ot = t + delta * direction;
465 { 537 struct tm otm;
466 struct tm otm; 538 ranged_convert (convert, &ot, &otm);
467 ranged_convert (convert, &ot, &otm); 539 if (! isdst_differ (isdst, otm.tm_isdst))
468 if (otm.tm_isdst == isdst) 540 {
469 { 541 /* We found the desired tm_isdst.
470 /* We found the desired tm_isdst. 542 Extrapolate back to the desired time. */
471 Extrapolate back to the desired time. */ 543 t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
472 t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm); 544 ranged_convert (convert, &t, &tm);
473 ranged_convert (convert, &t, &tm); 545 goto offset_found;
474 goto offset_found; 546 }
475 } 547 }
476 }
477 }
478 } 548 }
479 549
480 offset_found: 550 offset_found:
@@ -483,14 +553,16 @@ __mktime_internal (struct tm *tp,
483 if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec) 553 if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
484 { 554 {
485 /* Adjust time to reflect the tm_sec requested, not the normalized value. 555 /* Adjust time to reflect the tm_sec requested, not the normalized value.
486 Also, repair any damage from a false match due to a leap second. */ 556 Also, repair any damage from a false match due to a leap second. */
487 int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec; 557 int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
558 if (! time_t_int_add_ok (t, sec_requested))
559 return -1;
488 t1 = t + sec_requested; 560 t1 = t + sec_requested;
561 if (! time_t_int_add_ok (t1, sec_adjustment))
562 return -1;
489 t2 = t1 + sec_adjustment; 563 t2 = t1 + sec_adjustment;
490 if (((t1 < t) != (sec_requested < 0)) 564 if (! convert (&t2, &tm))
491 | ((t2 < t1) != (sec_adjustment < 0)) 565 return -1;
492 | ! convert (&t2, &tm))
493 return -1;
494 t = t2; 566 t = t2;
495 } 567 }
496 568
@@ -511,7 +583,7 @@ mktime (struct tm *tp)
511{ 583{
512#ifdef _LIBC 584#ifdef _LIBC
513 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the 585 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
514 time zone names contained in the external variable `tzname' shall 586 time zone names contained in the external variable 'tzname' shall
515 be set as if the tzset() function had been called. */ 587 be set as if the tzset() function had been called. */
516 __tzset (); 588 __tzset ();
517#endif 589#endif
@@ -534,13 +606,13 @@ static int
534not_equal_tm (const struct tm *a, const struct tm *b) 606not_equal_tm (const struct tm *a, const struct tm *b)
535{ 607{
536 return ((a->tm_sec ^ b->tm_sec) 608 return ((a->tm_sec ^ b->tm_sec)
537 | (a->tm_min ^ b->tm_min) 609 | (a->tm_min ^ b->tm_min)
538 | (a->tm_hour ^ b->tm_hour) 610 | (a->tm_hour ^ b->tm_hour)
539 | (a->tm_mday ^ b->tm_mday) 611 | (a->tm_mday ^ b->tm_mday)
540 | (a->tm_mon ^ b->tm_mon) 612 | (a->tm_mon ^ b->tm_mon)
541 | (a->tm_year ^ b->tm_year) 613 | (a->tm_year ^ b->tm_year)
542 | (a->tm_yday ^ b->tm_yday) 614 | (a->tm_yday ^ b->tm_yday)
543 | (a->tm_isdst ^ b->tm_isdst)); 615 | isdst_differ (a->tm_isdst, b->tm_isdst));
544} 616}
545 617
546static void 618static void
@@ -548,9 +620,9 @@ print_tm (const struct tm *tp)
548{ 620{
549 if (tp) 621 if (tp)
550 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d", 622 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
551 tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday, 623 tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
552 tp->tm_hour, tp->tm_min, tp->tm_sec, 624 tp->tm_hour, tp->tm_min, tp->tm_sec,
553 tp->tm_yday, tp->tm_wday, tp->tm_isdst); 625 tp->tm_yday, tp->tm_wday, tp->tm_isdst);
554 else 626 else
555 printf ("0"); 627 printf ("0");
556} 628}
@@ -582,11 +654,11 @@ main (int argc, char **argv)
582 654
583 if ((argc == 3 || argc == 4) 655 if ((argc == 3 || argc == 4)
584 && (sscanf (argv[1], "%d-%d-%d%c", 656 && (sscanf (argv[1], "%d-%d-%d%c",
585 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer) 657 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
586 == 3) 658 == 3)
587 && (sscanf (argv[2], "%d:%d:%d%c", 659 && (sscanf (argv[2], "%d:%d:%d%c",
588 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer) 660 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
589 == 3)) 661 == 3))
590 { 662 {
591 tm.tm_year -= TM_YEAR_BASE; 663 tm.tm_year -= TM_YEAR_BASE;
592 tm.tm_mon--; 664 tm.tm_mon--;
@@ -595,10 +667,10 @@ main (int argc, char **argv)
595 tl = mktime (&tmk); 667 tl = mktime (&tmk);
596 lt = localtime (&tl); 668 lt = localtime (&tl);
597 if (lt) 669 if (lt)
598 { 670 {
599 tml = *lt; 671 tml = *lt;
600 lt = &tml; 672 lt = &tml;
601 } 673 }
602 printf ("mktime returns %ld == ", (long int) tl); 674 printf ("mktime returns %ld == ", (long int) tl);
603 print_tm (&tmk); 675 print_tm (&tmk);
604 printf ("\n"); 676 printf ("\n");
@@ -611,51 +683,51 @@ main (int argc, char **argv)
611 time_t to = atol (argv[3]); 683 time_t to = atol (argv[3]);
612 684
613 if (argc == 4) 685 if (argc == 4)
614 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1) 686 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
615 { 687 {
616 lt = localtime (&tl); 688 lt = localtime (&tl);
617 if (lt) 689 if (lt)
618 { 690 {
619 tmk = tml = *lt; 691 tmk = tml = *lt;
620 tk = mktime (&tmk); 692 tk = mktime (&tmk);
621 status |= check_result (tk, tmk, tl, &tml); 693 status |= check_result (tk, tmk, tl, &tml);
622 } 694 }
623 else 695 else
624 { 696 {
625 printf ("localtime (%ld) yields 0\n", (long int) tl); 697 printf ("localtime (%ld) yields 0\n", (long int) tl);
626 status = 1; 698 status = 1;
627 } 699 }
628 tl1 = tl + by; 700 tl1 = tl + by;
629 if ((tl1 < tl) != (by < 0)) 701 if ((tl1 < tl) != (by < 0))
630 break; 702 break;
631 } 703 }
632 else 704 else
633 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1) 705 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
634 { 706 {
635 /* Null benchmark. */ 707 /* Null benchmark. */
636 lt = localtime (&tl); 708 lt = localtime (&tl);
637 if (lt) 709 if (lt)
638 { 710 {
639 tmk = tml = *lt; 711 tmk = tml = *lt;
640 tk = tl; 712 tk = tl;
641 status |= check_result (tk, tmk, tl, &tml); 713 status |= check_result (tk, tmk, tl, &tml);
642 } 714 }
643 else 715 else
644 { 716 {
645 printf ("localtime (%ld) yields 0\n", (long int) tl); 717 printf ("localtime (%ld) yields 0\n", (long int) tl);
646 status = 1; 718 status = 1;
647 } 719 }
648 tl1 = tl + by; 720 tl1 = tl + by;
649 if ((tl1 < tl) != (by < 0)) 721 if ((tl1 < tl) != (by < 0))
650 break; 722 break;
651 } 723 }
652 } 724 }
653 else 725 else
654 printf ("Usage:\ 726 printf ("Usage:\
655\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\ 727\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
656\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\ 728\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
657\t%s FROM BY TO - # Do not test those values (for benchmark).\n", 729\t%s FROM BY TO - # Do not test those values (for benchmark).\n",
658 argv[0], argv[0], argv[0]); 730 argv[0], argv[0], argv[0]);
659 731
660 return status; 732 return status;
661} 733}
@@ -664,6 +736,6 @@ main (int argc, char **argv)
664 736
665/* 737/*
666Local Variables: 738Local Variables:
667compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime" 739compile-command: "gcc -DDEBUG -I. -Wall -W -O2 -g mktime.c -o mktime"
668End: 740End:
669*/ 741*/