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