[p5sagit/p5-mst-13.2.git] / time64.c

/*

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 "time64.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 Year 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 */
#define SOLAR_CYCLE_LENGTH 28
static const int safe_years[SOLAR_CYCLE_LENGTH] = {
    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[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))

#ifdef USE_SYSTEM_LOCALTIME
#    define SHOULD_USE_SYSTEM_LOCALTIME(a)  (       \
    (a) <= SYSTEM_LOCALTIME_MAX &&              \
    (a) >= SYSTEM_LOCALTIME_MIN                 \
)
#else
#    define SHOULD_USE_SYSTEM_LOCALTIME(a)      (0)
#endif

#ifdef USE_SYSTEM_GMTIME
#    define SHOULD_USE_SYSTEM_GMTIME(a)     (       \
    (a) <= SYSTEM_GMTIME_MAX    &&              \
    (a) >= SYSTEM_GMTIME_MIN                    \
)
#else
#    define SHOULD_USE_SYSTEM_GMTIME(a)         (0)
#endif

/* Multi varadic macros are a C99 thing, alas */
#ifdef TIME_64_DEBUG
#    define TRACE(format) (fprintf(stderr, format))
#    define TRACE1(format, var1)    (fprintf(stderr, format, var1))
#    define TRACE2(format, var1, var2)    (fprintf(stderr, format, var1, var2))
#    define TRACE3(format, var1, var2, var3)    (fprintf(stderr, format, var1, var2, var3))
#else
#    define TRACE(format) ((void)0)
#    define TRACE1(format, var1) ((void)0)
#    define TRACE2(format, var1, var2) ((void)0)
#    define TRACE3(format, var1, var2, var3) ((void)0)
#endif

static int is_exception_century(Year year)
{
    int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
    TRACE1("# is_exception_century: %s\n", is_exception ? "yes" : "no");

    return(is_exception);
}


Time64_T timegm64(struct TM *date) {
    int      days    = 0;
    Time64_T seconds = 0;
    Year     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(seconds);
}


#ifdef DEBUGGING
static 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;
}
#endif


/* The exceptional centuries without leap years cause the cycle to
   shift by 16
*/
static Year cycle_offset(Year year)
{
    const Year start_year = 2000;
    Year year_diff  = year - start_year;
    Year exceptions;

    if( year > start_year )
        year_diff--;

    exceptions  = year_diff / 100;
    exceptions -= year_diff / 400;

    TRACE3("# 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.
*/
static int safe_year(Year year)
{
    int safe_year;
    Year 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);

    TRACE3("# year: %lld, year_cycle: %lld, safe_year: %d\n",
          year, year_cycle, safe_year);

    return safe_year;
}


void copy_little_tm_to_big_TM(const struct tm *src, struct TM *dest) {
    if( src == NULL ) {
        memset(dest, 0, sizeof(*dest));
    }
    else {
#       ifdef USE_TM64
            dest->tm_sec        = src->tm_sec;
            dest->tm_min        = src->tm_min;
            dest->tm_hour       = src->tm_hour;
            dest->tm_mday       = src->tm_mday;
            dest->tm_mon        = src->tm_mon;
            dest->tm_year       = (Year)src->tm_year;
            dest->tm_wday       = src->tm_wday;
            dest->tm_yday       = src->tm_yday;
            dest->tm_isdst      = src->tm_isdst;

#           ifdef HAS_TM_TM_GMTOFF
                dest->tm_gmtoff  = src->tm_gmtoff;
#           endif

#           ifdef HAS_TM_TM_ZONE
                dest->tm_zone  = src->tm_zone;
#           endif

#       else
            /* They're the same type */
            memcpy(dest, src, sizeof(*dest));
#       endif
    }
}


void copy_big_TM_to_little_tm(const struct TM *src, struct tm *dest) {
    if( src == NULL ) {
        memset(dest, 0, sizeof(*dest));
    }
    else {
#       ifdef USE_TM64
            dest->tm_sec        = src->tm_sec;
            dest->tm_min        = src->tm_min;
            dest->tm_hour       = src->tm_hour;
            dest->tm_mday       = src->tm_mday;
            dest->tm_mon        = src->tm_mon;
            dest->tm_year       = (int)src->tm_year;
            dest->tm_wday       = src->tm_wday;
            dest->tm_yday       = src->tm_yday;
            dest->tm_isdst      = src->tm_isdst;

#           ifdef HAS_TM_TM_GMTOFF
                dest->tm_gmtoff  = src->tm_gmtoff;
#           endif

#           ifdef HAS_TM_TM_ZONE
                dest->tm_zone  = src->tm_zone;
#           endif

#       else
            /* They're the same type */
            memcpy(dest, src, sizeof(*dest));
#       endif
    }
}


/* Simulate localtime_r() to the best of our ability */
struct tm * fake_localtime_r(const time_t *clock, struct tm *result) {
    dTHX;    /* in case the following is defined as Perl_my_localtime(aTHX_ ...) */
    const struct tm *static_result = localtime(clock);

    assert(result != NULL);

    if( static_result == NULL ) {
        memset(result, 0, sizeof(*result));
        return NULL;
    }
    else {
        memcpy(result, static_result, sizeof(*result));
        return result;
    }
}


/* Simulate gmtime_r() to the best of our ability */
struct tm * fake_gmtime_r(const time_t *clock, struct tm *result) {
    dTHX;    /* in case the following is defined as Perl_my_gmtime(aTHX_ ...) */
    const struct tm *static_result = gmtime(clock);

    assert(result != NULL);

    if( static_result == NULL ) {
        memset(result, 0, sizeof(*result));
        return NULL;
    }
    else {
        memcpy(result, static_result, sizeof(*result));
        return result;
    }
}


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;
    Year year = 70;
    int cycles = 0;

    assert(p != NULL);

    /* Use the system gmtime() if time_t is small enough */
    if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
        time_t safe_time = (time_t)*in_time;
        struct tm safe_date;
        GMTIME_R(&safe_time, &safe_date);

        copy_little_tm_to_big_TM(&safe_date, 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 =  (int)(time % 60);
    time /= 60;
    v_tm_min =  (int)(time % 60);
    time /= 60;
    v_tm_hour = (int)(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);

    v_tm_wday = (int)((v_tm_tday + 4) % 7);
    if (v_tm_wday < 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 */
        cycles = (int)(m / (Time64_T) days_in_gregorian_cycle);
        if( cycles ) {
            m -= (cycles * (Time64_T) days_in_gregorian_cycle);
            year += (cycles * 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 */
        cycles = (int)((m / (Time64_T) days_in_gregorian_cycle) + 1);
        if( cycles ) {
            m -= (cycles * (Time64_T) days_in_gregorian_cycle);
            year += (cycles * 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;
    }

    /* At this point m is less than a year so casting to an int is safe */
    p->tm_mday = (int) m + 1;
    p->tm_yday = julian_days_by_month[leap][v_tm_mon] + (int)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 safe_date;
    struct TM gm_tm;
    Year orig_year;
    int month_diff;

    assert(local_tm != NULL);

    /* Use the system localtime() if time_t is small enough */
    if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
        safe_time = (time_t)*time;

        TRACE1("Using system localtime for %lld\n", *time);

        LOCALTIME_R(&safe_time, &safe_date);

        copy_little_tm_to_big_TM(&safe_date, local_tm);
        assert(check_tm(local_tm));

        return local_tm;
    }

    if( gmtime64_r(time, &gm_tm) == NULL ) {
        TRACE1("gmtime64_r returned null for %lld\n", *time);
        return NULL;
    }

    orig_year = gm_tm.tm_year;

    if (gm_tm.tm_year > (2037 - 1900) ||
        gm_tm.tm_year < (1970 - 1900)
       )
    {
        TRACE1("Mapping tm_year %lld to safe_year\n", (Year)gm_tm.tm_year);
        gm_tm.tm_year = safe_year((Year)(gm_tm.tm_year + 1900)) - 1900;
    }

    safe_time = (time_t)timegm64(&gm_tm);
    if( LOCALTIME_R(&safe_time, &safe_date) == NULL ) {
        TRACE1("localtime_r(%d) returned NULL\n", (int)safe_time);
        return NULL;
    }

    copy_little_tm_to_big_TM(&safe_date, local_tm);

    local_tm->tm_year = orig_year;
    if( local_tm->tm_year != orig_year ) {
        TRACE2("tm_year overflow: tm_year %lld, orig_year %lld\n",
              (Year)local_tm->tm_year, (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;
}
Commit	Line	Data
a272e669	1	/*
	2
	3	Copyright (c) 2007-2008 Michael G Schwern
	4
	5	This software originally derived from Paul Sheer's pivotal_gmtime_r.c.
	6
	7	The MIT License:
	8
	9	Permission is hereby granted, free of charge, to any person obtaining a copy
	10	of this software and associated documentation files (the "Software"), to deal
	11	in the Software without restriction, including without limitation the rights
	12	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	copies of the Software, and to permit persons to whom the Software is
	14	furnished to do so, subject to the following conditions:
	15
	16	The above copyright notice and this permission notice shall be included in
	17	all copies or substantial portions of the Software.
	18
	19	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	25	THE SOFTWARE.
	26
	27	*/
	28
	29	/*
	30
	31	Programmers who have available to them 64-bit time values as a 'long
	32	long' type can use localtime64_r() and gmtime64_r() which correctly
	33	converts the time even on 32-bit systems. Whether you have 64-bit time
	34	values will depend on the operating system.
	35
	36	localtime64_r() is a 64-bit equivalent of localtime_r().
	37
	38	gmtime64_r() is a 64-bit equivalent of gmtime_r().
	39
	40	*/
	41
7643e68f	42	#include "time64.h"
af9b2bf5	43
a272e669	44	static 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
	49	static 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
	54	static const int length_of_year[2] = { 365, 366 };
	55
	56	/* Number of days in a 400 year Gregorian cycle */
806a119a	57	static const Year years_in_gregorian_cycle = 400;
a272e669	58	static const int days_in_gregorian_cycle = (365 * 400) + 100 - 4 + 1;
	59
	60	/* 28 year calendar cycle between 2010 and 2037 */
806a119a	61	#define SOLAR_CYCLE_LENGTH 28
806a119a	62	static const int safe_years[SOLAR_CYCLE_LENGTH] = {
a272e669	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	72	static const int dow_year_start[SOLAR_CYCLE_LENGTH] = {
003c3b95	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	80	};
a272e669	81
9af24521	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	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
b86b480f	93	#ifdef USE_SYSTEM_LOCALTIME
b86b480f	94	# define SHOULD_USE_SYSTEM_LOCALTIME(a) ( \
7bda3dfc	95	(a) <= SYSTEM_LOCALTIME_MAX && \
	96	(a) >= SYSTEM_LOCALTIME_MIN \
	97	)
b86b480f	98	#else
	99	# define SHOULD_USE_SYSTEM_LOCALTIME(a) (0)
	100	#endif
	101
	102	#ifdef USE_SYSTEM_GMTIME
	103	# define SHOULD_USE_SYSTEM_GMTIME(a) ( \
7bda3dfc	104	(a) <= SYSTEM_GMTIME_MAX && \
	105	(a) >= SYSTEM_GMTIME_MIN \
	106	)
b86b480f	107	#else
	108	# define SHOULD_USE_SYSTEM_GMTIME(a) (0)
	109	#endif
a64acb40	110
d4fb0a1f	111	/* Multi varadic macros are a C99 thing, alas */
461d5a49	112	#ifdef TIME_64_DEBUG
d4fb0a1f	113	# define TRACE(format) (fprintf(stderr, format))
	114	# define TRACE1(format, var1) (fprintf(stderr, format, var1))
	115	# define TRACE2(format, var1, var2) (fprintf(stderr, format, var1, var2))
	116	# define TRACE3(format, var1, var2, var3) (fprintf(stderr, format, var1, var2, var3))
461d5a49	117	#else
d4fb0a1f	118	# define TRACE(format) ((void)0)
	119	# define TRACE1(format, var1) ((void)0)
	120	# define TRACE2(format, var1, var2) ((void)0)
	121	# define TRACE3(format, var1, var2, var3) ((void)0)
461d5a49	122	#endif
a64acb40	123
b86b480f	124	static int is_exception_century(Year year)
a272e669	125	{
a272e669	126	int is_exception = ((year % 100 == 0) && !(year % 400 == 0));
d4fb0a1f	127	TRACE1("# is_exception_century: %s\n", is_exception ? "yes" : "no");
a272e669	128
	129	return(is_exception);
	130	}
	131
9af24521	132
806a119a	133	Time64_T timegm64(struct TM *date) {
b86b480f	134	int days = 0;
	135	Time64_T seconds = 0;
	136	Year year;
a272e669	137
9af24521	138	if( date->tm_year > 70 ) {
	139	year = 70;
	140	while( year < date->tm_year ) {
	141	days += length_of_year[IS_LEAP(year)];
	142	year++;
a272e669	143	}
a272e669	144	}
9af24521	145	else if ( date->tm_year < 70 ) {
	146	year = 69;
	147	do {
	148	days -= length_of_year[IS_LEAP(year)];
	149	year--;
	150	} while( year >= date->tm_year );
	151	}
	152
	153	days += julian_days_by_month[IS_LEAP(date->tm_year)][date->tm_mon];
	154	days += date->tm_mday - 1;
	155
ea722b76	156	/* Avoid overflowing the days integer */
	157	seconds = days;
	158	seconds = seconds * 60 * 60 * 24;
	159
9af24521	160	seconds += date->tm_hour * 60 * 60;
	161	seconds += date->tm_min * 60;
	162	seconds += date->tm_sec;
	163
b86b480f	164	return(seconds);
9af24521	165	}
	166
	167
554fcfb9	168	#ifdef DEBUGGING
806a119a	169	static int check_tm(struct TM *tm)
9af24521	170	{
9af24521	171	/* Don't forget leap seconds */
af9b2bf5	172	assert(tm->tm_sec >= 0);
9af24521	173	assert(tm->tm_sec <= 61);
9af24521	174
af9b2bf5	175	assert(tm->tm_min >= 0);
9af24521	176	assert(tm->tm_min <= 59);
	177
	178	assert(tm->tm_hour >= 0);
	179	assert(tm->tm_hour <= 23);
	180
	181	assert(tm->tm_mday >= 1);
af9b2bf5	182	assert(tm->tm_mday <= days_in_month[IS_LEAP(tm->tm_year)][tm->tm_mon]);
9af24521	183
	184	assert(tm->tm_mon >= 0);
	185	assert(tm->tm_mon <= 11);
	186
	187	assert(tm->tm_wday >= 0);
	188	assert(tm->tm_wday <= 6);
	189
	190	assert(tm->tm_yday >= 0);
af9b2bf5	191	assert(tm->tm_yday <= length_of_year[IS_LEAP(tm->tm_year)]);
9af24521	192
	193	#ifdef HAS_TM_TM_GMTOFF
	194	assert(tm->tm_gmtoff >= -24 * 60 * 60);
	195	assert(tm->tm_gmtoff <= 24 * 60 * 60);
	196	#endif
af9b2bf5	197
af9b2bf5	198	return 1;
a272e669	199	}
554fcfb9	200	#endif
a64acb40	201
a272e669	202
	203	/* The exceptional centuries without leap years cause the cycle to
	204	shift by 16
	205	*/
806a119a	206	static Year cycle_offset(Year year)
a272e669	207	{
750c447b	208	const Year start_year = 2000;
	209	Year year_diff = year - start_year;
	210	Year exceptions;
003c3b95	211
	212	if( year > start_year )
	213	year_diff--;
	214
750c447b	215	exceptions = year_diff / 100;
750c447b	216	exceptions -= year_diff / 400;
a272e669	217
d4fb0a1f	218	TRACE3("# year: %lld, exceptions: %lld, year_diff: %lld\n",
461d5a49	219	year, exceptions, year_diff);
a272e669	220
	221	return exceptions * 16;
	222	}
	223
	224	/* For a given year after 2038, pick the latest possible matching
	225	year in the 28 year calendar cycle.
ea722b76	226
	227	A matching year...
	228	1) Starts on the same day of the week.
	229	2) Has the same leap year status.
	230
	231	This is so the calendars match up.
	232
	233	Also the previous year must match. When doing Jan 1st you might
	234	wind up on Dec 31st the previous year when doing a -UTC time zone.
003c3b95	235
	236	Finally, the next year must have the same start day of week. This
	237	is for Dec 31st with a +UTC time zone.
	238	It doesn't need the same leap year status since we only care about
	239	January 1st.
a272e669	240	*/
806a119a	241	static int safe_year(Year year)
a272e669	242	{
a272e669	243	int safe_year;
806a119a	244	Year year_cycle = year + cycle_offset(year);
a272e669	245
a272e669	246	/* Change non-leap xx00 years to an equivalent */
806a119a	247	if( is_exception_century(year) )
a272e669	248	year_cycle += 11;
a272e669	249
003c3b95	250	/* Also xx01 years, since the previous year will be wrong */
806a119a	251	if( is_exception_century(year - 1) )
003c3b95	252	year_cycle += 17;
003c3b95	253
a272e669	254	year_cycle %= SOLAR_CYCLE_LENGTH;
ea722b76	255	if( year_cycle < 0 )
ea722b76	256	year_cycle = SOLAR_CYCLE_LENGTH + year_cycle;
a272e669	257
003c3b95	258	assert( year_cycle >= 0 );
003c3b95	259	assert( year_cycle < SOLAR_CYCLE_LENGTH );
a272e669	260	safe_year = safe_years[year_cycle];
	261
	262	assert(safe_year <= 2037 && safe_year >= 2010);
	263
d4fb0a1f	264	TRACE3("# year: %lld, year_cycle: %lld, safe_year: %d\n",
461d5a49	265	year, year_cycle, safe_year);
a272e669	266
	267	return safe_year;
	268	}
	269
750c447b	270
ef3a38ff	271	void copy_little_tm_to_big_TM(const struct tm src, struct TM dest) {
806a119a	272	if( src == NULL ) {
	273	memset(dest, 0, sizeof(*dest));
	274	}
	275	else {
	276	# ifdef USE_TM64
	277	dest->tm_sec = src->tm_sec;
	278	dest->tm_min = src->tm_min;
	279	dest->tm_hour = src->tm_hour;
	280	dest->tm_mday = src->tm_mday;
	281	dest->tm_mon = src->tm_mon;
	282	dest->tm_year = (Year)src->tm_year;
	283	dest->tm_wday = src->tm_wday;
	284	dest->tm_yday = src->tm_yday;
	285	dest->tm_isdst = src->tm_isdst;
	286
	287	# ifdef HAS_TM_TM_GMTOFF
	288	dest->tm_gmtoff = src->tm_gmtoff;
	289	# endif
	290
	291	# ifdef HAS_TM_TM_ZONE
	292	dest->tm_zone = src->tm_zone;
	293	# endif
	294
	295	# else
	296	/* They're the same type */
	297	memcpy(dest, src, sizeof(*dest));
	298	# endif
	299	}
	300	}
	301
	302
ef3a38ff	303	void copy_big_TM_to_little_tm(const struct TM src, struct tm dest) {
806a119a	304	if( src == NULL ) {
	305	memset(dest, 0, sizeof(*dest));
	306	}
	307	else {
	308	# ifdef USE_TM64
	309	dest->tm_sec = src->tm_sec;
	310	dest->tm_min = src->tm_min;
	311	dest->tm_hour = src->tm_hour;
	312	dest->tm_mday = src->tm_mday;
	313	dest->tm_mon = src->tm_mon;
	314	dest->tm_year = (int)src->tm_year;
	315	dest->tm_wday = src->tm_wday;
	316	dest->tm_yday = src->tm_yday;
	317	dest->tm_isdst = src->tm_isdst;
	318
	319	# ifdef HAS_TM_TM_GMTOFF
	320	dest->tm_gmtoff = src->tm_gmtoff;
	321	# endif
	322
	323	# ifdef HAS_TM_TM_ZONE
	324	dest->tm_zone = src->tm_zone;
	325	# endif
	326
	327	# else
	328	/* They're the same type */
	329	memcpy(dest, src, sizeof(*dest));
	330	# endif
	331	}
	332	}
	333
	334
948ea7a9	335	/* Simulate localtime_r() to the best of our ability */
948ea7a9	336	struct tm * fake_localtime_r(const time_t clock, struct tm result) {
478780ab	337	dTHX; /* in case the following is defined as Perl_my_localtime(aTHX_ ...) */
948ea7a9	338	const struct tm *static_result = localtime(clock);
	339
	340	assert(result != NULL);
	341
	342	if( static_result == NULL ) {
	343	memset(result, 0, sizeof(*result));
	344	return NULL;
	345	}
	346	else {
	347	memcpy(result, static_result, sizeof(*result));
	348	return result;
	349	}
	350	}
	351
	352
	353	/* Simulate gmtime_r() to the best of our ability */
	354	struct tm * fake_gmtime_r(const time_t clock, struct tm result) {
478780ab	355	dTHX; /* in case the following is defined as Perl_my_gmtime(aTHX_ ...) */
948ea7a9	356	const struct tm *static_result = gmtime(clock);
	357
	358	assert(result != NULL);
	359
	360	if( static_result == NULL ) {
	361	memset(result, 0, sizeof(*result));
	362	return NULL;
	363	}
	364	else {
	365	memcpy(result, static_result, sizeof(*result));
	366	return result;
	367	}
	368	}
	369
	370
806a119a	371	struct TM gmtime64_r (const Time64_T in_time, struct TM *p)
a272e669	372	{
a272e669	373	int v_tm_sec, v_tm_min, v_tm_hour, v_tm_mon, v_tm_wday;
b86b480f	374	Time64_T v_tm_tday;
a272e669	375	int leap;
b86b480f	376	Time64_T m;
a272e669	377	Time64_T time = *in_time;
750c447b	378	Year year = 70;
806a119a	379	int cycles = 0;
a272e669	380
948ea7a9	381	assert(p != NULL);
948ea7a9	382
a64acb40	383	/* Use the system gmtime() if time_t is small enough */
a64acb40	384	if( SHOULD_USE_SYSTEM_GMTIME(*in_time) ) {
cd1759d8	385	time_t safe_time = (time_t)*in_time;
806a119a	386	struct tm safe_date;
	387	GMTIME_R(&safe_time, &safe_date);
	388
ef3a38ff	389	copy_little_tm_to_big_TM(&safe_date, p);
806a119a	390	assert(check_tm(p));
806a119a	391
a64acb40	392	return p;
	393	}
	394
9af24521	395	#ifdef HAS_TM_TM_GMTOFF
a272e669	396	p->tm_gmtoff = 0;
	397	#endif
	398	p->tm_isdst = 0;
	399
9af24521	400	#ifdef HAS_TM_TM_ZONE
a272e669	401	p->tm_zone = "UTC";
	402	#endif
	403
750c447b	404	v_tm_sec = (int)(time % 60);
a272e669	405	time /= 60;
750c447b	406	v_tm_min = (int)(time % 60);
a272e669	407	time /= 60;
750c447b	408	v_tm_hour = (int)(time % 24);
a272e669	409	time /= 24;
a272e669	410	v_tm_tday = time;
750c447b	411
a272e669	412	WRAP (v_tm_sec, v_tm_min, 60);
	413	WRAP (v_tm_min, v_tm_hour, 60);
	414	WRAP (v_tm_hour, v_tm_tday, 24);
750c447b	415
	416	v_tm_wday = (int)((v_tm_tday + 4) % 7);
	417	if (v_tm_wday < 0)
a272e669	418	v_tm_wday += 7;
a272e669	419	m = v_tm_tday;
a272e669	420
9af24521	421	if (m >= CHEAT_DAYS) {
	422	year = CHEAT_YEARS;
	423	m -= CHEAT_DAYS;
	424	}
	425
	426	if (m >= 0) {
a272e669	427	/* Gregorian cycles, this is huge optimization for distant times */
461d5a49	428	cycles = (int)(m / (Time64_T) days_in_gregorian_cycle);
806a119a	429	if( cycles ) {
	430	m -= (cycles * (Time64_T) days_in_gregorian_cycle);
	431	year += (cycles * years_in_gregorian_cycle);
a272e669	432	}
	433
	434	/* Years */
	435	leap = IS_LEAP (year);
	436	while (m >= (Time64_T) length_of_year[leap]) {
	437	m -= (Time64_T) length_of_year[leap];
	438	year++;
	439	leap = IS_LEAP (year);
	440	}
	441
	442	/* Months */
	443	v_tm_mon = 0;
	444	while (m >= (Time64_T) days_in_month[leap][v_tm_mon]) {
	445	m -= (Time64_T) days_in_month[leap][v_tm_mon];
	446	v_tm_mon++;
	447	}
	448	} else {
9af24521	449	year--;
a272e669	450
a272e669	451	/* Gregorian cycles */
461d5a49	452	cycles = (int)((m / (Time64_T) days_in_gregorian_cycle) + 1);
806a119a	453	if( cycles ) {
	454	m -= (cycles * (Time64_T) days_in_gregorian_cycle);
	455	year += (cycles * years_in_gregorian_cycle);
a272e669	456	}
	457
	458	/* Years */
	459	leap = IS_LEAP (year);
	460	while (m < (Time64_T) -length_of_year[leap]) {
	461	m += (Time64_T) length_of_year[leap];
	462	year--;
	463	leap = IS_LEAP (year);
	464	}
	465
	466	/* Months */
	467	v_tm_mon = 11;
	468	while (m < (Time64_T) -days_in_month[leap][v_tm_mon]) {
	469	m += (Time64_T) days_in_month[leap][v_tm_mon];
	470	v_tm_mon--;
	471	}
	472	m += (Time64_T) days_in_month[leap][v_tm_mon];
	473	}
	474
	475	p->tm_year = year;
	476	if( p->tm_year != year ) {
9af24521	477	#ifdef EOVERFLOW
a272e669	478	errno = EOVERFLOW;
9af24521	479	#endif
a272e669	480	return NULL;
	481	}
	482
b86b480f	483	/* At this point m is less than a year so casting to an int is safe */
a272e669	484	p->tm_mday = (int) m + 1;
b86b480f	485	p->tm_yday = julian_days_by_month[leap][v_tm_mon] + (int)m;
	486	p->tm_sec = v_tm_sec;
	487	p->tm_min = v_tm_min;
	488	p->tm_hour = v_tm_hour;
	489	p->tm_mon = v_tm_mon;
	490	p->tm_wday = v_tm_wday;
a272e669	491
806a119a	492	assert(check_tm(p));
a272e669	493
	494	return p;
	495	}
	496
	497
806a119a	498	struct TM localtime64_r (const Time64_T time, struct TM *local_tm)
a272e669	499	{
a272e669	500	time_t safe_time;
806a119a	501	struct tm safe_date;
806a119a	502	struct TM gm_tm;
750c447b	503	Year orig_year;
a272e669	504	int month_diff;
a272e669	505
948ea7a9	506	assert(local_tm != NULL);
948ea7a9	507
a64acb40	508	/* Use the system localtime() if time_t is small enough */
a64acb40	509	if( SHOULD_USE_SYSTEM_LOCALTIME(*time) ) {
cd1759d8	510	safe_time = (time_t)*time;
806a119a	511
d4fb0a1f	512	TRACE1("Using system localtime for %lld\n", *time);
461d5a49	513
806a119a	514	LOCALTIME_R(&safe_time, &safe_date);
806a119a	515
ef3a38ff	516	copy_little_tm_to_big_TM(&safe_date, local_tm);
806a119a	517	assert(check_tm(local_tm));
806a119a	518
a64acb40	519	return local_tm;
	520	}
	521
461d5a49	522	if( gmtime64_r(time, &gm_tm) == NULL ) {
d4fb0a1f	523	TRACE1("gmtime64_r returned null for %lld\n", *time);
af832814	524	return NULL;
461d5a49	525	}
af832814	526
a272e669	527	orig_year = gm_tm.tm_year;
a272e669	528
c07fe26c	529	if (gm_tm.tm_year > (2037 - 1900) \|\|
461d5a49	530	gm_tm.tm_year < (1970 - 1900)
c07fe26c	531	)
c07fe26c	532	{
d4fb0a1f	533	TRACE1("Mapping tm_year %lld to safe_year\n", (Year)gm_tm.tm_year);
b86b480f	534	gm_tm.tm_year = safe_year((Year)(gm_tm.tm_year + 1900)) - 1900;
c07fe26c	535	}
a272e669	536
cd1759d8	537	safe_time = (time_t)timegm64(&gm_tm);
461d5a49	538	if( LOCALTIME_R(&safe_time, &safe_date) == NULL ) {
d4fb0a1f	539	TRACE1("localtime_r(%d) returned NULL\n", (int)safe_time);
af832814	540	return NULL;
461d5a49	541	}
a272e669	542
ef3a38ff	543	copy_little_tm_to_big_TM(&safe_date, local_tm);
806a119a	544
a272e669	545	local_tm->tm_year = orig_year;
af832814	546	if( local_tm->tm_year != orig_year ) {
d4fb0a1f	547	TRACE2("tm_year overflow: tm_year %lld, orig_year %lld\n",
461d5a49	548	(Year)local_tm->tm_year, (Year)orig_year);
461d5a49	549
af832814	550	#ifdef EOVERFLOW
	551	errno = EOVERFLOW;
	552	#endif
	553	return NULL;
	554	}
	555
	556
a272e669	557	month_diff = local_tm->tm_mon - gm_tm.tm_mon;
	558
	559	/* When localtime is Dec 31st previous year and
	560	gmtime is Jan 1st next year.
	561	*/
	562	if( month_diff == 11 ) {
	563	local_tm->tm_year--;
	564	}
	565
	566	/* When localtime is Jan 1st, next year and
	567	gmtime is Dec 31st, previous year.
	568	*/
	569	if( month_diff == -11 ) {
	570	local_tm->tm_year++;
	571	}
	572
	573	/* GMT is Jan 1st, xx01 year, but localtime is still Dec 31st
	574	in a non-leap xx00. There is one point in the cycle
	575	we can't account for which the safe xx00 year is a leap
	576	year. So we need to correct for Dec 31st comming out as
	577	the 366th day of the year.
	578	*/
	579	if( !IS_LEAP(local_tm->tm_year) && local_tm->tm_yday == 365 )
	580	local_tm->tm_yday--;
	581
806a119a	582	assert(check_tm(local_tm));
a272e669	583
	584	return local_tm;
	585	}