time64.c

   1 /*
   2
   3 Copyright (c) 2007-2008  Michael G Schwern
   4
   5 This software originally derived from Paul Sheer's pivotal_gmtime_r.c.
   6
   7 The MIT License:
   8
   9 Permission is hereby granted, free of charge, to any person obtaining a copy
  10 of this software and associated documentation files (the "Software"), to deal
  11 in the Software without restriction, including without limitation the rights
  12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13 copies of the Software, and to permit persons to whom the Software is
  14 furnished to do so, subject to the following conditions:
  15
  16 The above copyright notice and this permission notice shall be included in
  17 all copies or substantial portions of the Software.
  18
  19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25 THE SOFTWARE.
  26
  27 */
  28
  29
  30 /*
  31  *   This thing all things devours:
  32  *   Birds, beasts, trees, flowers;
  33  *   Gnaws iron, bites steel;
  34  *   Grinds hard stones to meal;
  35  *   Slays king, ruins town,
  36  *   And beats high mountain down."
  37  *
  38  * Poor Bilbo sat in the dark thinking of all the horrible names of all the
  39  * giants and ogres he had ever heard told of in tales, but not one of them had
  40  * done all these things. He had a feeling that the answer was quite different
  41  * and that he ought to know it, but he could not think of it. He began to get
  42  * frightened, and that is bad for thinking. Gollum began to get out of his
  43  * boat. He flapped into the water and paddled to the bank; Bilbo could see his
  44  * eyes coming towards him. His tongue seemed to stick in his mouth; he wanted
  45  * to shout out: "Give me more time! Give me time!" But all that came out with
  46  * a sudden squeal was:
  47  *
  48  * "Time! Time!"
  49  *
  50  * Bilbo was saved by pure luck. For that of course was the answer.
  51  *
  52  *     [p.84 of _The Hobbit_: "Riddles in the Dark"]
  53  *
  54 */
  55
  56 /*
  57
  58 Programmers who have available to them 64-bit time values as a 'long
  59 long' type can use localtime64_r() and gmtime64_r() which correctly
  60 converts the time even on 32-bit systems. Whether you have 64-bit time
  61 values will depend on the operating system.
  62
  63 Perl_localtime64_r() is a 64-bit equivalent of localtime_r().
  64
  65 Perl_gmtime64_r() is a 64-bit equivalent of gmtime_r().
  66
  67 */
  68
  69 #include "EXTERN.h"
  70 #define PERL_IN_TIME64_C
  71 #include "perl.h"
  72 #include "time64.h"
  73
  74 static const char days_in_month[2][12] = {
  75     {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
  76     {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
  77 };
  78
  79 static const short julian_days_by_month[2][12] = {
  80     {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
  81     {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335},
  82 };
  83
  84 static const short length_of_year[2] = { 365, 366 };
  85
  86 /* Number of days in a 400 year Gregorian cycle */
  87 static const Year years_in_gregorian_cycle = 400;
  88 static const int days_in_gregorian_cycle  = (365 * 400) + 100 - 4 + 1;
  89
  90 /* 28 year calendar cycle between 2010 and 2037 */
  91 #define SOLAR_CYCLE_LENGTH 28
  92 static const short safe_years[SOLAR_CYCLE_LENGTH] = {
  93     2016, 2017, 2018, 2019,
  94     2020, 2021, 2022, 2023,
  95     2024, 2025, 2026, 2027,
  96     2028, 2029, 2030, 2031,
  97     2032, 2033, 2034, 2035,
  98     2036, 2037, 2010, 2011,
  99     2012, 2013, 2014, 2015
 100 };
 101
 102 /* Let's assume people are going to be looking for dates in the future.
 103    Let's provide some cheats so you can skip ahead.
 104    This has a 4x speed boost when near 2008.
 105 */
 106 /* Number of days since epoch on Jan 1st, 2008 GMT */
 107 #define CHEAT_DAYS  (1199145600 / 24 / 60 / 60)
 108 #define CHEAT_YEARS 108
 109
 110 #define IS_LEAP(n)      ((!(((n) + 1900) % 400) || (!(((n) + 1900) % 4) && (((n) + 1900) % 100))) != 0)
 111 #undef WRAP /* some <termios.h> define this */
 112 #define WRAP(a,b,m)     ((a) = ((a) <  0  ) ? ((b)--, (a) + (m)) : (a))
 113
 114 #ifdef USE_SYSTEM_LOCALTIME
 115 #    define SHOULD_USE_SYSTEM_LOCALTIME(a)  (       \
 116     (a) <= SYSTEM_LOCALTIME_MAX &&              \
 117     (a) >= SYSTEM_LOCALTIME_MIN                 \
 118 )
 119 #else
 120 #    define SHOULD_USE_SYSTEM_LOCALTIME(a)      (0)
 121 #endif
 122
 123 #ifdef USE_SYSTEM_GMTIME
 124 #    define SHOULD_USE_SYSTEM_GMTIME(a)     (       \
 125     (a) <= SYSTEM_GMTIME_MAX    &&              \
 126     (a) >= SYSTEM_GMTIME_MIN                    \
 127 )
 128 #else
 129 #    define SHOULD_USE_SYSTEM_GMTIME(a)         (0)
 130 #endif
 131
 132 /* Multi varadic macros are a C99 thing, alas */
 133 #ifdef TIME_64_DEBUG
 134 #    define TIME64_TRACE(format) (fprintf(stderr, format))
 135 #    define TIME64_TRACE1(format, var1)    (fprintf(stderr, format, var1))
 136 #    define TIME64_TRACE2(format, var1, var2)    (fprintf(stderr, format, var1, var2))
 137 #    define TIME64_TRACE3(format, var1, var2, var3)    (fprintf(stderr, format, var1, var2, var3))
 138 #else
 139 #    define TIME64_TRACE(format) ((void)0)
 140 #    define TIME64_TRACE1(format, var1) ((void)0)
 141 #    define TIME64_TRACE2(format, var1, var2) ((void)0)
 142 #    define TIME64_TRACE3(format, var1, var2, var3) ((void)0)
 143 #endif
 144
 145 static int S_is_exception_century(Year year)
 146 {
 147     const int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
 148     TIME64_TRACE1("# is_exception_century: %s\n", is_exception ? "yes" : "no");
 149
 150     return(is_exception);
 151 }
 152
 153
 154 static Time64_T S_timegm64(const struct TM *date) {
 155     int      days    = 0;
 156     Time64_T seconds = 0;
 157
 158     if( date->tm_year > 70 ) {
 159         Year year = 70;
 160         while( year < date->tm_year ) {
 161             days += length_of_year[IS_LEAP(year)];
 162             year++;
 163         }
 164     }
 165     else if ( date->tm_year < 70 ) {
 166         Year year = 69;
 167         do {
 168             days -= length_of_year[IS_LEAP(year)];
 169             year--;
 170         } while( year >= date->tm_year );
 171     }
 172
 173     days += julian_days_by_month[IS_LEAP(date->tm_year)][date->tm_mon];
 174     days += date->tm_mday - 1;
 175
 176     /* Avoid overflowing the days integer */
 177     seconds = days;
 178     seconds = seconds * 60 * 60 * 24;
 179
 180     seconds += date->tm_hour * 60 * 60;
 181     seconds += date->tm_min * 60;
 182     seconds += date->tm_sec;
 183
 184     return(seconds);
 185 }
 186
 187
 188 #ifdef DEBUGGING
 189 static int S_check_tm(const struct TM *tm)
 190 {
 191     /* Don't forget leap seconds */
 192     assert(tm->tm_sec >= 0);
 193     assert(tm->tm_sec <= 61);
 194
 195     assert(tm->tm_min >= 0);
 196     assert(tm->tm_min <= 59);
 197
 198     assert(tm->tm_hour >= 0);
 199     assert(tm->tm_hour <= 23);
 200
 201     assert(tm->tm_mday >= 1);
 202     assert(tm->tm_mday <= days_in_month[IS_LEAP(tm->tm_year)][tm->tm_mon]);
 203
 204     assert(tm->tm_mon  >= 0);
 205     assert(tm->tm_mon  <= 11);
 206
 207     assert(tm->tm_wday >= 0);
 208     assert(tm->tm_wday <= 6);
 209
 210     assert(tm->tm_yday >= 0);
 211     assert(tm->tm_yday <= length_of_year[IS_LEAP(tm->tm_year)]);
 212
 213 #ifdef HAS_TM_TM_GMTOFF
 214     assert(tm->tm_gmtoff >= -24 * 60 * 60);
 215     assert(tm->tm_gmtoff <=  24 * 60 * 60);
 216 #endif
 217
 218     return 1;
 219 }
 220 #endif
 221
 222
 223 /* The exceptional centuries without leap years cause the cycle to
 224    shift by 16
 225 */
 226 static Year S_cycle_offset(Year year)
 227 {
 228     const Year start_year = 2000;
 229     Year year_diff  = year - start_year;
 230     Year exceptions;
 231
 232     if( year > start_year )
 233         year_diff--;
 234
 235     exceptions  = year_diff / 100;
 236     exceptions -= year_diff / 400;
 237
 238     TIME64_TRACE3("# year: %lld, exceptions: %lld, year_diff: %lld\n",
 239           year, exceptions, year_diff);
 240
 241     return exceptions * 16;
 242 }
 243
 244 /* For a given year after 2038, pick the latest possible matching
 245    year in the 28 year calendar cycle.
 246
 247    A matching year...
 248    1) Starts on the same day of the week.
 249    2) Has the same leap year status.
 250
 251    This is so the calendars match up.
 252
 253    Also the previous year must match.  When doing Jan 1st you might
 254    wind up on Dec 31st the previous year when doing a -UTC time zone.
 255
 256    Finally, the next year must have the same start day of week.  This
 257    is for Dec 31st with a +UTC time zone.
 258    It doesn't need the same leap year status since we only care about
 259    January 1st.
 260 */
 261 static int S_safe_year(Year year)
 262 {
 263     int safe_year;
 264     Year year_cycle = year + S_cycle_offset(year);
 265
 266     /* Change non-leap xx00 years to an equivalent */
 267     if( S_is_exception_century(year) )
 268         year_cycle += 11;
 269
 270     /* Also xx01 years, since the previous year will be wrong */
 271     if( S_is_exception_century(year - 1) )
 272         year_cycle += 17;
 273
 274     year_cycle %= SOLAR_CYCLE_LENGTH;
 275     if( year_cycle < 0 )
 276         year_cycle = SOLAR_CYCLE_LENGTH + year_cycle;
 277
 278     assert( year_cycle >= 0 );
 279     assert( year_cycle < SOLAR_CYCLE_LENGTH );
 280     safe_year = safe_years[year_cycle];
 281
 282     assert(safe_year <= 2037 && safe_year >= 2010);
 283
 284     TIME64_TRACE3("# year: %lld, year_cycle: %lld, safe_year: %d\n",
 285           year, year_cycle, safe_year);
 286
 287     return safe_year;
 288 }
 289
 290
 291 static void S_copy_little_tm_to_big_TM(const struct tm *src, struct TM *dest) {
 292     assert(src);
 293     assert(dest);
 294 #ifdef USE_TM64
 295     dest->tm_sec        = src->tm_sec;
 296     dest->tm_min        = src->tm_min;
 297     dest->tm_hour       = src->tm_hour;
 298     dest->tm_mday       = src->tm_mday;
 299     dest->tm_mon        = src->tm_mon;
 300     dest->tm_year       = (Year)src->tm_year;
 301     dest->tm_wday       = src->tm_wday;
 302     dest->tm_yday       = src->tm_yday;
 303     dest->tm_isdst      = src->tm_isdst;
 304
 305 #  ifdef HAS_TM_TM_GMTOFF
 306     dest->tm_gmtoff     = src->tm_gmtoff;
 307 #  endif
 308
 309 #  ifdef HAS_TM_TM_ZONE
 310     dest->tm_zone       = src->tm_zone;
 311 #  endif
 312
 313 #else
 314     /* They're the same type */
 315     memcpy(dest, src, sizeof(*dest));
 316 #endif
 317 }
 318
 319 struct TM *Perl_gmtime64_r (const Time64_T *in_time, struct TM *p)
 320 {
 321     int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
 322     Time64_T v_tm_tday;
 323     int leap;
 324     Time64_T m;
 325     Time64_T time = *in_time;
 326     Year year = 70;
 327     dTHX;
 328
 329     assert(p != NULL);
 330
 331     /* Use the system gmtime() if time_t is small enough */
 332     if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
 333         time_t safe_time = (time_t)*in_time;
 334         struct tm safe_date;
 335         struct tm * result;
 336
 337         GMTIME_LOCK;
 338
 339         /* reentr.h will automatically replace this with a call to gmtime_r()
 340          * when appropriate */
 341         result = gmtime(&safe_time);
 342
 343         assert(result != NULL);
 344
 345 #if defined(HAS_GMTIME_R) && defined(USE_REENTRANT_API)
 346
 347         PERL_UNUSED_VAR(safe_date);
 348 #else
 349         /* Here, no gmtime_r() and is a threaded perl where the result can be
 350          * overwritten by a call in another thread.  Copy to a safe place,
 351          * hopefully before another gmtime that isn't using the mutexes can
 352          * jump in and trash this result. */
 353         memcpy(&safe_date, result, sizeof(safe_date));
 354         result = &safe_date;
 355 #endif
 356         GMTIME_UNLOCK;
 357
 358         S_copy_little_tm_to_big_TM(result, p);
 359         assert(S_check_tm(p));
 360
 361         return p;
 362     }
 363
 364 #ifdef HAS_TM_TM_GMTOFF
 365     p->tm_gmtoff = 0;
 366 #endif
 367     p->tm_isdst  = 0;
 368
 369 #ifdef HAS_TM_TM_ZONE
 370     p->tm_zone   = "UTC";
 371 #endif
 372
 373     v_tm_sec  = (int)Perl_fmod(time, 60.0);
 374     time      = time >= 0 ? Perl_floor(time / 60.0) : Perl_ceil(time / 60.0);
 375     v_tm_min  = (int)Perl_fmod(time, 60.0);
 376     time      = time >= 0 ? Perl_floor(time / 60.0) : Perl_ceil(time / 60.0);
 377     v_tm_hour = (int)Perl_fmod(time, 24.0);
 378     time      = time >= 0 ? Perl_floor(time / 24.0) : Perl_ceil(time / 24.0);
 379     v_tm_tday = time;
 380
 381     WRAP (v_tm_sec, v_tm_min, 60);
 382     WRAP (v_tm_min, v_tm_hour, 60);
 383     WRAP (v_tm_hour, v_tm_tday, 24);
 384
 385     v_tm_wday = (int)Perl_fmod((v_tm_tday + 4.0), 7.0);
 386     if (v_tm_wday < 0)
 387         v_tm_wday += 7;
 388     m = v_tm_tday;
 389
 390     if (m >= CHEAT_DAYS) {
 391         year = CHEAT_YEARS;
 392         m -= CHEAT_DAYS;
 393     }
 394
 395     if (m >= 0) {
 396         /* Gregorian cycles, this is huge optimization for distant times */
 397         const int cycles = (int)Perl_floor(m / (Time64_T) days_in_gregorian_cycle);
 398         if( cycles ) {
 399             m -= (cycles * (Time64_T) days_in_gregorian_cycle);
 400             year += (cycles * years_in_gregorian_cycle);
 401         }
 402
 403         /* Years */
 404         leap = IS_LEAP (year);
 405         while (m >= (Time64_T) length_of_year[leap]) {
 406             m -= (Time64_T) length_of_year[leap];
 407             year++;
 408             leap = IS_LEAP (year);
 409         }
 410
 411         /* Months */
 412         v_tm_mon = 0;
 413         while (m >= (Time64_T) days_in_month[leap][v_tm_mon]) {
 414             m -= (Time64_T) days_in_month[leap][v_tm_mon];
 415             v_tm_mon++;
 416         }
 417     } else {
 418         int cycles;
 419
 420         year--;
 421
 422         /* Gregorian cycles */
 423         cycles = (int)Perl_ceil((m / (Time64_T) days_in_gregorian_cycle) + 1);
 424         if( cycles ) {
 425             m -= (cycles * (Time64_T) days_in_gregorian_cycle);
 426             year += (cycles * years_in_gregorian_cycle);
 427         }
 428
 429         /* Years */
 430         leap = IS_LEAP (year);
 431         while (m < (Time64_T) -length_of_year[leap]) {
 432             m += (Time64_T) length_of_year[leap];
 433             year--;
 434             leap = IS_LEAP (year);
 435         }
 436
 437         /* Months */
 438         v_tm_mon = 11;
 439         while (m < (Time64_T) -days_in_month[leap][v_tm_mon]) {
 440             m += (Time64_T) days_in_month[leap][v_tm_mon];
 441             v_tm_mon--;
 442         }
 443         m += (Time64_T) days_in_month[leap][v_tm_mon];
 444     }
 445
 446     p->tm_year = year;
 447     if( p->tm_year != year ) {
 448 #ifdef EOVERFLOW
 449         errno = EOVERFLOW;
 450 #endif
 451         return NULL;
 452     }
 453
 454     /* At this point m is less than a year so casting to an int is safe */
 455     p->tm_mday = (int) m + 1;
 456     p->tm_yday = julian_days_by_month[leap][v_tm_mon] + (int)m;
 457     p->tm_sec  = v_tm_sec;
 458     p->tm_min  = v_tm_min;
 459     p->tm_hour = v_tm_hour;
 460     p->tm_mon  = v_tm_mon;
 461     p->tm_wday = v_tm_wday;
 462
 463     assert(S_check_tm(p));
 464
 465     return p;
 466 }
 467
 468
 469 struct TM *Perl_localtime64_r (const Time64_T *time, struct TM *local_tm)
 470 {
 471     time_t safe_time;
 472     struct tm safe_date;
 473     const struct tm * result;
 474     struct TM gm_tm;
 475     Year orig_year = 0; /* initialise to avoid spurious compiler warning */
 476     int month_diff;
 477     const bool use_system = SHOULD_USE_SYSTEM_LOCALTIME(*time);
 478     dTHX;
 479
 480     assert(local_tm != NULL);
 481
 482     /* Use the system localtime() if time_t is small enough */
 483     if (use_system) {
 484         safe_time = (time_t)*time;
 485
 486         TIME64_TRACE1("Using system localtime for %lld\n", *time);
 487     }
 488     else {
 489         if (Perl_gmtime64_r(time, &gm_tm) == NULL) {
 490             TIME64_TRACE1("gmtime64_r returned null for %lld\n", *time);
 491             return NULL;
 492         }
 493
 494         orig_year = gm_tm.tm_year;
 495
 496         if (gm_tm.tm_year > (2037 - 1900) ||
 497             gm_tm.tm_year < (1970 - 1900)
 498            )
 499         {
 500             TIME64_TRACE1("Mapping tm_year %lld to safe_year\n",
 501                                                         (Year)gm_tm.tm_year);
 502             gm_tm.tm_year = S_safe_year((Year)(gm_tm.tm_year + 1900)) - 1900;
 503         }
 504
 505         safe_time = (time_t)S_timegm64(&gm_tm);
 506     }
 507
 508     LOCALTIME_LOCK;
 509
 510     /* reentr.h will automatically replace this with a call to localtime_r()
 511      * when appropriate */
 512     result = localtime(&safe_time);
 513
 514     if(UNLIKELY(result == NULL)) {
 515         LOCALTIME_UNLOCK;
 516         TIME64_TRACE1("localtime(%d) returned NULL\n", (int)safe_time);
 517         return NULL;
 518     }
 519
 520 #if ! defined(USE_REENTRANT_API) || defined(PERL_REENTR_USING_LOCALTIME_R)
 521
 522     PERL_UNUSED_VAR(safe_date);
 523
 524 #else
 525
 526     /* Here, would be using localtime_r() if it could, meaning there isn't one,
 527      * and is a threaded perl where the result can be overwritten by a call in
 528      * another thread.  Copy to a safe place, hopefully before another
 529      * localtime that isn't using the mutexes can jump in and trash this
 530      * result. */
 531     memcpy(&safe_date, result, sizeof(safe_date));
 532     result = &safe_date;
 533
 534 #endif
 535
 536     LOCALTIME_UNLOCK;
 537
 538     S_copy_little_tm_to_big_TM(result, local_tm);
 539
 540     if (! use_system) {
 541
 542         local_tm->tm_year = orig_year;
 543         if( local_tm->tm_year != orig_year ) {
 544             TIME64_TRACE2("tm_year overflow: tm_year %lld, orig_year %lld\n",
 545                   (Year)local_tm->tm_year, (Year)orig_year);
 546
 547 #ifdef EOVERFLOW
 548             errno = EOVERFLOW;
 549 #endif
 550             return NULL;
 551         }
 552
 553         month_diff = local_tm->tm_mon - gm_tm.tm_mon;
 554
 555         /*  When localtime is Dec 31st previous year and
 556             gmtime is Jan 1st next year.
 557         */
 558         if( month_diff == 11 ) {
 559             local_tm->tm_year--;
 560         }
 561
 562         /*  When localtime is Jan 1st, next year and
 563             gmtime is Dec 31st, previous year.
 564         */
 565         if( month_diff == -11 ) {
 566             local_tm->tm_year++;
 567         }
 568
 569         /* GMT is Jan 1st, xx01 year, but localtime is still Dec 31st
 570            in a non-leap xx00.  There is one point in the cycle
 571            we can't account for which the safe xx00 year is a leap
 572            year.  So we need to correct for Dec 31st coming out as
 573            the 366th day of the year.
 574         */
 575         if( !IS_LEAP(local_tm->tm_year) && local_tm->tm_yday == 365 )
 576             local_tm->tm_yday--;
 577
 578     }
 579
 580     assert(S_check_tm(local_tm));
 581
 582     return local_tm;
 583 }