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