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 int 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 static const int safe_years[28] = {
  62     2016, 2017, 2018, 2019,
  63     2020, 2021, 2022, 2023,
  64     2024, 2025, 2026, 2027,
  65     2028, 2029, 2030, 2031,
  66     2032, 2033, 2034, 2035,
  67     2036, 2037, 2010, 2011,
  68     2012, 2013, 2014, 2015
  69 };
  70
  71 #define SOLAR_CYCLE_LENGTH 28
  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 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 /* timegm() is a GNU extension, so emulate it here if we need it */
 115 #ifdef HAS_TIMEGM
 116 #    define TIMEGM(n) timegm(n);
 117 #else
 118 #    define TIMEGM(n) ((time_t)timegm64(n));
 119 #endif
 120
 121 Time64_T timegm64(struct tm *date) {
 122     int   days    = 0;
 123     Int64 seconds = 0;
 124     Int64 year;
 125
 126     if( date->tm_year > 70 ) {
 127         year = 70;
 128         while( year < date->tm_year ) {
 129             days += length_of_year[IS_LEAP(year)];
 130             year++;
 131         }
 132     }
 133     else if ( date->tm_year < 70 ) {
 134         year = 69;
 135         do {
 136             days -= length_of_year[IS_LEAP(year)];
 137             year--;
 138         } while( year >= date->tm_year );
 139     }
 140
 141     days += julian_days_by_month[IS_LEAP(date->tm_year)][date->tm_mon];
 142     days += date->tm_mday - 1;
 143
 144     /* Avoid overflowing the days integer */
 145     seconds = days;
 146     seconds = seconds * 60 * 60 * 24;
 147
 148     seconds += date->tm_hour * 60 * 60;
 149     seconds += date->tm_min * 60;
 150     seconds += date->tm_sec;
 151
 152     return((Time64_T)seconds);
 153 }
 154
 155
 156 int _check_tm(struct tm *tm)
 157 {
 158     /* Don't forget leap seconds */
 159     assert(tm->tm_sec >= 0);
 160     assert(tm->tm_sec <= 61);
 161
 162     assert(tm->tm_min >= 0);
 163     assert(tm->tm_min <= 59);
 164
 165     assert(tm->tm_hour >= 0);
 166     assert(tm->tm_hour <= 23);
 167
 168     assert(tm->tm_mday >= 1);
 169     assert(tm->tm_mday <= days_in_month[IS_LEAP(tm->tm_year)][tm->tm_mon]);
 170
 171     assert(tm->tm_mon  >= 0);
 172     assert(tm->tm_mon  <= 11);
 173
 174     assert(tm->tm_wday >= 0);
 175     assert(tm->tm_wday <= 6);
 176
 177     assert(tm->tm_yday >= 0);
 178     assert(tm->tm_yday <= length_of_year[IS_LEAP(tm->tm_year)]);
 179
 180 #ifdef HAS_TM_TM_GMTOFF
 181     assert(tm->tm_gmtoff >= -24 * 60 * 60);
 182     assert(tm->tm_gmtoff <=  24 * 60 * 60);
 183 #endif
 184
 185     return 1;
 186 }
 187
 188
 189 /* The exceptional centuries without leap years cause the cycle to
 190    shift by 16
 191 */
 192 Year _cycle_offset(Year year)
 193 {
 194     const Year start_year = 2000;
 195     Year year_diff  = year - start_year;
 196     Year exceptions;
 197
 198     if( year > start_year )
 199         year_diff--;
 200
 201     exceptions  = year_diff / 100;
 202     exceptions -= year_diff / 400;
 203
 204     /*
 205     fprintf(stderr, "# year: %lld, exceptions: %lld, year_diff: %lld\n",
 206             year, exceptions, year_diff);
 207     */
 208
 209     return exceptions * 16;
 210 }
 211
 212 /* For a given year after 2038, pick the latest possible matching
 213    year in the 28 year calendar cycle.
 214
 215    A matching year...
 216    1) Starts on the same day of the week.
 217    2) Has the same leap year status.
 218
 219    This is so the calendars match up.
 220
 221    Also the previous year must match.  When doing Jan 1st you might
 222    wind up on Dec 31st the previous year when doing a -UTC time zone.
 223
 224    Finally, the next year must have the same start day of week.  This
 225    is for Dec 31st with a +UTC time zone.
 226    It doesn't need the same leap year status since we only care about
 227    January 1st.
 228 */
 229 int _safe_year(Year year)
 230 {
 231     int safe_year;
 232     Year year_cycle = year + _cycle_offset(year);
 233
 234     /* Change non-leap xx00 years to an equivalent */
 235     if( _is_exception_century(year) )
 236         year_cycle += 11;
 237
 238     /* Also xx01 years, since the previous year will be wrong */
 239     if( _is_exception_century(year - 1) )
 240         year_cycle += 17;
 241
 242     year_cycle %= SOLAR_CYCLE_LENGTH;
 243     if( year_cycle < 0 )
 244         year_cycle = SOLAR_CYCLE_LENGTH + year_cycle;
 245
 246     assert( year_cycle >= 0 );
 247     assert( year_cycle < SOLAR_CYCLE_LENGTH );
 248     safe_year = safe_years[year_cycle];
 249
 250     assert(safe_year <= 2037 && safe_year >= 2010);
 251
 252     /*
 253     printf("year: %d, year_cycle: %d, safe_year: %d\n",
 254            year, year_cycle, safe_year);
 255     */
 256
 257     return safe_year;
 258 }
 259
 260
 261 /* Simulate localtime_r() to the best of our ability */
 262 struct tm * fake_localtime_r(const time_t *clock, struct tm *result) {
 263     const struct tm *static_result = localtime(clock);
 264
 265     assert(result != NULL);
 266
 267     if( static_result == NULL ) {
 268         memset(result, 0, sizeof(*result));
 269         return NULL;
 270     }
 271     else {
 272         memcpy(result, static_result, sizeof(*result));
 273         return result;
 274     }
 275 }
 276
 277
 278 /* Simulate gmtime_r() to the best of our ability */
 279 struct tm * fake_gmtime_r(const time_t *clock, struct tm *result) {
 280     const struct tm *static_result = gmtime(clock);
 281
 282     assert(result != NULL);
 283
 284     if( static_result == NULL ) {
 285         memset(result, 0, sizeof(*result));
 286         return NULL;
 287     }
 288     else {
 289         memcpy(result, static_result, sizeof(*result));
 290         return result;
 291     }
 292 }
 293
 294
 295 struct tm *gmtime64_r (const Time64_T *in_time, struct tm *p)
 296 {
 297     int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
 298     Int64 v_tm_tday;
 299     int leap;
 300     Int64 m;
 301     Time64_T time = *in_time;
 302     Year year = 70;
 303
 304     assert(p != NULL);
 305
 306     /* Use the system gmtime() if time_t is small enough */
 307     if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
 308         time_t safe_time = *in_time;
 309         GMTIME_R(&safe_time, p);
 310         assert(_check_tm(p));
 311         return p;
 312     }
 313
 314 #ifdef HAS_TM_TM_GMTOFF
 315     p->tm_gmtoff = 0;
 316 #endif
 317     p->tm_isdst  = 0;
 318
 319 #ifdef HAS_TM_TM_ZONE
 320     p->tm_zone   = "UTC";
 321 #endif
 322
 323     v_tm_sec =  (int)(time % 60);
 324     time /= 60;
 325     v_tm_min =  (int)(time % 60);
 326     time /= 60;
 327     v_tm_hour = (int)(time % 24);
 328     time /= 24;
 329     v_tm_tday = time;
 330
 331     WRAP (v_tm_sec, v_tm_min, 60);
 332     WRAP (v_tm_min, v_tm_hour, 60);
 333     WRAP (v_tm_hour, v_tm_tday, 24);
 334
 335     v_tm_wday = (int)((v_tm_tday + 4) % 7);
 336     if (v_tm_wday < 0)
 337         v_tm_wday += 7;
 338     m = v_tm_tday;
 339
 340     if (m >= CHEAT_DAYS) {
 341         year = CHEAT_YEARS;
 342         m -= CHEAT_DAYS;
 343     }
 344
 345     if (m >= 0) {
 346         /* Gregorian cycles, this is huge optimization for distant times */
 347         while (m >= (Time64_T) days_in_gregorian_cycle) {
 348             m -= (Time64_T) days_in_gregorian_cycle;
 349             year += years_in_gregorian_cycle;
 350         }
 351
 352         /* Years */
 353         leap = IS_LEAP (year);
 354         while (m >= (Time64_T) length_of_year[leap]) {
 355             m -= (Time64_T) length_of_year[leap];
 356             year++;
 357             leap = IS_LEAP (year);
 358         }
 359
 360         /* Months */
 361         v_tm_mon = 0;
 362         while (m >= (Time64_T) days_in_month[leap][v_tm_mon]) {
 363             m -= (Time64_T) days_in_month[leap][v_tm_mon];
 364             v_tm_mon++;
 365         }
 366     } else {
 367         year--;
 368
 369         /* Gregorian cycles */
 370         while (m < (Time64_T) -days_in_gregorian_cycle) {
 371             m += (Time64_T) days_in_gregorian_cycle;
 372             year -= years_in_gregorian_cycle;
 373         }
 374
 375         /* Years */
 376         leap = IS_LEAP (year);
 377         while (m < (Time64_T) -length_of_year[leap]) {
 378             m += (Time64_T) length_of_year[leap];
 379             year--;
 380             leap = IS_LEAP (year);
 381         }
 382
 383         /* Months */
 384         v_tm_mon = 11;
 385         while (m < (Time64_T) -days_in_month[leap][v_tm_mon]) {
 386             m += (Time64_T) days_in_month[leap][v_tm_mon];
 387             v_tm_mon--;
 388         }
 389         m += (Time64_T) days_in_month[leap][v_tm_mon];
 390     }
 391
 392     p->tm_year = year;
 393     if( p->tm_year != year ) {
 394 #ifdef EOVERFLOW
 395         errno = EOVERFLOW;
 396 #endif
 397         return NULL;
 398     }
 399
 400     p->tm_mday = (int) m + 1;
 401     p->tm_yday = (int) julian_days_by_month[leap][v_tm_mon] + m;
 402     p->tm_sec = v_tm_sec, p->tm_min = v_tm_min, p->tm_hour = v_tm_hour,
 403         p->tm_mon = v_tm_mon, p->tm_wday = v_tm_wday;
 404
 405     assert(_check_tm(p));
 406
 407     return p;
 408 }
 409
 410
 411 struct tm *localtime64_r (const Time64_T *time, struct tm *local_tm)
 412 {
 413     time_t safe_time;
 414     struct tm gm_tm;
 415     Year orig_year;
 416     int month_diff;
 417
 418     assert(local_tm != NULL);
 419
 420     /* Use the system localtime() if time_t is small enough */
 421     if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
 422         safe_time = *time;
 423         LOCALTIME_R(&safe_time, local_tm);
 424         assert(_check_tm(local_tm));
 425         return local_tm;
 426     }
 427
 428     if( gmtime64_r(time, &gm_tm) == NULL )
 429         return NULL;
 430
 431     orig_year = gm_tm.tm_year;
 432
 433     if (gm_tm.tm_year > (2037 - 1900) ||
 434         gm_tm.tm_year < (1902 - 1900)
 435        )
 436     {
 437         gm_tm.tm_year = _safe_year(gm_tm.tm_year + 1900) - 1900;
 438     }
 439
 440     safe_time = TIMEGM(&gm_tm);
 441     if( LOCALTIME_R(&safe_time, local_tm) == NULL )
 442         return NULL;
 443
 444     local_tm->tm_year = orig_year;
 445     if( local_tm->tm_year != orig_year ) {
 446 #ifdef EOVERFLOW
 447         errno = EOVERFLOW;
 448 #endif
 449         return NULL;
 450     }
 451
 452
 453     month_diff = local_tm->tm_mon - gm_tm.tm_mon;
 454
 455     /*  When localtime is Dec 31st previous year and
 456         gmtime is Jan 1st next year.
 457     */
 458     if( month_diff == 11 ) {
 459         local_tm->tm_year--;
 460     }
 461
 462     /*  When localtime is Jan 1st, next year and
 463         gmtime is Dec 31st, previous year.
 464     */
 465     if( month_diff == -11 ) {
 466         local_tm->tm_year++;
 467     }
 468
 469     /* GMT is Jan 1st, xx01 year, but localtime is still Dec 31st
 470        in a non-leap xx00.  There is one point in the cycle
 471        we can't account for which the safe xx00 year is a leap
 472        year.  So we need to correct for Dec 31st comming out as
 473        the 366th day of the year.
 474     */
 475     if( !IS_LEAP(local_tm->tm_year) && local_tm->tm_yday == 365 )
 476         local_tm->tm_yday--;
 477
 478     assert(_check_tm(local_tm));
 479
 480     return local_tm;
 481 }