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