This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Fix gmtime() and localtime() so they can pop times larger than 2**55 off the stack...
[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
36localtime64_r() is a 64-bit equivalent of localtime_r().
37
38gmtime64_r() is a 64-bit equivalent of gmtime_r().
39
40*/
41
7643e68f 42#include "time64.h"
af9b2bf5 43
a272e669
MS
44static 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
49static 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
54static const int length_of_year[2] = { 365, 366 };
55
56/* Number of days in a 400 year Gregorian cycle */
806a119a 57static const Year years_in_gregorian_cycle = 400;
a272e669
MS
58static const int days_in_gregorian_cycle = (365 * 400) + 100 - 4 + 1;
59
60/* 28 year calendar cycle between 2010 and 2037 */
806a119a
MS
61#define SOLAR_CYCLE_LENGTH 28
62static const int safe_years[SOLAR_CYCLE_LENGTH] = {
a272e669
MS
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
ea722b76 72static const int dow_year_start[SOLAR_CYCLE_LENGTH] = {
003c3b95
MS
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 */
a272e669
MS
80};
81
9af24521
MS
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
a272e669
MS
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
7bda3dfc
MS
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)
a64acb40
MS
103
104
806a119a 105static int is_exception_century(Int64 year)
a272e669
MS
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
9af24521 113
806a119a 114Time64_T timegm64(struct TM *date) {
ea722b76
MS
115 int days = 0;
116 Int64 seconds = 0;
117 Int64 year;
a272e669 118
9af24521
MS
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++;
a272e669
MS
124 }
125 }
9af24521
MS
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
ea722b76
MS
137 /* Avoid overflowing the days integer */
138 seconds = days;
139 seconds = seconds * 60 * 60 * 24;
140
9af24521
MS
141 seconds += date->tm_hour * 60 * 60;
142 seconds += date->tm_min * 60;
143 seconds += date->tm_sec;
144
ea722b76 145 return((Time64_T)seconds);
9af24521
MS
146}
147
148
806a119a 149static int check_tm(struct TM *tm)
9af24521 150{
9af24521 151 /* Don't forget leap seconds */
af9b2bf5 152 assert(tm->tm_sec >= 0);
9af24521
MS
153 assert(tm->tm_sec <= 61);
154
af9b2bf5 155 assert(tm->tm_min >= 0);
9af24521
MS
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);
af9b2bf5 162 assert(tm->tm_mday <= days_in_month[IS_LEAP(tm->tm_year)][tm->tm_mon]);
9af24521
MS
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);
af9b2bf5 171 assert(tm->tm_yday <= length_of_year[IS_LEAP(tm->tm_year)]);
9af24521
MS
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
af9b2bf5
MS
177
178 return 1;
a272e669 179}
a64acb40 180
a272e669
MS
181
182/* The exceptional centuries without leap years cause the cycle to
183 shift by 16
184*/
806a119a 185static Year cycle_offset(Year year)
a272e669 186{
750c447b
MS
187 const Year start_year = 2000;
188 Year year_diff = year - start_year;
189 Year exceptions;
003c3b95
MS
190
191 if( year > start_year )
192 year_diff--;
193
750c447b
MS
194 exceptions = year_diff / 100;
195 exceptions -= year_diff / 400;
a272e669 196
003c3b95
MS
197 /*
198 fprintf(stderr, "# year: %lld, exceptions: %lld, year_diff: %lld\n",
199 year, exceptions, year_diff);
200 */
a272e669
MS
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.
ea722b76
MS
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.
003c3b95
MS
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.
a272e669 221*/
806a119a 222static int safe_year(Year year)
a272e669
MS
223{
224 int safe_year;
806a119a 225 Year year_cycle = year + cycle_offset(year);
a272e669
MS
226
227 /* Change non-leap xx00 years to an equivalent */
806a119a 228 if( is_exception_century(year) )
a272e669
MS
229 year_cycle += 11;
230
003c3b95 231 /* Also xx01 years, since the previous year will be wrong */
806a119a 232 if( is_exception_century(year - 1) )
003c3b95
MS
233 year_cycle += 17;
234
a272e669 235 year_cycle %= SOLAR_CYCLE_LENGTH;
ea722b76
MS
236 if( year_cycle < 0 )
237 year_cycle = SOLAR_CYCLE_LENGTH + year_cycle;
a272e669 238
003c3b95
MS
239 assert( year_cycle >= 0 );
240 assert( year_cycle < SOLAR_CYCLE_LENGTH );
a272e669
MS
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
750c447b 253
806a119a
MS
254void 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
286void 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
948ea7a9
MS
318/* Simulate localtime_r() to the best of our ability */
319struct 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 */
336struct 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
806a119a 352struct TM *gmtime64_r (const Time64_T *in_time, struct TM *p)
a272e669
MS
353{
354 int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
9af24521 355 Int64 v_tm_tday;
a272e669 356 int leap;
9af24521 357 Int64 m;
a272e669 358 Time64_T time = *in_time;
750c447b 359 Year year = 70;
806a119a 360 int cycles = 0;
a272e669 361
948ea7a9
MS
362 assert(p != NULL);
363
a64acb40
MS
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;
806a119a
MS
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
a64acb40
MS
373 return p;
374 }
375
9af24521 376#ifdef HAS_TM_TM_GMTOFF
a272e669
MS
377 p->tm_gmtoff = 0;
378#endif
379 p->tm_isdst = 0;
380
9af24521 381#ifdef HAS_TM_TM_ZONE
a272e669
MS
382 p->tm_zone = "UTC";
383#endif
384
750c447b 385 v_tm_sec = (int)(time % 60);
a272e669 386 time /= 60;
750c447b 387 v_tm_min = (int)(time % 60);
a272e669 388 time /= 60;
750c447b 389 v_tm_hour = (int)(time % 24);
a272e669
MS
390 time /= 24;
391 v_tm_tday = time;
750c447b 392
a272e669
MS
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);
750c447b
MS
396
397 v_tm_wday = (int)((v_tm_tday + 4) % 7);
398 if (v_tm_wday < 0)
a272e669
MS
399 v_tm_wday += 7;
400 m = v_tm_tday;
a272e669 401
9af24521
MS
402 if (m >= CHEAT_DAYS) {
403 year = CHEAT_YEARS;
404 m -= CHEAT_DAYS;
405 }
406
407 if (m >= 0) {
a272e669 408 /* Gregorian cycles, this is huge optimization for distant times */
806a119a
MS
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);
a272e669
MS
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 {
9af24521 430 year--;
a272e669
MS
431
432 /* Gregorian cycles */
806a119a
MS
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);
a272e669
MS
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 ) {
9af24521 458#ifdef EOVERFLOW
a272e669 459 errno = EOVERFLOW;
9af24521 460#endif
a272e669
MS
461 return NULL;
462 }
463
464 p->tm_mday = (int) m + 1;
750c447b 465 p->tm_yday = (int) julian_days_by_month[leap][v_tm_mon] + m;
a272e669
MS
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
806a119a 469 assert(check_tm(p));
a272e669
MS
470
471 return p;
472}
473
474
806a119a 475struct TM *localtime64_r (const Time64_T *time, struct TM *local_tm)
a272e669
MS
476{
477 time_t safe_time;
806a119a
MS
478 struct tm safe_date;
479 struct TM gm_tm;
750c447b 480 Year orig_year;
a272e669
MS
481 int month_diff;
482
948ea7a9
MS
483 assert(local_tm != NULL);
484
a64acb40
MS
485 /* Use the system localtime() if time_t is small enough */
486 if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
487 safe_time = *time;
806a119a
MS
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
a64acb40
MS
494 return local_tm;
495 }
496
af832814
MS
497 if( gmtime64_r(time, &gm_tm) == NULL )
498 return NULL;
499
a272e669
MS
500 orig_year = gm_tm.tm_year;
501
c07fe26c
MS
502 if (gm_tm.tm_year > (2037 - 1900) ||
503 gm_tm.tm_year < (1902 - 1900)
504 )
505 {
806a119a 506 gm_tm.tm_year = safe_year(gm_tm.tm_year + 1900) - 1900;
c07fe26c 507 }
a272e669 508
806a119a
MS
509 safe_time = timegm64(&gm_tm);
510 if( LOCALTIME_R(&safe_time, &safe_date) == NULL )
af832814 511 return NULL;
a272e669 512
806a119a
MS
513 copy_tm_to_TM(&safe_date, local_tm);
514
a272e669 515 local_tm->tm_year = orig_year;
af832814
MS
516 if( local_tm->tm_year != orig_year ) {
517#ifdef EOVERFLOW
518 errno = EOVERFLOW;
519#endif
520 return NULL;
521 }
522
523
a272e669
MS
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
806a119a 549 assert(check_tm(local_tm));
a272e669
MS
550
551 return local_tm;
552}