[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original]
[PATCH] 2038 fix
Attached is a patch to fix the 2038 bug in Perl. It's pretty good. There's
one obvious nit that needs more-expert-than-me attention.
* As noted by the #include "localtime64.c" in pp_sys.c, some sort of build foo
has to be done to make things aware of that file. I don't know how to do
that.
I also eliminated the use of *S_my_localtime for the LOCALTIME_EDGECASE_BROKEN
special case because, well, it got in the way. What's the deal with that?
I'm sure there's a few portability nits. There's also a large pile of
optimizations planned (gmtime 2**56 takes a full minute). Currently it runs
about 50% slower on OS X for small times.
PS The underlying 64 bit time.h code is being developed independently here:
http://code.google.com/p/y2038/
there's lots of room for improvement and I'm a crappy C programmer.
--
94. Crucifixes do not ward off officers, and I should not test that.
-- The 213 Things Skippy Is No Longer Allowed To Do In The U.S. Army
http://skippyslist.com/list/
--- bleadperl/pp_sys.c 2008-06-28 14:11:23.000000000 -0700
+++ bleadperl.mv/pp_sys.c 2008-09-10 23:36:11.000000000 -0700
@@ -27,6 +27,8 @@
#include "EXTERN.h"
#define PERL_IN_PP_SYS_C
#include "perl.h"
+#include "localtime64.h"
+#include "localtime64.c"
#ifdef I_SHADOW
/* Shadow password support for solaris - pdo@cs.umd.edu
@@ -4446,60 +4448,60 @@
{
dVAR;
dSP;
- Time_t when;
- const struct tm *tmbuf;
+ Time64_T when;
+ struct tm tmbuf;
+ struct tm *err;
static const char * const dayname[] =
{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
static const char * const monname[] =
{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
- if (MAXARG < 1)
- (void)time(&when);
+ if (MAXARG < 1) {
+ time_t now;
+ (void)time(&now);
+ when = (Time64_T)now;
+ }
else
-#ifdef BIG_TIME
- when = (Time_t)SvNVx(POPs);
-#else
- when = (Time_t)SvIVx(POPs);
-#endif
+ when = (Time64_T)SvNVx(POPs);
if (PL_op->op_type == OP_LOCALTIME)
-#ifdef LOCALTIME_EDGECASE_BROKEN
- tmbuf = S_my_localtime(aTHX_ &when);
-#else
- tmbuf = localtime(&when);
-#endif
+ err = localtime64_r(&when, &tmbuf);
else
- tmbuf = gmtime(&when);
+ err = gmtime64_r(&when, &tmbuf);
+
+ if( (tmbuf.tm_year + 1900) < 0 )
+ Perl_warner(aTHX_ packWARN(WARN_OVERFLOW),
+ "local/gmtime under/overflowed the year");
if (GIMME != G_ARRAY) {
SV *tsv;
EXTEND(SP, 1);
EXTEND_MORTAL(1);
- if (!tmbuf)
+ if (err == NULL)
RETPUSHUNDEF;
tsv = Perl_newSVpvf(aTHX_ "%s %s %2d %02d:%02d:%02d %d",
- dayname[tmbuf->tm_wday],
- monname[tmbuf->tm_mon],
- tmbuf->tm_mday,
- tmbuf->tm_hour,
- tmbuf->tm_min,
- tmbuf->tm_sec,
- tmbuf->tm_year + 1900);
+ dayname[tmbuf.tm_wday],
+ monname[tmbuf.tm_mon],
+ tmbuf.tm_mday,
+ tmbuf.tm_hour,
+ tmbuf.tm_min,
+ tmbuf.tm_sec,
+ tmbuf.tm_year + 1900);
mPUSHs(tsv);
}
- else if (tmbuf) {
+ else if (err != NULL) {
EXTEND(SP, 9);
EXTEND_MORTAL(9);
- mPUSHi(tmbuf->tm_sec);
- mPUSHi(tmbuf->tm_min);
- mPUSHi(tmbuf->tm_hour);
- mPUSHi(tmbuf->tm_mday);
- mPUSHi(tmbuf->tm_mon);
- mPUSHi(tmbuf->tm_year);
- mPUSHi(tmbuf->tm_wday);
- mPUSHi(tmbuf->tm_yday);
- mPUSHi(tmbuf->tm_isdst);
+ mPUSHi(tmbuf.tm_sec);
+ mPUSHi(tmbuf.tm_min);
+ mPUSHi(tmbuf.tm_hour);
+ mPUSHi(tmbuf.tm_mday);
+ mPUSHi(tmbuf.tm_mon);
+ mPUSHi(tmbuf.tm_year);
+ mPUSHi(tmbuf.tm_wday);
+ mPUSHi(tmbuf.tm_yday);
+ mPUSHi(tmbuf.tm_isdst);
}
RETURN;
}
--- /dev/null 2008-09-11 00:01:41.000000000 -0700
+++ bleadperl.mv/localtime64.c 2008-09-10 23:35:51.000000000 -0700
@@ -0,0 +1,238 @@
+/* localtime64.c */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+static const int days_in_month[2][12] = {
+ {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+ {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+};
+
+static const int julian_days_by_month[2][12] = {
+ {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
+ {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335},
+};
+
+static const int length_of_year[2] = { 365, 366 };
+
+/* 28 year calendar cycle between 2010 and 2037 */
+static const int safe_years[28] = {
+ 2016, 2017, 2018, 2019,
+ 2020, 2021, 2022, 2023,
+ 2024, 2025, 2026, 2027,
+ 2028, 2029, 2030, 2031,
+ 2032, 2033, 2034, 2035,
+ 2036, 2037, 2010, 2011,
+ 2012, 2013, 2014, 2015
+};
+
+static const int dow_year_start[28] = {
+ 5, 0, 1, 2, /* 2016 - 2019 */
+ 3, 5, 6, 0,
+ 1, 3, 4, 5,
+ 6, 1, 2, 3,
+ 4, 6, 0, 1,
+ 2, 4, 5, 6, /* 2036, 2037, 2010, 2011 */
+ 0, 2, 3, 4 /* 2012, 2013, 2014, 2015 */
+};
+
+
+#define IS_LEAP(n) ((!(((n) + 1900) % 400) || (!(((n) + 1900) % 4) && (((n) + 1900) % 100))) != 0)
+#define WRAP(a,b,m) ((a) = ((a) < 0 ) ? ((b)--, (a) + (m)) : (a))
+
+int _is_exception_century(long year)
+{
+ int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
+ /* printf("is_exception_century: %s\n", is_exception ? "yes" : "no"); */
+
+ return(is_exception);
+}
+
+void _check_tm(struct tm *tm)
+{
+ /* Don't forget leap seconds */
+ assert(tm->tm_sec >= 0 && tm->tm_sec <= 61);
+ assert(tm->tm_min >= 0 && tm->tm_min <= 59);
+ assert(tm->tm_hour >= 0 && tm->tm_hour <= 23);
+ assert(tm->tm_mday >= 1 && tm->tm_mday <= 31);
+ assert(tm->tm_mon >= 0 && tm->tm_mon <= 11);
+ assert(tm->tm_wday >= 0 && tm->tm_wday <= 6);
+ assert(tm->tm_yday >= 0 && tm->tm_yday <= 365);
+
+#ifdef TM_HAS_GMTOFF
+ assert( tm->tm_gmtoff >= -24 * 60 * 60
+ && tm->tm_gmtoff <= 24 * 60 * 60);
+#endif
+
+ if( !IS_LEAP(tm->tm_year) ) {
+ /* no more than 365 days in a non_leap year */
+ assert( tm->tm_yday <= 364 );
+
+ /* and no more than 28 days in Feb */
+ if( tm->tm_mon == 1 ) {
+ assert( tm->tm_mday <= 28 );
+ }
+ }
+}
+
+/* The exceptional centuries without leap years cause the cycle to
+ shift by 16
+*/
+int _cycle_offset(long year)
+{
+ const long start_year = 2000;
+ long year_diff = year - start_year - 1;
+ long exceptions = year_diff / 100;
+ exceptions -= year_diff / 400;
+
+ assert( year >= 2001 );
+
+ /* printf("year: %d, exceptions: %d\n", year, exceptions); */
+
+ return exceptions * 16;
+}
+
+/* For a given year after 2038, pick the latest possible matching
+ year in the 28 year calendar cycle.
+*/
+#define SOLAR_CYCLE_LENGTH 28
+int _safe_year(long year)
+{
+ int safe_year;
+ long year_cycle = year + _cycle_offset(year);
+
+ /* Change non-leap xx00 years to an equivalent */
+ if( _is_exception_century(year) )
+ year_cycle += 11;
+
+ year_cycle %= SOLAR_CYCLE_LENGTH;
+
+ safe_year = safe_years[year_cycle];
+
+ assert(safe_year <= 2037 && safe_year >= 2010);
+
+ /*
+ printf("year: %d, year_cycle: %d, safe_year: %d\n",
+ year, year_cycle, safe_year);
+ */
+
+ return safe_year;
+}
+
+struct tm *gmtime64_r (const Time64_T *in_time, struct tm *p)
+{
+ int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
+ Time64_T v_tm_tday;
+ int leap;
+ Time64_T m;
+ Time64_T time = *in_time;
+
+#ifdef TM_HAS_GMTOFF
+ p->tm_gmtoff = 0;
+#endif
+ p->tm_isdst = 0;
+
+#ifdef TM_HAS_ZONE
+ p->tm_zone = "UTC";
+#endif
+
+ v_tm_sec = time % 60;
+ time /= 60;
+ v_tm_min = time % 60;
+ time /= 60;
+ v_tm_hour = time % 24;
+ time /= 24;
+ v_tm_tday = time;
+ WRAP (v_tm_sec, v_tm_min, 60);
+ WRAP (v_tm_min, v_tm_hour, 60);
+ WRAP (v_tm_hour, v_tm_tday, 24);
+ if ((v_tm_wday = (v_tm_tday + 4) % 7) < 0)
+ v_tm_wday += 7;
+ m = v_tm_tday;
+ if (m >= 0) {
+ p->tm_year = 70;
+ leap = IS_LEAP (p->tm_year);
+ while (m >= (Time64_T) length_of_year[leap]) {
+ m -= (Time64_T) length_of_year[leap];
+ p->tm_year++;
+ leap = IS_LEAP (p->tm_year);
+ }
+ v_tm_mon = 0;
+ while (m >= (Time64_T) days_in_month[leap][v_tm_mon]) {
+ m -= (Time64_T) days_in_month[leap][v_tm_mon];
+ v_tm_mon++;
+ }
+ } else {
+ p->tm_year = 69;
+ leap = IS_LEAP (p->tm_year);
+ while (m < (Time64_T) -length_of_year[leap]) {
+ m += (Time64_T) length_of_year[leap];
+ p->tm_year--;
+ leap = IS_LEAP (p->tm_year);
+ }
+ v_tm_mon = 11;
+ while (m < (Time64_T) -days_in_month[leap][v_tm_mon]) {
+ m += (Time64_T) days_in_month[leap][v_tm_mon];
+ v_tm_mon--;
+ }
+ m += (Time64_T) days_in_month[leap][v_tm_mon];
+ }
+ p->tm_mday = (int) m + 1;
+ p->tm_yday = julian_days_by_month[leap][v_tm_mon] + m;
+ p->tm_sec = v_tm_sec, p->tm_min = v_tm_min, p->tm_hour = v_tm_hour,
+ p->tm_mon = v_tm_mon, p->tm_wday = v_tm_wday;
+
+ _check_tm(p);
+
+ return p;
+}
+
+
+struct tm *localtime64_r (const Time64_T *time, struct tm *local_tm)
+{
+ time_t safe_time;
+ struct tm gm_tm;
+ long orig_year;
+ int month_diff;
+
+ gmtime64_r(time, &gm_tm);
+ orig_year = gm_tm.tm_year;
+
+ if (gm_tm.tm_year > (2037 - 1900))
+ gm_tm.tm_year = _safe_year(gm_tm.tm_year + 1900) - 1900;
+
+ safe_time = timegm(&gm_tm);
+ localtime_r(&safe_time, local_tm);
+
+ local_tm->tm_year = orig_year;
+ month_diff = local_tm->tm_mon - gm_tm.tm_mon;
+
+ /* When localtime is Dec 31st previous year and
+ gmtime is Jan 1st next year.
+ */
+ if( month_diff == 11 ) {
+ local_tm->tm_year--;
+ }
+
+ /* When localtime is Jan 1st, next year and
+ gmtime is Dec 31st, previous year.
+ */
+ if( month_diff == -11 ) {
+ local_tm->tm_year++;
+ }
+
+ /* GMT is Jan 1st, xx01 year, but localtime is still Dec 31st
+ in a non-leap xx00. There is one point in the cycle
+ we can't account for which the safe xx00 year is a leap
+ year. So we need to correct for Dec 31st comming out as
+ the 366th day of the year.
+ */
+ if( !IS_LEAP(local_tm->tm_year) && local_tm->tm_yday == 365 )
+ local_tm->tm_yday--;
+
+ _check_tm(local_tm);
+
+ return local_tm;
+}
--- /dev/null 2008-09-11 00:01:41.000000000 -0700
+++ bleadperl.mv/localtime64.h 2008-09-10 21:56:11.000000000 -0700
@@ -0,0 +1,11 @@
+#include <time.h>
+
+#ifndef LOCALTIME64_H
+# define LOCALTIME64_H
+
+typedef Quad_t Time64_T;
+
+struct tm *gmtime64_r (const Time64_T *, struct tm *);
+struct tm *localtime64_r (const Time64_T *, struct tm *);
+
+#endif
--- bleadperl/t/op/time.t 2007-01-07 16:18:22.000000000 -0800
+++ bleadperl.mv/t/op/time.t 2008-09-10 23:57:44.000000000 -0700
@@ -1,14 +1,12 @@
#!./perl
-$does_gmtime = gmtime(time);
-
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
require './test.pl';
}
-plan tests => 8;
+plan tests => 32;
($beguser,$begsys) = times;
@@ -32,7 +30,9 @@
($xsec,$foo) = localtime($now);
$localyday = $yday;
-ok($sec != $xsec && $mday && $year, 'localtime() list context');
+isnt($sec, $xsec), 'localtime() list context';
+ok $mday, ' month day';
+ok $year, ' year';
ok(localtime() =~ /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat)[ ]
(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[ ]
@@ -56,13 +56,13 @@
ok($hour != $hour2, 'changes to $ENV{TZ} respected');
}
-SKIP: {
- skip "No gmtime()", 3 unless $does_gmtime;
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime($beg);
($xsec,$foo) = localtime($now);
-ok($sec != $xsec && $mday && $year, 'gmtime() list context');
+isnt($sec, $xsec), 'gmtime() list conext';
+ok $mday, ' month day';
+ok $year, ' year';
my $day_diff = $localyday - $yday;
ok( grep({ $day_diff == $_ } (0, 1, -1, 364, 365, -364, -365)),
@@ -76,4 +76,49 @@
/x,
'gmtime(), scalar context'
);
+
+
+
+# Test gmtime over a range of times.
+{
+ # gm/localtime is limited by the size of tm_year which might be as small as 16 bits
+ my %tests = (
+ # time_t gmtime list scalar
+ -2**35 => [52, 13, 20, 7, 2, -1019, 5, 65, 0, "Fri Mar 7 20:13:52 881"],
+ -2**32 => [44, 31, 17, 24, 10, -67, 0, 327, 0, "Sun Nov 24 17:31:44 1833"],
+ -2**31 => [52, 45, 20, 13, 11, 1, 5, 346, 0, "Fri Dec 13 20:45:52 1901"],
+ 0 => [0, 0, 0, 1, 0, 70, 4, 0, 0, "Thu Jan 1 00:00:00 1970"],
+ 2**30 => [4, 37, 13, 10, 0, 104, 6, 9, 0, "Sat Jan 10 13:37:04 2004"],
+ 2**31 => [8, 14, 3, 19, 0, 138, 2, 18, 0, "Tue Jan 19 03:14:08 2038"],
+ 2**32 => [16, 28, 6, 7, 1, 206, 0, 37, 0, "Sun Feb 7 06:28:16 2106"],
+ 2**39 => [8, 18, 12, 25, 0, 17491, 2, 24, 0, "Tue Jan 25 12:18:08 19391"],
+ );
+
+ for my $time (keys %tests) {
+ my @expected = @{$tests{$time}};
+ my $scalar = pop @expected;
+
+ ok eq_array([gmtime($time)], \@expected), "gmtime($time) list context";
+ is scalar gmtime($time), $scalar, " scalar";
+ }
+}
+
+
+# Test localtime
+{
+ # We pick times which fall in the middle of a month, so the month and year should be
+ # the same regardless of the time zone.
+ my %tests = (
+ # time_t month, year, scalar
+ 5000000000 => [5, 228, qr/Jun \d+ .* 2128$/],
+ 1163500000 => [10, 106, qr/Nov \d+ .* 2006$/],
+ );
+
+ for my $time (keys %tests) {
+ my @expected = @{$tests{$time}};
+ my $scalar = pop @expected;
+
+ ok eq_array([(localtime($time))[4,5]], \@expected), "localtime($time) list context";
+ like scalar localtime($time), $scalar, " scalar";
+ }
}
- Follow-Ups from:
-
Michael G Schwern <schwern@pobox.com>
[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original]