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 Programmers who have available to them 64-bit time values as a 'long
  32 long' type can use localtime64_r() and gmtime64_r() which correctly
  33 converts the time even on 32-bit systems. Whether you have 64-bit time
  34 values will depend on the operating system.
  35
  36 localtime64_r() is a 64-bit equivalent of localtime_r().
  37
  38 gmtime64_r() is a 64-bit equivalent of gmtime_r().
  39
  40 */
  41
  42 #include "time64.h"
  43
  44 static const int days_in_month[2][12] = {
  45     {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
  46     {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
  47 };
  48
  49 static const int julian_days_by_month[2][12] = {
  50     {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
  51     {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335},
  52 };
  53
  54 static const int length_of_year[2] = { 365, 366 };
  55
  56 /* Number of days in a 400 year Gregorian cycle */
  57 static const Year years_in_gregorian_cycle = 400;
  58 static const int days_in_gregorian_cycle  = (365 * 400) + 100 - 4 + 1;
  59
  60 /* 28 year calendar cycle between 2010 and 2037 */
  61 #define SOLAR_CYCLE_LENGTH 28
  62 static const int safe_years[SOLAR_CYCLE_LENGTH] = {
  63     2016, 2017, 2018, 2019,
  64     2020, 2021, 2022, 2023,
  65     2024, 2025, 2026, 2027,
  66     2028, 2029, 2030, 2031,
  67     2032, 2033, 2034, 2035,
  68     2036, 2037, 2010, 2011,
  69     2012, 2013, 2014, 2015
  70 };
  71
  72 static const int dow_year_start[SOLAR_CYCLE_LENGTH] = {
  73     5, 0, 1, 2,     /* 0       2016 - 2019 */
  74     3, 5, 6, 0,     /* 4  */
  75     1, 3, 4, 5,     /* 8  */
  76     6, 1, 2, 3,     /* 12 */
  77     4, 6, 0, 1,     /* 16 */
  78     2, 4, 5, 6,     /* 20      2036, 2037, 2010, 2011 */
  79     0, 2, 3, 4      /* 24      2012, 2013, 2014, 2015 */
  80 };
  81
  82 /* Let's assume people are going to be looking for dates in the future.
  83    Let's provide some cheats so you can skip ahead.
  84    This has a 4x speed boost when near 2008.
  85 */
  86 /* Number of days since epoch on Jan 1st, 2008 GMT */
  87 #define CHEAT_DAYS  (1199145600 / 24 / 60 / 60)
  88 #define CHEAT_YEARS 108
  89
  90 #define IS_LEAP(n)      ((!(((n) + 1900) % 400) || (!(((n) + 1900) % 4) && (((n) + 1900) % 100))) != 0)
  91 #define WRAP(a,b,m)     ((a) = ((a) <  0  ) ? ((b)--, (a) + (m)) : (a))
  92
  93 #define SHOULD_USE_SYSTEM_LOCALTIME(a)  (       \
  94     USE_SYSTEM_LOCALTIME        &&              \
  95     (a) <= SYSTEM_LOCALTIME_MAX &&              \
  96     (a) >= SYSTEM_LOCALTIME_MIN                 \
  97 )
  98 #define SHOULD_USE_SYSTEM_GMTIME(a)     (       \
  99     USE_SYSTEM_GMTIME           &&              \
 100     (a) <= SYSTEM_GMTIME_MAX    &&              \
 101     (a) >= SYSTEM_GMTIME_MIN                    \
 102 )
 103
 104
 105 static int is_exception_century(Int64 year)
 106 {
 107     int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
 108     /* printf("is_exception_century: %s\n", is_exception ? "yes" : "no"); */
 109
 110     return(is_exception);
 111 }
 112
 113
 114 Time64_T timegm64(struct TM *date) {
 115     int   days    = 0;
 116     Int64 seconds = 0;
 117     Int64 year;
 118
 119     if( date->tm_year > 70 ) {
 120         year = 70;
 121         while( year < date->tm_year ) {
 122             days += length_of_year[IS_LEAP(year)];
 123             year++;
 124         }
 125     }
 126     else if ( date->tm_year < 70 ) {
 127         year = 69;
 128         do {
 129             days -= length_of_year[IS_LEAP(year)];
 130             year--;
 131         } while( year >= date->tm_year );
 132     }
 133
 134     days += julian_days_by_month[IS_LEAP(date->tm_year)][date->tm_mon];
 135     days += date->tm_mday - 1;
 136
 137     /* Avoid overflowing the days integer */
 138     seconds = days;
 139     seconds = seconds * 60 * 60 * 24;
 140
 141     seconds += date->tm_hour * 60 * 60;
 142     seconds += date->tm_min * 60;
 143     seconds += date->tm_sec;
 144
 145     return((Time64_T)seconds);
 146 }
 147
 148
 149 static int check_tm(struct TM *tm)
 150 {
 151     /* Don't forget leap seconds */
 152     assert(tm->tm_sec >= 0);
 153     assert(tm->tm_sec <= 61);
 154
 155     assert(tm->tm_min >= 0);
 156     assert(tm->tm_min <= 59);
 157
 158     assert(tm->tm_hour >= 0);
 159     assert(tm->tm_hour <= 23);
 160
 161     assert(tm->tm_mday >= 1);
 162     assert(tm->tm_mday <= days_in_month[IS_LEAP(tm->tm_year)][tm->tm_mon]);
 163
 164     assert(tm->tm_mon  >= 0);
 165     assert(tm->tm_mon  <= 11);
 166
 167     assert(tm->tm_wday >= 0);
 168     assert(tm->tm_wday <= 6);
 169
 170     assert(tm->tm_yday >= 0);
 171     assert(tm->tm_yday <= length_of_year[IS_LEAP(tm->tm_year)]);
 172
 173 #ifdef HAS_TM_TM_GMTOFF
 174     assert(tm->tm_gmtoff >= -24 * 60 * 60);
 175     assert(tm->tm_gmtoff <=  24 * 60 * 60);
 176 #endif
 177
 178     return 1;
 179 }
 180
 181
 182 /* The exceptional centuries without leap years cause the cycle to
 183    shift by 16
 184 */
 185 static Year cycle_offset(Year year)
 186 {
 187     const Year start_year = 2000;
 188     Year year_diff  = year - start_year;
 189     Year exceptions;
 190
 191     if( year > start_year )
 192         year_diff--;
 193
 194     exceptions  = year_diff / 100;
 195     exceptions -= year_diff / 400;
 196
 197     /*
 198     fprintf(stderr, "# year: %lld, exceptions: %lld, year_diff: %lld\n",
 199             year, exceptions, year_diff);
 200     */
 201
 202     return exceptions * 16;
 203 }
 204
 205 /* For a given year after 2038, pick the latest possible matching
 206    year in the 28 year calendar cycle.
 207
 208    A matching year...
 209    1) Starts on the same day of the week.
 210    2) Has the same leap year status.
 211
 212    This is so the calendars match up.
 213
 214    Also the previous year must match.  When doing Jan 1st you might
 215    wind up on Dec 31st the previous year when doing a -UTC time zone.
 216
 217    Finally, the next year must have the same start day of week.  This
 218    is for Dec 31st with a +UTC time zone.
 219    It doesn't need the same leap year status since we only care about
 220    January 1st.
 221 */
 222 static int safe_year(Year year)
 223 {
 224     int safe_year;
 225     Year year_cycle = year + cycle_offset(year);
 226
 227     /* Change non-leap xx00 years to an equivalent */
 228     if( is_exception_century(year) )
 229         year_cycle += 11;
 230
 231     /* Also xx01 years, since the previous year will be wrong */
 232     if( is_exception_century(year - 1) )
 233         year_cycle += 17;
 234
 235     year_cycle %= SOLAR_CYCLE_LENGTH;
 236     if( year_cycle < 0 )
 237         year_cycle = SOLAR_CYCLE_LENGTH + year_cycle;
 238
 239     assert( year_cycle >= 0 );
 240     assert( year_cycle < SOLAR_CYCLE_LENGTH );
 241     safe_year = safe_years[year_cycle];
 242
 243     assert(safe_year <= 2037 && safe_year >= 2010);
 244
 245     /*
 246     printf("year: %d, year_cycle: %d, safe_year: %d\n",
 247            year, year_cycle, safe_year);
 248     */
 249
 250     return safe_year;
 251 }
 252
 253
 254 void copy_tm_to_TM(const struct tm *src, struct TM *dest) {
 255     if( src == NULL ) {
 256         memset(dest, 0, sizeof(*dest));
 257     }
 258     else {
 259 #       ifdef USE_TM64
 260             dest->tm_sec        = src->tm_sec;
 261             dest->tm_min        = src->tm_min;
 262             dest->tm_hour       = src->tm_hour;
 263             dest->tm_mday       = src->tm_mday;
 264             dest->tm_mon        = src->tm_mon;
 265             dest->tm_year       = (Year)src->tm_year;
 266             dest->tm_wday       = src->tm_wday;
 267             dest->tm_yday       = src->tm_yday;
 268             dest->tm_isdst      = src->tm_isdst;
 269
 270 #           ifdef HAS_TM_TM_GMTOFF
 271                 dest->tm_gmtoff  = src->tm_gmtoff;
 272 #           endif
 273
 274 #           ifdef HAS_TM_TM_ZONE
 275                 dest->tm_zone  = src->tm_zone;
 276 #           endif
 277
 278 #       else
 279             /* They're the same type */
 280             memcpy(dest, src, sizeof(*dest));
 281 #       endif
 282     }
 283 }
 284
 285
 286 void copy_TM_to_tm(const struct TM *src, struct tm *dest) {
 287     if( src == NULL ) {
 288         memset(dest, 0, sizeof(*dest));
 289     }
 290     else {
 291 #       ifdef USE_TM64
 292             dest->tm_sec        = src->tm_sec;
 293             dest->tm_min        = src->tm_min;
 294             dest->tm_hour       = src->tm_hour;
 295             dest->tm_mday       = src->tm_mday;
 296             dest->tm_mon        = src->tm_mon;
 297             dest->tm_year       = (int)src->tm_year;
 298             dest->tm_wday       = src->tm_wday;
 299             dest->tm_yday       = src->tm_yday;
 300             dest->tm_isdst      = src->tm_isdst;
 301
 302 #           ifdef HAS_TM_TM_GMTOFF
 303                 dest->tm_gmtoff  = src->tm_gmtoff;
 304 #           endif
 305
 306 #           ifdef HAS_TM_TM_ZONE
 307                 dest->tm_zone  = src->tm_zone;
 308 #           endif
 309
 310 #       else
 311             /* They're the same type */
 312             memcpy(dest, src, sizeof(*dest));
 313 #       endif
 314     }
 315 }
 316
 317
 318 /* Simulate localtime_r() to the best of our ability */
 319 struct tm * fake_localtime_r(const time_t *clock, struct tm *result) {
 320     const struct tm *static_result = localtime(clock);
 321
 322     assert(result != NULL);
 323
 324     if( static_result == NULL ) {
 325         memset(result, 0, sizeof(*result));
 326         return NULL;
 327     }
 328     else {
 329         memcpy(result, static_result, sizeof(*result));
 330         return result;
 331     }
 332 }
 333
 334
 335 /* Simulate gmtime_r() to the best of our ability */
 336 struct tm * fake_gmtime_r(const time_t *clock, struct tm *result) {
 337     const struct tm *static_result = gmtime(clock);
 338
 339     assert(result != NULL);
 340
 341     if( static_result == NULL ) {
 342         memset(result, 0, sizeof(*result));
 343         return NULL;
 344     }
 345     else {
 346         memcpy(result, static_result, sizeof(*result));
 347         return result;
 348     }
 349 }
 350
 351
 352 struct TM *gmtime64_r (const Time64_T *in_time, struct TM *p)
 353 {
 354     int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
 355     Int64 v_tm_tday;
 356     int leap;
 357     Int64 m;
 358     Time64_T time = *in_time;
 359     Year year = 70;
 360     int cycles = 0;
 361
 362     assert(p != NULL);
 363
 364     /* Use the system gmtime() if time_t is small enough */
 365     if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
 366         time_t safe_time = *in_time;
 367         struct tm safe_date;
 368         GMTIME_R(&safe_time, &safe_date);
 369
 370         copy_tm_to_TM(&safe_date, p);
 371         assert(check_tm(p));
 372
 373         return p;
 374     }
 375
 376 #ifdef HAS_TM_TM_GMTOFF
 377     p->tm_gmtoff = 0;
 378 #endif
 379     p->tm_isdst  = 0;
 380
 381 #ifdef HAS_TM_TM_ZONE
 382     p->tm_zone   = "UTC";
 383 #endif
 384
 385     v_tm_sec =  (int)(time % 60);
 386     time /= 60;
 387     v_tm_min =  (int)(time % 60);
 388     time /= 60;
 389     v_tm_hour = (int)(time % 24);
 390     time /= 24;
 391     v_tm_tday = time;
 392
 393     WRAP (v_tm_sec, v_tm_min, 60);
 394     WRAP (v_tm_min, v_tm_hour, 60);
 395     WRAP (v_tm_hour, v_tm_tday, 24);
 396
 397     v_tm_wday = (int)((v_tm_tday + 4) % 7);
 398     if (v_tm_wday < 0)
 399         v_tm_wday += 7;
 400     m = v_tm_tday;
 401
 402     if (m >= CHEAT_DAYS) {
 403         year = CHEAT_YEARS;
 404         m -= CHEAT_DAYS;
 405     }
 406
 407     if (m >= 0) {
 408         /* Gregorian cycles, this is huge optimization for distant times */
 409         cycles = floor(m / (Time64_T) days_in_gregorian_cycle);
 410         if( cycles ) {
 411             m -= (cycles * (Time64_T) days_in_gregorian_cycle);
 412             year += (cycles * years_in_gregorian_cycle);
 413         }
 414
 415         /* Years */
 416         leap = IS_LEAP (year);
 417         while (m >= (Time64_T) length_of_year[leap]) {
 418             m -= (Time64_T) length_of_year[leap];
 419             year++;
 420             leap = IS_LEAP (year);
 421         }
 422
 423         /* Months */
 424         v_tm_mon = 0;
 425         while (m >= (Time64_T) days_in_month[leap][v_tm_mon]) {
 426             m -= (Time64_T) days_in_month[leap][v_tm_mon];
 427             v_tm_mon++;
 428         }
 429     } else {
 430         year--;
 431
 432         /* Gregorian cycles */
 433         cycles = ceil(m / (Time64_T) days_in_gregorian_cycle) + 1;
 434         if( cycles ) {
 435             m -= (cycles * (Time64_T) days_in_gregorian_cycle);
 436             year += (cycles * years_in_gregorian_cycle);
 437         }
 438
 439         /* Years */
 440         leap = IS_LEAP (year);
 441         while (m < (Time64_T) -length_of_year[leap]) {
 442             m += (Time64_T) length_of_year[leap];
 443             year--;
 444             leap = IS_LEAP (year);
 445         }
 446
 447         /* Months */
 448         v_tm_mon = 11;
 449         while (m < (Time64_T) -days_in_month[leap][v_tm_mon]) {
 450             m += (Time64_T) days_in_month[leap][v_tm_mon];
 451             v_tm_mon--;
 452         }
 453         m += (Time64_T) days_in_month[leap][v_tm_mon];
 454     }
 455
 456     p->tm_year = year;
 457     if( p->tm_year != year ) {
 458 #ifdef EOVERFLOW
 459         errno = EOVERFLOW;
 460 #endif
 461         return NULL;
 462     }
 463
 464     p->tm_mday = (int) m + 1;
 465     p->tm_yday = (int) julian_days_by_month[leap][v_tm_mon] + m;
 466     p->tm_sec = v_tm_sec, p->tm_min = v_tm_min, p->tm_hour = v_tm_hour,
 467         p->tm_mon = v_tm_mon, p->tm_wday = v_tm_wday;
 468
 469     assert(check_tm(p));
 470
 471     return p;
 472 }
 473
 474
 475 struct TM *localtime64_r (const Time64_T *time, struct TM *local_tm)
 476 {
 477     time_t safe_time;
 478     struct tm safe_date;
 479     struct TM gm_tm;
 480     Year orig_year;
 481     int month_diff;
 482
 483     assert(local_tm != NULL);
 484
 485     /* Use the system localtime() if time_t is small enough */
 486     if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
 487         safe_time = *time;
 488
 489         LOCALTIME_R(&safe_time, &safe_date);
 490
 491         copy_tm_to_TM(&safe_date, local_tm);
 492         assert(check_tm(local_tm));
 493
 494         return local_tm;
 495     }
 496
 497     if( gmtime64_r(time, &gm_tm) == NULL )
 498         return NULL;
 499
 500     orig_year = gm_tm.tm_year;
 501
 502     if (gm_tm.tm_year > (2037 - 1900) ||
 503         gm_tm.tm_year < (1902 - 1900)
 504        )
 505     {
 506         gm_tm.tm_year = safe_year(gm_tm.tm_year + 1900) - 1900;
 507     }
 508
 509     safe_time = timegm64(&gm_tm);
 510     if( LOCALTIME_R(&safe_time, &safe_date) == NULL )
 511         return NULL;
 512
 513     copy_tm_to_TM(&safe_date, local_tm);
 514
 515     local_tm->tm_year = orig_year;
 516     if( local_tm->tm_year != orig_year ) {
 517 #ifdef EOVERFLOW
 518         errno = EOVERFLOW;
 519 #endif
 520         return NULL;
 521     }
 522
 523
 524     month_diff = local_tm->tm_mon - gm_tm.tm_mon;
 525
 526     /*  When localtime is Dec 31st previous year and
 527         gmtime is Jan 1st next year.
 528     */
 529     if( month_diff == 11 ) {
 530         local_tm->tm_year--;
 531     }
 532
 533     /*  When localtime is Jan 1st, next year and
 534         gmtime is Dec 31st, previous year.
 535     */
 536     if( month_diff == -11 ) {
 537         local_tm->tm_year++;
 538     }
 539
 540     /* GMT is Jan 1st, xx01 year, but localtime is still Dec 31st
 541        in a non-leap xx00.  There is one point in the cycle
 542        we can't account for which the safe xx00 year is a leap
 543        year.  So we need to correct for Dec 31st comming out as
 544        the 366th day of the year.
 545     */
 546     if( !IS_LEAP(local_tm->tm_year) && local_tm->tm_yday == 365 )
 547         local_tm->tm_yday--;
 548
 549     assert(check_tm(local_tm));
 550
 551     return local_tm;
 552 }