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