1 /* Convert a 'struct tm' to a time_t value. 2 Copyright (C) 1993-2013 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 Contributed by Paul Eggert <eggert@twinsun.com>. 5 6 The GNU C Library is free software; you can redistribute it and/or 7 modify it under the terms of the GNU General Public 8 License as published by the Free Software Foundation; either 9 version 3 of the License, or (at your option) any later version. 10 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 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public 17 License along with the GNU C Library; if not, see 18 <http://www.gnu.org/licenses/>. */ 19 20 /* Define this to have a standalone program to test this implementation of 21 mktime. */ 22 /* #define DEBUG 1 */ 23 24 #ifndef _LIBC 25 # include <config.h> 26 #endif 27 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 33 #endif 34 35 #include <time.h> 36 37 #include <limits.h> 38 39 #include <string.h> /* For the real memcpy prototype. */ 40 41 #if DEBUG 42 # include <stdio.h> 43 # include <stdlib.h> 44 /* Make it work even if the system's libc has its own mktime routine. */ 45 # undef mktime 46 # define mktime my_mktime 47 #endif /* DEBUG */ 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 76 typedef long int long_int; 77 #else 78 typedef long long int long_int; 79 #endif 80 verify (long_int_is_wide_enough, INT_MAX == INT_MAX * (long_int) 2 / 2); 81 82 /* Shift A right by B bits portably, by dividing A by 2**B and 83 truncating towards minus infinity. A and B should be free of side 84 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where 85 INT_BITS is the number of useful bits in an int. GNU code can 86 assume that INT_BITS is at least 32. 87 88 ISO C99 says that A >> B is implementation-defined if A < 0. Some 89 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift 90 right in the usual way when A < 0, so SHR falls back on division if 91 ordinary A >> B doesn't seem to be the usual signed shift. */ 92 #define SHR(a, b) \ 93 ((-1 >> 1 == -1 \ 94 && (long_int) -1 >> 1 == -1 \ 95 && ((time_t) -1 >> 1 == -1 || ! TYPE_SIGNED (time_t))) \ 96 ? (a) >> (b) \ 97 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0)) 98 99 /* The extra casts in the following macros work around compiler bugs, 100 e.g., in Cray C 5.0.3.0. */ 101 102 /* True if the arithmetic type T is an integer type. bool counts as 103 an integer. */ 104 #define TYPE_IS_INTEGER(t) ((t) 1.5 == 1) 105 106 /* True if negative values of the signed integer type T use two's 107 complement, or if T is an unsigned integer type. */ 108 #define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1) 109 110 /* True if the arithmetic type T is signed. */ 111 #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1)) 112 113 /* The maximum and minimum values for the integer type T. These 114 macros have undefined behavior if T is signed and has padding bits. 115 If this is a problem for you, please let us know how to fix it for 116 your host. */ 117 #define TYPE_MINIMUM(t) \ 118 ((t) (! TYPE_SIGNED (t) \ 119 ? (t) 0 \ 120 : ~ TYPE_MAXIMUM (t))) 121 #define TYPE_MAXIMUM(t) \ 122 ((t) (! TYPE_SIGNED (t) \ 123 ? (t) -1 \ 124 : ((((t) 1 << (sizeof (t) * CHAR_BIT - 2)) - 1) * 2 + 1))) 125 126 #ifndef TIME_T_MIN 127 # define TIME_T_MIN TYPE_MINIMUM (time_t) 128 #endif 129 #ifndef TIME_T_MAX 130 # define TIME_T_MAX TYPE_MAXIMUM (time_t) 131 #endif 132 #define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1) 133 134 verify (time_t_is_integer, TYPE_IS_INTEGER (time_t)); 135 verify (twos_complement_arithmetic, 136 (TYPE_TWOS_COMPLEMENT (int) 137 && TYPE_TWOS_COMPLEMENT (long_int) 138 && TYPE_TWOS_COMPLEMENT (time_t))); 139 140 #define EPOCH_YEAR 1970 141 #define TM_YEAR_BASE 1900 142 verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0); 143 144 /* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */ 145 static int 146 leapyear (long_int year) 147 { 148 /* Don't add YEAR to TM_YEAR_BASE, as that might overflow. 149 Also, work even if YEAR is negative. */ 150 return 151 ((year & 3) == 0 152 && (year % 100 != 0 153 || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3))); 154 } 155 156 /* How many days come before each month (0-12). */ 157 #ifndef _LIBC 158 static 159 #endif 160 const unsigned short int __mon_yday[2][13] = 161 { 162 /* Normal years. */ 163 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }, 164 /* Leap years. */ 165 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } 166 }; 167 168 169 #ifndef _LIBC 170 /* Portable standalone applications should supply a <time.h> that 171 declares a POSIX-compliant localtime_r, for the benefit of older 172 implementations that lack localtime_r or have a nonstandard one. 173 See the gnulib time_r module for one way to implement this. */ 174 # undef __localtime_r 175 # define __localtime_r localtime_r 176 # define __mktime_internal mktime_internal 177 # include "mktime-internal.h" 178 #endif 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. */ 182 static int 183 isdst_differ (int a, int b) 184 { 185 return (!a != !b) && (0 <= a) && (0 <= b); 186 } 187 188 /* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) - 189 (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks 190 were not adjusted between the time stamps. 191 192 The YEAR values uses the same numbering as TP->tm_year. Values 193 need not be in the usual range. However, YEAR1 must not be less 194 than 2 * INT_MIN or greater than 2 * INT_MAX. 195 196 The result may overflow. It is the caller's responsibility to 197 detect overflow. */ 198 199 static time_t 200 ydhms_diff (long_int year1, long_int yday1, int hour1, int min1, int sec1, 201 int year0, int yday0, int hour0, int min0, int sec0) 202 { 203 verify (C99_integer_division, -1 / 2 == 0); 204 205 /* Compute intervening leap days correctly even if year is negative. 206 Take care to avoid integer overflow here. */ 207 int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3); 208 int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3); 209 int a100 = a4 / 25 - (a4 % 25 < 0); 210 int b100 = b4 / 25 - (b4 % 25 < 0); 211 int a400 = SHR (a100, 2); 212 int b400 = SHR (b100, 2); 213 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400); 214 215 /* Compute the desired time in time_t precision. Overflow might 216 occur here. */ 217 time_t tyear1 = year1; 218 time_t years = tyear1 - year0; 219 time_t days = 365 * years + yday1 - yday0 + intervening_leap_days; 220 time_t hours = 24 * days + hour1 - hour0; 221 time_t minutes = 60 * hours + min1 - min0; 222 time_t seconds = 60 * minutes + sec1 - sec0; 223 return seconds; 224 } 225 226 /* Return the average of A and B, even if A + B would overflow. */ 227 static time_t 228 time_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. */ 236 static int 237 time_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. */ 257 static int 258 time_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 } 273 274 /* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC), 275 assuming that *T corresponds to *TP and that no clock adjustments 276 occurred between *TP and the desired time. 277 If TP is null, return a value not equal to *T; this avoids false matches. 278 If overflow occurs, yield the minimal or maximal value, except do not 279 yield a value equal to *T. */ 280 static time_t 281 guess_time_tm (long_int year, long_int yday, int hour, int min, int sec, 282 const time_t *t, const struct tm *tp) 283 { 284 if (tp) 285 { 286 time_t d = ydhms_diff (year, yday, hour, min, sec, 287 tp->tm_year, tp->tm_yday, 288 tp->tm_hour, tp->tm_min, tp->tm_sec); 289 if (time_t_add_ok (*t, d)) 290 return *t + d; 291 } 292 293 /* Overflow occurred one way or another. Return the nearest result 294 that is actually in range, except don't report a zero difference 295 if the actual difference is nonzero, as that would cause a false 296 match; and don't oscillate between two values, as that would 297 confuse the spring-forward gap detector. */ 298 return (*t < TIME_T_MIDPOINT 299 ? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN) 300 : (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX)); 301 } 302 303 /* Use CONVERT to convert *T to a broken down time in *TP. 304 If *T is out of range for conversion, adjust it so that 305 it is the nearest in-range value and then convert that. */ 306 static struct tm * 307 ranged_convert (struct tm *(*convert) (const time_t *, struct tm *), 308 time_t *t, struct tm *tp) 309 { 310 struct tm *r = convert (t, tp); 311 312 if (!r && *t) 313 { 314 time_t bad = *t; 315 time_t ok = 0; 316 317 /* BAD is a known unconvertible time_t, and OK is a known good one. 318 Use binary search to narrow the range between BAD and OK until 319 they differ by 1. */ 320 while (bad != ok + (bad < 0 ? -1 : 1)) 321 { 322 time_t mid = *t = time_t_avg (ok, bad); 323 r = convert (t, tp); 324 if (r) 325 ok = mid; 326 else 327 bad = mid; 328 } 329 330 if (!r && ok) 331 { 332 /* The last conversion attempt failed; 333 revert to the most recent successful attempt. */ 334 *t = ok; 335 r = convert (t, tp); 336 } 337 } 338 339 return r; 340 } 341 342 343 /* Convert *TP to a time_t value, inverting 344 the monotonic and mostly-unit-linear conversion function CONVERT. 345 Use *OFFSET to keep track of a guess at the offset of the result, 346 compared to what the result would be for UTC without leap seconds. 347 If *OFFSET's guess is correct, only one CONVERT call is needed. 348 This function is external because it is used also by timegm.c. */ 349 time_t 350 __mktime_internal (struct tm *tp, 351 struct tm *(*convert) (const time_t *, struct tm *), 352 time_t *offset) 353 { 354 time_t t, gt, t0, t1, t2; 355 struct tm tm; 356 357 /* The maximum number of probes (calls to CONVERT) should be enough 358 to handle any combinations of time zone rule changes, solar time, 359 leap seconds, and oscillations around a spring-forward gap. 360 POSIX.1 prohibits leap seconds, but some hosts have them anyway. */ 361 int remaining_probes = 6; 362 363 /* Time requested. Copy it in case CONVERT modifies *TP; this can 364 occur if TP is localtime's returned value and CONVERT is localtime. */ 365 int sec = tp->tm_sec; 366 int min = tp->tm_min; 367 int hour = tp->tm_hour; 368 int mday = tp->tm_mday; 369 int mon = tp->tm_mon; 370 int year_requested = tp->tm_year; 371 int isdst = tp->tm_isdst; 372 373 /* 1 if the previous probe was DST. */ 374 int dst2; 375 376 /* Ensure that mon is in range, and set year accordingly. */ 377 int mon_remainder = mon % 12; 378 int negative_mon_remainder = mon_remainder < 0; 379 int mon_years = mon / 12 - negative_mon_remainder; 380 long_int lyear_requested = year_requested; 381 long_int year = lyear_requested + mon_years; 382 383 /* The other values need not be in range: 384 the remaining code handles minor overflows correctly, 385 assuming int and time_t arithmetic wraps around. 386 Major overflows are caught at the end. */ 387 388 /* Calculate day of year from year, month, and day of month. 389 The result need not be in range. */ 390 int mon_yday = ((__mon_yday[leapyear (year)] 391 [mon_remainder + 12 * negative_mon_remainder]) 392 - 1); 393 long_int lmday = mday; 394 long_int yday = mon_yday + lmday; 395 396 time_t guessed_offset = *offset; 397 398 int sec_requested = sec; 399 400 if (LEAP_SECONDS_POSSIBLE) 401 { 402 /* Handle out-of-range seconds specially, 403 since ydhms_tm_diff assumes every minute has 60 seconds. */ 404 if (sec < 0) 405 sec = 0; 406 if (59 < sec) 407 sec = 59; 408 } 409 410 /* Invert CONVERT by probing. First assume the same offset as last 411 time. */ 412 413 t0 = ydhms_diff (year, yday, hour, min, sec, 414 EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset); 415 416 if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3) 417 { 418 /* time_t isn't large enough to rule out overflows, so check 419 for major overflows. A gross check suffices, since if t0 420 has overflowed, it is off by a multiple of TIME_T_MAX - 421 TIME_T_MIN + 1. So ignore any component of the difference 422 that is bounded by a small value. */ 423 424 /* Approximate log base 2 of the number of time units per 425 biennium. A biennium is 2 years; use this unit instead of 426 years to avoid integer overflow. For example, 2 average 427 Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds, 428 which is 63113904 seconds, and rint (log2 (63113904)) is 429 26. */ 430 int ALOG2_SECONDS_PER_BIENNIUM = 26; 431 int ALOG2_MINUTES_PER_BIENNIUM = 20; 432 int ALOG2_HOURS_PER_BIENNIUM = 14; 433 int ALOG2_DAYS_PER_BIENNIUM = 10; 434 int LOG2_YEARS_PER_BIENNIUM = 1; 435 436 int approx_requested_biennia = 437 (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM) 438 - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM) 439 + SHR (mday, ALOG2_DAYS_PER_BIENNIUM) 440 + SHR (hour, ALOG2_HOURS_PER_BIENNIUM) 441 + SHR (min, ALOG2_MINUTES_PER_BIENNIUM) 442 + (LEAP_SECONDS_POSSIBLE 443 ? 0 444 : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM))); 445 446 int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM); 447 int diff = approx_biennia - approx_requested_biennia; 448 int approx_abs_diff = diff < 0 ? -1 - diff : diff; 449 450 /* IRIX 4.0.5 cc miscalculates TIME_T_MIN / 3: it erroneously 451 gives a positive value of 715827882. Setting a variable 452 first then doing math on it seems to work. 453 (ghazi@caip.rutgers.edu) */ 454 time_t time_t_max = TIME_T_MAX; 455 time_t time_t_min = TIME_T_MIN; 456 time_t overflow_threshold = 457 (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM; 458 459 if (overflow_threshold < approx_abs_diff) 460 { 461 /* Overflow occurred. Try repairing it; this might work if 462 the time zone offset is enough to undo the overflow. */ 463 time_t repaired_t0 = -1 - t0; 464 approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM); 465 diff = approx_biennia - approx_requested_biennia; 466 approx_abs_diff = diff < 0 ? -1 - diff : diff; 467 if (overflow_threshold < approx_abs_diff) 468 return -1; 469 guessed_offset += repaired_t0 - t0; 470 t0 = repaired_t0; 471 } 472 } 473 474 /* Repeatedly use the error to improve the guess. */ 475 476 for (t = t1 = t2 = t0, dst2 = 0; 477 (gt = guess_time_tm (year, yday, hour, min, sec, &t, 478 ranged_convert (convert, &t, &tm)), 479 t != gt); 480 t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0) 481 if (t == t1 && t != t2 482 && (tm.tm_isdst < 0 483 || (isdst < 0 484 ? dst2 <= (tm.tm_isdst != 0) 485 : (isdst != 0) != (tm.tm_isdst != 0)))) 486 /* We can't possibly find a match, as we are oscillating 487 between two values. The requested time probably falls 488 within a spring-forward gap of size GT - T. Follow the common 489 practice in this case, which is to return a time that is GT - T 490 away from the requested time, preferring a time whose 491 tm_isdst differs from the requested value. (If no tm_isdst 492 was requested and only one of the two values has a nonzero 493 tm_isdst, prefer that value.) In practice, this is more 494 useful than returning -1. */ 495 goto offset_found; 496 else if (--remaining_probes == 0) 497 return -1; 498 499 /* We have a match. Check whether tm.tm_isdst has the requested 500 value, if any. */ 501 if (isdst_differ (isdst, tm.tm_isdst)) 502 { 503 /* tm.tm_isdst has the wrong value. Look for a neighboring 504 time with the right value, and use its UTC offset. 505 506 Heuristic: probe the adjacent timestamps in both directions, 507 looking for the desired isdst. This should work for all real 508 time zone histories in the tz database. */ 509 510 /* Distance between probes when looking for a DST boundary. In 511 tzdata2003a, the shortest period of DST is 601200 seconds 512 (e.g., America/Recife starting 2000-10-08 01:00), and the 513 shortest period of non-DST surrounded by DST is 694800 514 seconds (Africa/Tunis starting 1943-04-17 01:00). Use the 515 minimum of these two values, so we don't miss these short 516 periods when probing. */ 517 int stride = 601200; 518 519 /* The longest period of DST in tzdata2003a is 536454000 seconds 520 (e.g., America/Jujuy starting 1946-10-01 01:00). The longest 521 period of non-DST is much longer, but it makes no real sense 522 to search for more than a year of non-DST, so use the DST 523 max. */ 524 int duration_max = 536454000; 525 526 /* Search in both directions, so the maximum distance is half 527 the duration; add the stride to avoid off-by-1 problems. */ 528 int delta_bound = duration_max / 2 + stride; 529 530 int delta, direction; 531 532 for (delta = stride; delta < delta_bound; delta += stride) 533 for (direction = -1; direction <= 1; direction += 2) 534 if (time_t_int_add_ok (t, delta * direction)) 535 { 536 time_t ot = t + delta * direction; 537 struct tm otm; 538 ranged_convert (convert, &ot, &otm); 539 if (! isdst_differ (isdst, otm.tm_isdst)) 540 { 541 /* We found the desired tm_isdst. 542 Extrapolate back to the desired time. */ 543 t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm); 544 ranged_convert (convert, &t, &tm); 545 goto offset_found; 546 } 547 } 548 } 549 550 offset_found: 551 *offset = guessed_offset + t - t0; 552 553 if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec) 554 { 555 /* Adjust time to reflect the tm_sec requested, not the normalized value. 556 Also, repair any damage from a false match due to a leap second. */ 557 int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec; 558 if (! time_t_int_add_ok (t, sec_requested)) 559 return -1; 560 t1 = t + sec_requested; 561 if (! time_t_int_add_ok (t1, sec_adjustment)) 562 return -1; 563 t2 = t1 + sec_adjustment; 564 if (! convert (&t2, &tm)) 565 return -1; 566 t = t2; 567 } 568 569 *tp = tm; 570 return t; 571 } 572 573 574 /* FIXME: This should use a signed type wide enough to hold any UTC 575 offset in seconds. 'int' should be good enough for GNU code. We 576 can't fix this unilaterally though, as other modules invoke 577 __mktime_internal. */ 578 static time_t localtime_offset; 579 580 /* Convert *TP to a time_t value. */ 581 time_t 582 mktime (struct tm *tp) 583 { 584 #ifdef _LIBC 585 /* POSIX.1 8.1.1 requires that whenever mktime() is called, the 586 time zone names contained in the external variable 'tzname' shall 587 be set as if the tzset() function had been called. */ 588 __tzset (); 589 #endif 590 591 return __mktime_internal (tp, __localtime_r, &localtime_offset); 592 } 593 594 #ifdef weak_alias 595 weak_alias (mktime, timelocal) 596 #endif 597 598 #ifdef _LIBC 599 libc_hidden_def (mktime) 600 libc_hidden_weak (timelocal) 601 #endif 602 603 #if DEBUG 604 605 static int 606 not_equal_tm (const struct tm *a, const struct tm *b) 607 { 608 return ((a->tm_sec ^ b->tm_sec) 609 | (a->tm_min ^ b->tm_min) 610 | (a->tm_hour ^ b->tm_hour) 611 | (a->tm_mday ^ b->tm_mday) 612 | (a->tm_mon ^ b->tm_mon) 613 | (a->tm_year ^ b->tm_year) 614 | (a->tm_yday ^ b->tm_yday) 615 | isdst_differ (a->tm_isdst, b->tm_isdst)); 616 } 617 618 static void 619 print_tm (const struct tm *tp) 620 { 621 if (tp) 622 printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d", 623 tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday, 624 tp->tm_hour, tp->tm_min, tp->tm_sec, 625 tp->tm_yday, tp->tm_wday, tp->tm_isdst); 626 else 627 printf ("0"); 628 } 629 630 static int 631 check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt) 632 { 633 if (tk != tl || !lt || not_equal_tm (&tmk, lt)) 634 { 635 printf ("mktime ("); 636 print_tm (lt); 637 printf (")\nyields ("); 638 print_tm (&tmk); 639 printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl); 640 return 1; 641 } 642 643 return 0; 644 } 645 646 int 647 main (int argc, char **argv) 648 { 649 int status = 0; 650 struct tm tm, tmk, tml; 651 struct tm *lt; 652 time_t tk, tl, tl1; 653 char trailer; 654 655 if ((argc == 3 || argc == 4) 656 && (sscanf (argv[1], "%d-%d-%d%c", 657 &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer) 658 == 3) 659 && (sscanf (argv[2], "%d:%d:%d%c", 660 &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer) 661 == 3)) 662 { 663 tm.tm_year -= TM_YEAR_BASE; 664 tm.tm_mon--; 665 tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]); 666 tmk = tm; 667 tl = mktime (&tmk); 668 lt = localtime (&tl); 669 if (lt) 670 { 671 tml = *lt; 672 lt = &tml; 673 } 674 printf ("mktime returns %ld == ", (long int) tl); 675 print_tm (&tmk); 676 printf ("\n"); 677 status = check_result (tl, tmk, tl, lt); 678 } 679 else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0)) 680 { 681 time_t from = atol (argv[1]); 682 time_t by = atol (argv[2]); 683 time_t to = atol (argv[3]); 684 685 if (argc == 4) 686 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1) 687 { 688 lt = localtime (&tl); 689 if (lt) 690 { 691 tmk = tml = *lt; 692 tk = mktime (&tmk); 693 status |= check_result (tk, tmk, tl, &tml); 694 } 695 else 696 { 697 printf ("localtime (%ld) yields 0\n", (long int) tl); 698 status = 1; 699 } 700 tl1 = tl + by; 701 if ((tl1 < tl) != (by < 0)) 702 break; 703 } 704 else 705 for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1) 706 { 707 /* Null benchmark. */ 708 lt = localtime (&tl); 709 if (lt) 710 { 711 tmk = tml = *lt; 712 tk = tl; 713 status |= check_result (tk, tmk, tl, &tml); 714 } 715 else 716 { 717 printf ("localtime (%ld) yields 0\n", (long int) tl); 718 status = 1; 719 } 720 tl1 = tl + by; 721 if ((tl1 < tl) != (by < 0)) 722 break; 723 } 724 } 725 else 726 printf ("Usage:\ 727 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\ 728 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\ 729 \t%s FROM BY TO - # Do not test those values (for benchmark).\n", 730 argv[0], argv[0], argv[0]); 731 732 return status; 733 } 734 735 #endif /* DEBUG */ 736 737 /* 738 Local Variables: 739 compile-command: "gcc -DDEBUG -I. -Wall -W -O2 -g mktime.c -o mktime" 740 End: 741 */ 742