[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original]
[PATCH] 2038 fix
Attached is the latest 2038 patch from the y2038 branch.
* Configure now probes for the safe range of the system's
localtime() and gmtime(). Perl will use the system
functions inside their safe range. [Thanks Merijn]
* Perl now ships with its own 64 bit gmtime() and timegm().
* localtime() is made 2038 safe on 32 bit systems using the algorithm
described here
http://code.google.com/p/y2038/wiki/HowItWorks
* Time::Local can now handle past 2038.
* Time::gmtime tests improved and expanded past 2038 and 1901.
* Time::localtime tests improved and expanded past 2038.
Open issues
* localtime64.h and .c need to be wired into the Makefile.
I don't now how to do this.
* The LOCALTIME_EDGECASE_BROKEN special case needs to be
reincorporated.
* This has not been tested on a system with an unsigned or floating point
time_t.
* The configure probes are probably broken with a floating point time_t.
Other notes
* The clever way Time::Local handles the year (8, 108 and 2008 are all 2008)
means there are gaps in what years you can run through timelocal() and
timegm().
* Since localtime64.c now has its own timegm() core time modules could
make use of it.
I've hit the limit of what I can do alone. I'd like to see this incorporated
into the bleadperl trunk so it can get some cross-platform testing.
--
s7ank: i want to be one of those guys that types "s/j&jd//.^$ueu*///djsls/sm."
and it's a perl script that turns dog crap into gold.
diff --git a/.gitignore b/.gitignore
index 40e7eb2..9d7069b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,6 +24,7 @@
# general build products
*.o
*.a
+*.old
# ?
ext.libs
diff --git a/lib/Time/Local.pm b/lib/Time/Local.pm
index 4044cd9..e5c4f88 100644
--- a/lib/Time/Local.pm
+++ b/lib/Time/Local.pm
@@ -4,7 +4,6 @@ require Exporter;
use Carp;
use Config;
use strict;
-use integer;
use vars qw( $VERSION @ISA @EXPORT @EXPORT_OK );
$VERSION = '1.18_01';
@@ -29,13 +28,8 @@ use constant SECS_PER_MINUTE => 60;
use constant SECS_PER_HOUR => 3600;
use constant SECS_PER_DAY => 86400;
-my $MaxInt = ( ( 1 << ( 8 * $Config{ivsize} - 2 ) ) - 1 ) * 2 + 1;
-my $MaxDay = int( ( $MaxInt - ( SECS_PER_DAY / 2 ) ) / SECS_PER_DAY ) - 1;
-
-if ( $^O eq 'MacOS' ) {
- # time_t is unsigned...
- $MaxInt = ( 1 << ( 8 * $Config{ivsize} ) ) - 1;
-}
+# localtime()'s limit is the year 2**31
+my $MaxDay = 365 * (2**31);
# Determine the EPOC day for this machine
my $Epoc = 0;
@@ -65,13 +59,13 @@ sub _daygm {
return $_[3] + (
$Cheat{ pack( 'ss', @_[ 4, 5 ] ) } ||= do {
my $month = ( $_[4] + 10 ) % 12;
- my $year = $_[5] + 1900 - $month / 10;
+ my $year = $_[5] + 1900 - int($month / 10);
( ( 365 * $year )
- + ( $year / 4 )
- - ( $year / 100 )
- + ( $year / 400 )
- + ( ( ( $month * 306 ) + 5 ) / 10 )
+ + int( $year / 4 )
+ - int( $year / 100 )
+ + int( $year / 400 )
+ + int( ( ( $month * 306 ) + 5 ) / 10 )
)
- $Epoc;
}
@@ -278,16 +272,6 @@ absolute four digit year instead.
The scheme above allows interpretation of a wide range of dates,
particularly if 4-digit years are used.
-=head2 Limits of time_t
-
-The range of dates that can be actually be handled depends on the size
-of C<time_t> (usually a signed integer) on the given
-platform. Currently, this is 32 bits for most systems, yielding an
-approximate range from Dec 1901 to Jan 2038.
-
-Both C<timelocal()> and C<timegm()> croak if given dates outside the
-supported range.
-
=head2 Ambiguous Local Times (DST)
Because of DST changes, there are many time zones where the same local
@@ -310,17 +294,6 @@ for the "Europe/Paris" time zone, the local clock jumped from
If the C<timelocal()> function is given a non-existent local time, it
will simply return an epoch value for the time one hour later.
-=head2 Negative Epoch Values
-
-Negative epoch (C<time_t>) values are not officially supported by the
-POSIX standards, so this module's tests do not test them. On some
-systems, they are known not to work. These include MacOS (pre-OSX) and
-Win32.
-
-On systems which do support negative epoch values, this module should
-be able to cope with dates before the start of the epoch, down the
-minimum value of time_t for the system.
-
=head1 IMPLEMENTATION
These routines are quite efficient and yet are always guaranteed to
diff --git a/lib/Time/Local.t b/lib/Time/Local.t
index 22138cf..ef32b40 100755
--- a/lib/Time/Local.t
+++ b/lib/Time/Local.t
@@ -25,10 +25,10 @@ my @time =
# leap day
[2020, 2, 29, 12, 59, 59],
[2030, 7, 4, 17, 07, 06],
-# The following test fails on a surprising number of systems
-# so it is commented out. The end of the Epoch for a 32-bit signed
-# implementation of time_t should be Jan 19, 2038 03:14:07 UTC.
-# [2038, 1, 17, 23, 59, 59], # last full day in any tz
+ [2038, 1, 17, 23, 59, 59], # last full day in any tz
+
+ # more than 2**31 time_t
+ [2258, 8, 11, 1, 49, 17],
);
my @bad_time =
@@ -88,7 +88,7 @@ for (@time, @neg_time) {
$year -= 1900;
$mon--;
- SKIP: {
+ SKIP: {
skip '1970 test on VOS fails.', 12
if $^O eq 'vos' && $year == 70;
skip 'this platform does not support negative epochs.', 12
@@ -107,20 +107,21 @@ for (@time, @neg_time) {
is($M, $mon, "timelocal month for @$_");
is($Y, $year, "timelocal year for @$_");
}
+ }
- {
- my $year_in = $year < 70 ? $year + 1900 : $year;
- my $time = timegm($sec,$min,$hour,$mday,$mon,$year_in);
+ # Perl has its own gmtime()
+ {
+ my $year_in = $year < 70 ? $year + 1900 : $year;
+ my $time = timegm($sec,$min,$hour,$mday,$mon,$year_in);
- my($s,$m,$h,$D,$M,$Y) = gmtime($time);
+ my($s,$m,$h,$D,$M,$Y) = gmtime($time);
- is($s, $sec, "timegm second for @$_");
- is($m, $min, "timegm minute for @$_");
- is($h, $hour, "timegm hour for @$_");
- is($D, $mday, "timegm day for @$_");
- is($M, $mon, "timegm month for @$_");
- is($Y, $year, "timegm year for @$_");
- }
+ is($s, $sec, "timegm second for @$_");
+ is($m, $min, "timegm minute for @$_");
+ is($h, $hour, "timegm hour for @$_");
+ is($D, $mday, "timegm day for @$_");
+ is($M, $mon, "timegm month for @$_");
+ is($Y, $year, "timegm year for @$_");
}
}
@@ -166,11 +167,7 @@ for my $p (@years) {
"$year $string a leap year" );
}
-SKIP:
{
- skip 'this platform does not support negative epochs.', 6
- unless $neg_epoch_ok;
-
eval { timegm(0,0,0,29,1,1900) };
like($@, qr/Day '29' out of range 1\.\.28/,
'does not accept leap day in 1900');
diff --git a/lib/Time/gmtime.t b/lib/Time/gmtime.t
index 853ec3b..1ccd7fb 100644
--- a/lib/Time/gmtime.t
+++ b/lib/Time/gmtime.t
@@ -3,55 +3,26 @@
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
-}
-BEGIN {
- our $hasgm;
- eval { my $n = gmtime 0 };
- $hasgm = 1 unless $@ && $@ =~ /unimplemented/;
- unless ($hasgm) { print "1..0 # Skip: no gmtime\n"; exit 0 }
+ require "./test.pl";
}
+my(@times, @methods);
BEGIN {
- our @gmtime = gmtime 0; # This is the function gmtime.
- unless (@gmtime) { print "1..0 # Skip: gmtime failed\n"; exit 0 }
-}
-
-print "1..10\n";
-
-use Time::gmtime;
-
-print "ok 1\n";
-
-my $gmtime = gmtime 0 ; # This is the OO gmtime.
-
-print "not " unless $gmtime->sec == $gmtime[0];
-print "ok 2\n";
-
-print "not " unless $gmtime->min == $gmtime[1];
-print "ok 3\n";
-
-print "not " unless $gmtime->hour == $gmtime[2];
-print "ok 4\n";
-
-print "not " unless $gmtime->mday == $gmtime[3];
-print "ok 5\n";
-
-print "not " unless $gmtime->mon == $gmtime[4];
-print "ok 6\n";
-
-print "not " unless $gmtime->year == $gmtime[5];
-print "ok 7\n";
-
-print "not " unless $gmtime->wday == $gmtime[6];
-print "ok 8\n";
-
-print "not " unless $gmtime->yday == $gmtime[7];
-print "ok 9\n";
-
-print "not " unless $gmtime->isdst == $gmtime[8];
-print "ok 10\n";
+ @times = (-2**33, -2**31-1, 0, 2**31-1, 2**33, time);
+ @methods = qw(sec min hour mday mon year wday yday isdst);
+ plan tests => (@times * @methods) + 1;
+ use_ok Time::gmtime;
+}
+# Perl has its own gmtime() so it's safe to do negative times.
+for my $time (@times) {
+ my $gmtime = gmtime $time; # This is the OO gmtime.
+ my @gmtime = CORE::gmtime $time; # This is the gmtime function
+ for my $method (@methods) {
+ is $gmtime->$method, shift @gmtime, "gmtime($time)->$method";
+ }
+}
diff --git a/lib/Time/localtime.t b/lib/Time/localtime.t
index 357615c..10df765 100644
--- a/lib/Time/localtime.t
+++ b/lib/Time/localtime.t
@@ -3,55 +3,35 @@
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
+
+ require "./test.pl";
}
BEGIN {
- our $haslocal;
+ my $haslocal;
eval { my $n = localtime 0 };
$haslocal = 1 unless $@ && $@ =~ /unimplemented/;
- unless ($haslocal) { print "1..0 # Skip: no localtime\n"; exit 0 }
-}
-BEGIN {
- our @localtime = localtime 0; # This is the function localtime.
- unless (@localtime) { print "1..0 # Skip: localtime failed\n"; exit 0 }
+ skip_all("no localtime") unless $haslocal;
}
-print "1..10\n";
-
-use Time::localtime;
-
-print "ok 1\n";
-
-my $localtime = localtime 0 ; # This is the OO localtime.
-
-print "not " unless $localtime->sec == $localtime[0];
-print "ok 2\n";
-
-print "not " unless $localtime->min == $localtime[1];
-print "ok 3\n";
-
-print "not " unless $localtime->hour == $localtime[2];
-print "ok 4\n";
-
-print "not " unless $localtime->mday == $localtime[3];
-print "ok 5\n";
-
-print "not " unless $localtime->mon == $localtime[4];
-print "ok 6\n";
-
-print "not " unless $localtime->year == $localtime[5];
-print "ok 7\n";
-
-print "not " unless $localtime->wday == $localtime[6];
-print "ok 8\n";
-
-print "not " unless $localtime->yday == $localtime[7];
-print "ok 9\n";
+BEGIN {
+ my @localtime = CORE::localtime 0; # This is the function localtime.
-print "not " unless $localtime->isdst == $localtime[8];
-print "ok 10\n";
+ skip_all("localtime failed") unless @localtime;
+}
+BEGIN { plan tests => 37; }
+BEGIN { use_ok Time::localtime; }
+# Since Perl's localtime() still uses the system localtime, don't try
+# to do negative times. The system might not support it.
+for my $time (0, 2**31-1, 2**33, time) {
+ my $localtime = localtime $time; # This is the OO localtime.
+ my @localtime = CORE::localtime $time; # This is the localtime function
+ for my $method (qw(sec min hour mday mon year wday yday isdst)) {
+ is $localtime->$method, shift @localtime, "localtime($time)->$method";
+ }
+}
diff --git a/localtime64.c b/localtime64.c
new file mode 100644
index 0000000..0c54bc3
--- /dev/null
+++ b/localtime64.c
@@ -0,0 +1,438 @@
+/*
+
+Copyright (c) 2007-2008 Michael G Schwern
+
+This software originally derived from Paul Sheer's pivotal_gmtime_r.c.
+
+The MIT License:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+/*
+
+Programmers who have available to them 64-bit time values as a 'long
+long' type can use localtime64_r() and gmtime64_r() which correctly
+converts the time even on 32-bit systems. Whether you have 64-bit time
+values will depend on the operating system.
+
+localtime64_r() is a 64-bit equivalent of localtime_r().
+
+gmtime64_r() is a 64-bit equivalent of gmtime_r().
+
+*/
+
+#include "localtime64.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 };
+
+/* Number of days in a 400 year Gregorian cycle */
+static const int years_in_gregorian_cycle = 400;
+static const int days_in_gregorian_cycle = (365 * 400) + 100 - 4 + 1;
+
+/* 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
+};
+
+#define SOLAR_CYCLE_LENGTH 28
+static const int dow_year_start[SOLAR_CYCLE_LENGTH] = {
+ 5, 0, 1, 2, /* 0 2016 - 2019 */
+ 3, 5, 6, 0, /* 4 */
+ 1, 3, 4, 5, /* 8 */
+ 6, 1, 2, 3, /* 12 */
+ 4, 6, 0, 1, /* 16 */
+ 2, 4, 5, 6, /* 20 2036, 2037, 2010, 2011 */
+ 0, 2, 3, 4 /* 24 2012, 2013, 2014, 2015 */
+};
+
+/* Let's assume people are going to be looking for dates in the future.
+ Let's provide some cheats so you can skip ahead.
+ This has a 4x speed boost when near 2008.
+*/
+/* Number of days since epoch on Jan 1st, 2008 GMT */
+#define CHEAT_DAYS (1199145600 / 24 / 60 / 60)
+#define CHEAT_YEARS 108
+
+#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))
+
+#define SHOULD_USE_SYSTEM_LOCALTIME(a) ( \
+ USE_SYSTEM_LOCALTIME && \
+ (a) <= SYSTEM_LOCALTIME_MAX && \
+ (a) >= SYSTEM_LOCALTIME_MIN \
+)
+#define SHOULD_USE_SYSTEM_GMTIME(a) ( \
+ USE_SYSTEM_GMTIME && \
+ (a) <= SYSTEM_GMTIME_MAX && \
+ (a) >= SYSTEM_GMTIME_MIN \
+)
+
+
+int _is_exception_century(Int64 year)
+{
+ int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
+ /* printf("is_exception_century: %s\n", is_exception ? "yes" : "no"); */
+
+ return(is_exception);
+}
+
+
+/* timegm() is a GNU extension, so emulate it here if we need it */
+#ifdef HAS_TIMEGM
+# define TIMEGM(n) timegm(n);
+#else
+# define TIMEGM(n) ((time_t)timegm64(n));
+#endif
+
+Time64_T timegm64(struct tm *date) {
+ int days = 0;
+ Int64 seconds = 0;
+ Int64 year;
+
+ if( date->tm_year > 70 ) {
+ year = 70;
+ while( year < date->tm_year ) {
+ days += length_of_year[IS_LEAP(year)];
+ year++;
+ }
+ }
+ else if ( date->tm_year < 70 ) {
+ year = 69;
+ do {
+ days -= length_of_year[IS_LEAP(year)];
+ year--;
+ } while( year >= date->tm_year );
+ }
+
+ days += julian_days_by_month[IS_LEAP(date->tm_year)][date->tm_mon];
+ days += date->tm_mday - 1;
+
+ /* Avoid overflowing the days integer */
+ seconds = days;
+ seconds = seconds * 60 * 60 * 24;
+
+ seconds += date->tm_hour * 60 * 60;
+ seconds += date->tm_min * 60;
+ seconds += date->tm_sec;
+
+ return((Time64_T)seconds);
+}
+
+
+int _check_tm(struct tm *tm)
+{
+ /* Don't forget leap seconds */
+ assert(tm->tm_sec >= 0);
+ assert(tm->tm_sec <= 61);
+
+ assert(tm->tm_min >= 0);
+ assert(tm->tm_min <= 59);
+
+ assert(tm->tm_hour >= 0);
+ assert(tm->tm_hour <= 23);
+
+ assert(tm->tm_mday >= 1);
+ assert(tm->tm_mday <= days_in_month[IS_LEAP(tm->tm_year)][tm->tm_mon]);
+
+ assert(tm->tm_mon >= 0);
+ assert(tm->tm_mon <= 11);
+
+ assert(tm->tm_wday >= 0);
+ assert(tm->tm_wday <= 6);
+
+ assert(tm->tm_yday >= 0);
+ assert(tm->tm_yday <= length_of_year[IS_LEAP(tm->tm_year)]);
+
+#ifdef HAS_TM_TM_GMTOFF
+ assert(tm->tm_gmtoff >= -24 * 60 * 60);
+ assert(tm->tm_gmtoff <= 24 * 60 * 60);
+#endif
+
+ return 1;
+}
+
+
+/* The exceptional centuries without leap years cause the cycle to
+ shift by 16
+*/
+int _cycle_offset(Int64 year)
+{
+ const Int64 start_year = 2000;
+ Int64 year_diff = year - start_year;
+
+ if( year > start_year )
+ year_diff--;
+
+ Int64 exceptions = year_diff / 100;
+ exceptions -= year_diff / 400;
+
+ /*
+ fprintf(stderr, "# year: %lld, exceptions: %lld, year_diff: %lld\n",
+ year, exceptions, year_diff);
+ */
+
+ return exceptions * 16;
+}
+
+/* For a given year after 2038, pick the latest possible matching
+ year in the 28 year calendar cycle.
+
+ A matching year...
+ 1) Starts on the same day of the week.
+ 2) Has the same leap year status.
+
+ This is so the calendars match up.
+
+ Also the previous year must match. When doing Jan 1st you might
+ wind up on Dec 31st the previous year when doing a -UTC time zone.
+
+ Finally, the next year must have the same start day of week. This
+ is for Dec 31st with a +UTC time zone.
+ It doesn't need the same leap year status since we only care about
+ January 1st.
+*/
+int _safe_year(Int64 year)
+{
+ int safe_year;
+ Int64 year_cycle = year + _cycle_offset(year);
+
+ /* Change non-leap xx00 years to an equivalent */
+ if( _is_exception_century(year) )
+ year_cycle += 11;
+
+ /* Also xx01 years, since the previous year will be wrong */
+ if( _is_exception_century(year - 1) )
+ year_cycle += 17;
+
+ year_cycle %= SOLAR_CYCLE_LENGTH;
+ if( year_cycle < 0 )
+ year_cycle = SOLAR_CYCLE_LENGTH + year_cycle;
+
+ assert( year_cycle >= 0 );
+ assert( 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;
+ Int64 v_tm_tday;
+ int leap;
+ Int64 m;
+ Time64_T time = *in_time;
+ Int64 year = 70;
+
+ /* Use the system gmtime() if time_t is small enough */
+ if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
+ time_t safe_time = *in_time;
+ localtime_r(&safe_time, p);
+ assert(_check_tm(p));
+ return p;
+ }
+
+#ifdef HAS_TM_TM_GMTOFF
+ p->tm_gmtoff = 0;
+#endif
+ p->tm_isdst = 0;
+
+#ifdef HAS_TM_TM_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 >= CHEAT_DAYS) {
+ year = CHEAT_YEARS;
+ m -= CHEAT_DAYS;
+ }
+
+ if (m >= 0) {
+ /* Gregorian cycles, this is huge optimization for distant times */
+ while (m >= (Time64_T) days_in_gregorian_cycle) {
+ m -= (Time64_T) days_in_gregorian_cycle;
+ year += years_in_gregorian_cycle;
+ }
+
+ /* Years */
+ leap = IS_LEAP (year);
+ while (m >= (Time64_T) length_of_year[leap]) {
+ m -= (Time64_T) length_of_year[leap];
+ year++;
+ leap = IS_LEAP (year);
+ }
+
+ /* Months */
+ 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 {
+ year--;
+
+ /* Gregorian cycles */
+ while (m < (Time64_T) -days_in_gregorian_cycle) {
+ m += (Time64_T) days_in_gregorian_cycle;
+ year -= years_in_gregorian_cycle;
+ }
+
+ /* Years */
+ leap = IS_LEAP (year);
+ while (m < (Time64_T) -length_of_year[leap]) {
+ m += (Time64_T) length_of_year[leap];
+ year--;
+ leap = IS_LEAP (year);
+ }
+
+ /* Months */
+ 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_year = year;
+ if( p->tm_year != year ) {
+#ifdef EOVERFLOW
+ errno = EOVERFLOW;
+#endif
+ return NULL;
+ }
+
+ 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;
+
+ assert(_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;
+ Int64 orig_year;
+ int month_diff;
+
+ /* Use the system localtime() if time_t is small enough */
+ if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
+ safe_time = *time;
+ localtime_r(&safe_time, local_tm);
+ assert(_check_tm(local_tm));
+ return local_tm;
+ }
+
+ if( gmtime64_r(time, &gm_tm) == NULL )
+ return NULL;
+
+ orig_year = gm_tm.tm_year;
+
+ if (gm_tm.tm_year > (2037 - 1900) ||
+ gm_tm.tm_year < (1902 - 1900)
+ )
+ {
+ gm_tm.tm_year = _safe_year(gm_tm.tm_year + 1900) - 1900;
+ }
+
+ safe_time = TIMEGM(&gm_tm);
+ if( localtime_r(&safe_time, local_tm) == NULL )
+ return NULL;
+
+ local_tm->tm_year = orig_year;
+ if( local_tm->tm_year != orig_year ) {
+#ifdef EOVERFLOW
+ errno = EOVERFLOW;
+#endif
+ return NULL;
+ }
+
+
+ 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--;
+
+ assert(_check_tm(local_tm));
+
+ return local_tm;
+}
diff --git a/localtime64.h b/localtime64.h
new file mode 100644
index 0000000..b7bd00e
--- /dev/null
+++ b/localtime64.h
@@ -0,0 +1,45 @@
+#ifndef LOCALTIME64_H
+# define LOCALTIME64_H
+
+/* Configuration. */
+/* Define as appropriate for your system */
+/*
+ HAS_TIMEGM
+ Defined if your system has timegm()
+
+ HAS_TM_TM_GMTOFF
+ Defined if your tm struct has a "tm_gmtoff" element.
+
+ HAS_TM_TM_ZONE
+ Defined if your tm struct has a "tm_zone" element.
+
+ SYSTEM_LOCALTIME_MAX
+ SYSTEM_LOCALTIME_MIN
+ SYSTEM_GMTIME_MAX
+ SYSTEM_GMTIME_MIN
+ Maximum and minimum values your system's gmtime() and localtime()
+ can handle.
+
+ USE_SYSTEM_LOCALTIME
+ USE_SYSTEM_GMTIME
+ Should we use the system functions if the time is inside their range?
+*/
+#define SYSTEM_LOCALTIME_MAX LOCALTIME_MAX
+#define SYSTEM_LOCALTIME_MIN LOCALTIME_MIN
+#define SYSTEM_GMTIME_MAX GMTIME_MAX
+#define SYSTEM_GMTIME_MIN GMTIME_MIN
+
+/* The system localtime will be faster and more correct inside its range */
+#define USE_SYSTEM_LOCALTIME 1
+#define USE_SYSTEM_GMTIME 1
+
+
+/* 64 bit types. Set as appropriate for your system. */
+typedef Quad_t Time64_T;
+typedef Quad_t Int64;
+
+struct tm *gmtime64_r (const Time64_T *, struct tm *);
+struct tm *localtime64_r (const Time64_T *, struct tm *);
+Time64_T timegm64 (struct tm *);
+
+#endif
diff --git a/pp_sys.c b/pp_sys.c
index 481864b..ad39804 100644
--- a/pp_sys.c
+++ b/pp_sys.c
@@ -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,66 @@ PP(pp_gmtime)
{
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 (GIMME != G_ARRAY) {
+ if( err == NULL ) {
+ char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
+ Perl_warner(aTHX_ packWARN(WARN_OVERFLOW),
+ "%s under/overflowed the year", opname);
+ }
+
+ if (GIMME != G_ARRAY) { /* scalar context */
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 { /* list context */
+ if ( err == NULL )
+ RETURN;
+
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;
}
diff --git a/t/op/time.t b/t/op/time.t
index 8b2f07d..a67dead 100755
--- a/t/op/time.t
+++ b/t/op/time.t
@@ -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 @@ ok($i >= 2_000_000, 'very basic times test');
($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 @@ $ENV{TZ} = "GMT+5";
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 @@ ok(gmtime() =~ /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat)[ ]
/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:
-
"Steve Hay" <SteveHay@planit.com>
[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original]