This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
time64.[ch]: Inline only use of another macro
[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
f832b29a 292struct TM *Perl_gmtime64_r (const Time64_T *in_time, struct TM *p)
a272e669
MS
293{
294 int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
b86b480f 295 Time64_T v_tm_tday;
a272e669 296 int leap;
b86b480f 297 Time64_T m;
a272e669 298 Time64_T time = *in_time;
750c447b 299 Year year = 70;
315d3362 300 dTHX;
a272e669 301
948ea7a9
MS
302 assert(p != NULL);
303
a64acb40
MS
304 /* Use the system gmtime() if time_t is small enough */
305 if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
cd1759d8 306 time_t safe_time = (time_t)*in_time;
806a119a 307 struct tm safe_date;
315d3362
KW
308 struct tm * result;
309
310 /* reentr.h will automatically replace this with a call to gmtime_r()
311 * when appropriate */
312 result = gmtime(&safe_time);
313
314 assert(result != NULL);
315
316#if defined(HAS_GMTIME_R) && defined(USE_REENTRANT_API)
317
318 PERL_UNUSED_VAR(safe_date);
319#else
320 /* Here, no gmtime_r() and is a threaded perl where the result can be
321 * overwritten by a call in another thread. Copy to a safe place,
322 * hopefully before another gmtime can jump in and trash this
323 * result. */
324 memcpy(&safe_date, result, sizeof(safe_date));
325 result = &safe_date;
326#endif
806a119a 327
315d3362 328 S_copy_little_tm_to_big_TM(result, p);
7430375d 329 assert(S_check_tm(p));
806a119a 330
a64acb40
MS
331 return p;
332 }
333
9af24521 334#ifdef HAS_TM_TM_GMTOFF
a272e669
MS
335 p->tm_gmtoff = 0;
336#endif
337 p->tm_isdst = 0;
338
9af24521 339#ifdef HAS_TM_TM_ZONE
1cefca6b 340 p->tm_zone = (char *)"UTC";
a272e669
MS
341#endif
342
42033175
JH
343 v_tm_sec = (int)Perl_fmod(time, 60.0);
344 time = time >= 0 ? Perl_floor(time / 60.0) : Perl_ceil(time / 60.0);
345 v_tm_min = (int)Perl_fmod(time, 60.0);
346 time = time >= 0 ? Perl_floor(time / 60.0) : Perl_ceil(time / 60.0);
347 v_tm_hour = (int)Perl_fmod(time, 24.0);
348 time = time >= 0 ? Perl_floor(time / 24.0) : Perl_ceil(time / 24.0);
455f2c6c 349 v_tm_tday = time;
750c447b 350
a272e669
MS
351 WRAP (v_tm_sec, v_tm_min, 60);
352 WRAP (v_tm_min, v_tm_hour, 60);
353 WRAP (v_tm_hour, v_tm_tday, 24);
750c447b 354
42033175 355 v_tm_wday = (int)Perl_fmod((v_tm_tday + 4.0), 7.0);
750c447b 356 if (v_tm_wday < 0)
a272e669
MS
357 v_tm_wday += 7;
358 m = v_tm_tday;
a272e669 359
9af24521
MS
360 if (m >= CHEAT_DAYS) {
361 year = CHEAT_YEARS;
362 m -= CHEAT_DAYS;
363 }
364
365 if (m >= 0) {
a272e669 366 /* Gregorian cycles, this is huge optimization for distant times */
c75442a5 367 const int cycles = (int)Perl_floor(m / (Time64_T) days_in_gregorian_cycle);
806a119a
MS
368 if( cycles ) {
369 m -= (cycles * (Time64_T) days_in_gregorian_cycle);
370 year += (cycles * years_in_gregorian_cycle);
a272e669
MS
371 }
372
373 /* Years */
374 leap = IS_LEAP (year);
375 while (m >= (Time64_T) length_of_year[leap]) {
376 m -= (Time64_T) length_of_year[leap];
377 year++;
378 leap = IS_LEAP (year);
379 }
380
381 /* Months */
382 v_tm_mon = 0;
383 while (m >= (Time64_T) days_in_month[leap][v_tm_mon]) {
384 m -= (Time64_T) days_in_month[leap][v_tm_mon];
385 v_tm_mon++;
386 }
387 } else {
c75442a5
AL
388 int cycles;
389
9af24521 390 year--;
a272e669
MS
391
392 /* Gregorian cycles */
42033175 393 cycles = (int)Perl_ceil((m / (Time64_T) days_in_gregorian_cycle) + 1);
806a119a
MS
394 if( cycles ) {
395 m -= (cycles * (Time64_T) days_in_gregorian_cycle);
396 year += (cycles * years_in_gregorian_cycle);
a272e669
MS
397 }
398
399 /* Years */
400 leap = IS_LEAP (year);
401 while (m < (Time64_T) -length_of_year[leap]) {
402 m += (Time64_T) length_of_year[leap];
403 year--;
404 leap = IS_LEAP (year);
405 }
406
407 /* Months */
408 v_tm_mon = 11;
409 while (m < (Time64_T) -days_in_month[leap][v_tm_mon]) {
410 m += (Time64_T) days_in_month[leap][v_tm_mon];
411 v_tm_mon--;
412 }
413 m += (Time64_T) days_in_month[leap][v_tm_mon];
414 }
415
416 p->tm_year = year;
417 if( p->tm_year != year ) {
9af24521 418#ifdef EOVERFLOW
a272e669 419 errno = EOVERFLOW;
9af24521 420#endif
a272e669
MS
421 return NULL;
422 }
423
b86b480f 424 /* At this point m is less than a year so casting to an int is safe */
a272e669 425 p->tm_mday = (int) m + 1;
b86b480f
MS
426 p->tm_yday = julian_days_by_month[leap][v_tm_mon] + (int)m;
427 p->tm_sec = v_tm_sec;
428 p->tm_min = v_tm_min;
429 p->tm_hour = v_tm_hour;
430 p->tm_mon = v_tm_mon;
431 p->tm_wday = v_tm_wday;
a272e669 432
7430375d 433 assert(S_check_tm(p));
a272e669
MS
434
435 return p;
436}
437
438
f832b29a 439struct TM *Perl_localtime64_r (const Time64_T *time, struct TM *local_tm)
a272e669
MS
440{
441 time_t safe_time;
806a119a 442 struct tm safe_date;
4684bf2c 443 const struct tm * result;
806a119a 444 struct TM gm_tm;
750c447b 445 Year orig_year;
a272e669 446 int month_diff;
6358af17 447 const bool use_system = SHOULD_USE_SYSTEM_LOCALTIME(*time);
4684bf2c 448 dTHX;
a272e669 449
948ea7a9
MS
450 assert(local_tm != NULL);
451
a64acb40 452 /* Use the system localtime() if time_t is small enough */
6358af17 453 if (use_system) {
cd1759d8 454 safe_time = (time_t)*time;
806a119a 455
7430375d 456 TIME64_TRACE1("Using system localtime for %lld\n", *time);
a64acb40 457 }
0bd9a4dd 458 else {
9b5e0ded
KW
459 if (Perl_gmtime64_r(time, &gm_tm) == NULL) {
460 TIME64_TRACE1("gmtime64_r returned null for %lld\n", *time);
461 return NULL;
462 }
af832814 463
9b5e0ded 464 orig_year = gm_tm.tm_year;
a272e669 465
9b5e0ded
KW
466 if (gm_tm.tm_year > (2037 - 1900) ||
467 gm_tm.tm_year < (1970 - 1900)
468 )
469 {
470 TIME64_TRACE1("Mapping tm_year %lld to safe_year\n",
471 (Year)gm_tm.tm_year);
472 gm_tm.tm_year = S_safe_year((Year)(gm_tm.tm_year + 1900)) - 1900;
473 }
a272e669 474
9b5e0ded 475 safe_time = (time_t)S_timegm64(&gm_tm);
0bd9a4dd
KW
476 }
477
4684bf2c
KW
478 /* reentr.h will automatically replace this with a call to localtime_r()
479 * when appropriate */
480 result = localtime(&safe_time);
481
482 if( result == NULL ) {
483 TIME64_TRACE1("localtime(%d) returned NULL\n", (int)safe_time);
af832814 484 return NULL;
461d5a49 485 }
a272e669 486
4684bf2c
KW
487#if ! defined(USE_REENTRANT_API) || defined(PERL_REENTR_USING_LOCALTIME_R)
488
489 PERL_UNUSED_VAR(safe_date);
490
491#else
492
493 /* Here, would be using localtime_r() if it could, meaning there isn't one,
494 * and is a threaded perl where the result can be overwritten by a call in
495 * another thread. Copy to a safe place, hopefully before another
496 * localtime can jump in and trash this result. */
497 memcpy(&safe_date, result, sizeof(safe_date));
498 result = &safe_date;
499
500#endif
501
502 S_copy_little_tm_to_big_TM(result, local_tm);
806a119a 503
0bd9a4dd
KW
504 if (! use_system) {
505
9b5e0ded
KW
506 local_tm->tm_year = orig_year;
507 if( local_tm->tm_year != orig_year ) {
508 TIME64_TRACE2("tm_year overflow: tm_year %lld, orig_year %lld\n",
509 (Year)local_tm->tm_year, (Year)orig_year);
461d5a49 510
af832814 511#ifdef EOVERFLOW
9b5e0ded 512 errno = EOVERFLOW;
af832814 513#endif
9b5e0ded
KW
514 return NULL;
515 }
af832814 516
9b5e0ded 517 month_diff = local_tm->tm_mon - gm_tm.tm_mon;
a272e669 518
9b5e0ded
KW
519 /* When localtime is Dec 31st previous year and
520 gmtime is Jan 1st next year.
521 */
522 if( month_diff == 11 ) {
523 local_tm->tm_year--;
524 }
a272e669 525
9b5e0ded
KW
526 /* When localtime is Jan 1st, next year and
527 gmtime is Dec 31st, previous year.
528 */
529 if( month_diff == -11 ) {
530 local_tm->tm_year++;
531 }
a272e669 532
9b5e0ded
KW
533 /* GMT is Jan 1st, xx01 year, but localtime is still Dec 31st
534 in a non-leap xx00. There is one point in the cycle
535 we can't account for which the safe xx00 year is a leap
536 year. So we need to correct for Dec 31st coming out as
537 the 366th day of the year.
538 */
539 if( !IS_LEAP(local_tm->tm_year) && local_tm->tm_yday == 365 )
540 local_tm->tm_yday--;
a272e669 541
0bd9a4dd
KW
542 }
543
7430375d 544 assert(S_check_tm(local_tm));
a272e669
MS
545
546 return local_tm;
547}