#define _PY_DATETIME_IMPL

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include "pycore_long.h" // _PyLong_GetOne()

#include "pycore_object.h" // _PyObject_Init()

#include "pycore_time.h" // _PyTime_ObjectToTime_t()

#include "datetime.h"

#include <time.h>

#ifdef MS_WINDOWS

# include <winsock2.h> /* struct timeval */

static PyTypeObject PyDateTime_DateType;

static PyTypeObject PyDateTime_DateTimeType;

static PyTypeObject PyDateTime_TimeType;

static PyTypeObject PyDateTime_DeltaType;

static PyTypeObject PyDateTime_TZInfoType;

static PyTypeObject PyDateTime_TimeZoneType;

typedef struct {

/* Module heap types. */

PyTypeObject *isocalendar_date_type;

/* Conversion factors. */

PyObject *us_per_ms; // 1_000

PyObject *us_per_second; // 1_000_000

PyObject *us_per_minute; // 1e6 * 60 as Python int

PyObject *us_per_hour; // 1e6 * 3600 as Python int

PyObject *us_per_day; // 1e6 * 3600 * 24 as Python int

PyObject *us_per_week; // 1e6 * 3600 * 24 * 7 as Python int

PyObject *seconds_per_day; // 3600 * 24 as Python int

/* The interned Unix epoch datetime instance */

PyObject *epoch;

} datetime_state;

#define NO_STATE NULL

#define DATE_TYPE(st) &PyDateTime_DateType

#define DATETIME_TYPE(st) &PyDateTime_DateTimeType

#define TIME_TYPE(st) &PyDateTime_TimeType

#define DELTA_TYPE(st) &PyDateTime_DeltaType

#define TZINFO_TYPE(st) &PyDateTime_TZInfoType

#define TIMEZONE_TYPE(st) &PyDateTime_TimeZoneType

#define ISOCALENDAR_DATE_TYPE(st) st->isocalendar_date_type

#define PyDate_Check(op) PyObject_TypeCheck(op, DATE_TYPE(NO_STATE))

#define PyDate_CheckExact(op) Py_IS_TYPE(op, DATE_TYPE(NO_STATE))

#define PyDateTime_Check(op) PyObject_TypeCheck(op, DATETIME_TYPE(NO_STATE))

#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, DATETIME_TYPE(NO_STATE))

#define PyTime_Check(op) PyObject_TypeCheck(op, TIME_TYPE(NO_STATE))

#define PyTime_CheckExact(op) Py_IS_TYPE(op, TIME_TYPE(NO_STATE))

#define PyDelta_Check(op) PyObject_TypeCheck(op, DELTA_TYPE(NO_STATE))

#define PyDelta_CheckExact(op) Py_IS_TYPE(op, DELTA_TYPE(NO_STATE))

#define PyTZInfo_Check(op) PyObject_TypeCheck(op, TZINFO_TYPE(NO_STATE))

#define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, TZINFO_TYPE(NO_STATE))

#define PyTimezone_Check(op) PyObject_TypeCheck(op, TIMEZONE_TYPE(NO_STATE))

#define CONST_US_PER_MS(st) st->us_per_ms

#define CONST_US_PER_SECOND(st) st->us_per_second

#define CONST_US_PER_MINUTE(st) st->us_per_minute

#define CONST_US_PER_HOUR(st) st->us_per_hour

#define CONST_US_PER_DAY(st) st->us_per_day

#define CONST_US_PER_WEEK(st) st->us_per_week

#define CONST_SEC_PER_DAY(st) st->seconds_per_day

#define CONST_EPOCH(st) st->epoch

#define CONST_UTC(st) ((PyObject *)&utc_timezone)

static datetime_state *

get_module_state(PyObject *module)

{

void *state = _PyModule_GetState(module);

assert(state != NULL);

return (datetime_state *)state;

}

#define INTERP_KEY ((PyObject *)&_Py_ID(cached_datetime_module))

static PyObject *

get_current_module(PyInterpreterState *interp, int *p_reloading)

{

PyObject *mod = NULL;

int reloading = 0;

PyObject *dict = PyInterpreterState_GetDict(interp);

if (dict == NULL) {

goto error;

}

PyObject *ref = NULL;

if (PyDict_GetItemRef(dict, INTERP_KEY, &ref) < 0) {

goto error;

}

if (ref != NULL) {

reloading = 1;

if (ref != Py_None) {

(void)PyWeakref_GetRef(ref, &mod);

if (mod == Py_None) {

Py_CLEAR(mod);

}

Py_DECREF(ref);

}

}

if (p_reloading != NULL) {

*p_reloading = reloading;

}

return mod;

error:

assert(PyErr_Occurred());

return NULL;

}

static PyModuleDef datetimemodule;

static datetime_state *

_get_current_state(PyObject **p_mod)

{

PyInterpreterState *interp = PyInterpreterState_Get();

PyObject *mod = get_current_module(interp, NULL);

if (mod == NULL) {

assert(!PyErr_Occurred());

if (PyErr_Occurred()) {

return NULL;

}

/* The static types can outlive the module,

mod = PyImport_ImportModule("_datetime");

if (mod == NULL) {

return NULL;

}

}

datetime_state *st = get_module_state(mod);

*p_mod = mod;

return st;

}

#define GET_CURRENT_STATE(MOD_VAR) \

_get_current_state(&MOD_VAR)

#define RELEASE_CURRENT_STATE(ST_VAR, MOD_VAR) \

Py_DECREF(MOD_VAR)

static int

set_current_module(PyInterpreterState *interp, PyObject *mod)

{

assert(mod != NULL);

PyObject *dict = PyInterpreterState_GetDict(interp);

if (dict == NULL) {

return -1;

}

PyObject *ref = PyWeakref_NewRef(mod, NULL);

if (ref == NULL) {

return -1;

}

int rc = PyDict_SetItem(dict, INTERP_KEY, ref);

Py_DECREF(ref);

return rc;

}

static void

clear_current_module(PyInterpreterState *interp, PyObject *expected)

{

PyObject *exc = PyErr_GetRaisedException();

PyObject *dict = PyInterpreterState_GetDict(interp);

if (dict == NULL) {

goto error;

}

if (expected != NULL) {

PyObject *ref = NULL;

if (PyDict_GetItemRef(dict, INTERP_KEY, &ref) < 0) {

goto error;

}

if (ref != NULL) {

PyObject *current = NULL;

int rc = PyWeakref_GetRef(ref, &current);

/* We only need "current" for pointer comparison. */

Py_XDECREF(current);

Py_DECREF(ref);

if (rc < 0) {

goto error;

}

if (current != expected) {

goto finally;

}

}

}

/* We use None to identify that the module was previously loaded. */

if (PyDict_SetItem(dict, INTERP_KEY, Py_None) < 0) {

goto error;

}

goto finally;

error:

PyErr_WriteUnraisable(NULL);

finally:

PyErr_SetRaisedException(exc);

}

#if SIZEOF_INT < 4

# error "_datetime.c requires that C int have at least 32 bits"

#define MINYEAR 1

#define MAXYEAR 9999

#define MAXORDINAL 3652059 /* date(9999,12,31).toordinal() */

#define MAX_DELTA_DAYS 999999999

#define GET_YEAR PyDateTime_GET_YEAR

#define GET_MONTH PyDateTime_GET_MONTH

#define GET_DAY PyDateTime_GET_DAY

#define DATE_GET_HOUR PyDateTime_DATE_GET_HOUR

#define DATE_GET_MINUTE PyDateTime_DATE_GET_MINUTE

#define DATE_GET_SECOND PyDateTime_DATE_GET_SECOND

#define DATE_GET_MICROSECOND PyDateTime_DATE_GET_MICROSECOND

#define DATE_GET_FOLD PyDateTime_DATE_GET_FOLD

#define SET_YEAR(o, v) (((o)->data[0] = ((v) & 0xff00) >> 8), \

((o)->data[1] = ((v) & 0x00ff)))

#define SET_MONTH(o, v) (PyDateTime_GET_MONTH(o) = (v))

#define SET_DAY(o, v) (PyDateTime_GET_DAY(o) = (v))

#define DATE_SET_HOUR(o, v) (PyDateTime_DATE_GET_HOUR(o) = (v))

#define DATE_SET_MINUTE(o, v) (PyDateTime_DATE_GET_MINUTE(o) = (v))

#define DATE_SET_SECOND(o, v) (PyDateTime_DATE_GET_SECOND(o) = (v))

#define DATE_SET_MICROSECOND(o, v) \

(((o)->data[7] = ((v) & 0xff0000) >> 16), \

((o)->data[8] = ((v) & 0x00ff00) >> 8), \

((o)->data[9] = ((v) & 0x0000ff)))

#define DATE_SET_FOLD(o, v) (PyDateTime_DATE_GET_FOLD(o) = (v))

#define TIME_GET_HOUR PyDateTime_TIME_GET_HOUR

#define TIME_GET_MINUTE PyDateTime_TIME_GET_MINUTE

#define TIME_GET_SECOND PyDateTime_TIME_GET_SECOND

#define TIME_GET_MICROSECOND PyDateTime_TIME_GET_MICROSECOND

#define TIME_GET_FOLD PyDateTime_TIME_GET_FOLD

#define TIME_SET_HOUR(o, v) (PyDateTime_TIME_GET_HOUR(o) = (v))

#define TIME_SET_MINUTE(o, v) (PyDateTime_TIME_GET_MINUTE(o) = (v))

#define TIME_SET_SECOND(o, v) (PyDateTime_TIME_GET_SECOND(o) = (v))

#define TIME_SET_MICROSECOND(o, v) \

(((o)->data[3] = ((v) & 0xff0000) >> 16), \

((o)->data[4] = ((v) & 0x00ff00) >> 8), \

((o)->data[5] = ((v) & 0x0000ff)))

#define TIME_SET_FOLD(o, v) (PyDateTime_TIME_GET_FOLD(o) = (v))

#define GET_TD_DAYS(o) (((PyDateTime_Delta *)(o))->days)

#define GET_TD_SECONDS(o) (((PyDateTime_Delta *)(o))->seconds)

#define GET_TD_MICROSECONDS(o) (((PyDateTime_Delta *)(o))->microseconds)

#define SET_TD_DAYS(o, v) ((o)->days = (v))

#define SET_TD_SECONDS(o, v) ((o)->seconds = (v))

#define SET_TD_MICROSECONDS(o, v) ((o)->microseconds = (v))

#define HASTZINFO _PyDateTime_HAS_TZINFO

#define GET_TIME_TZINFO PyDateTime_TIME_GET_TZINFO

#define GET_DT_TZINFO PyDateTime_DATE_GET_TZINFO

#define MONTH_IS_SANE(M) ((unsigned int)(M) - 1 < 12)

static int check_tzinfo_subclass(PyObject *p);

#include "clinic/_datetimemodule.c.h"

#define SIGNED_ADD_OVERFLOWED(RESULT, I, J) \

((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0)

static int

divmod(int x, int y, int *r)

{

int quo;

assert(y > 0);

quo = x / y;

*r = x - quo * y;

if (*r < 0) {

--quo;

*r += y;

}

assert(0 <= *r && *r < y);

return quo;

}

static PyObject *

divide_nearest(PyObject *m, PyObject *n)

{

PyObject *result;

PyObject *temp;

temp = _PyLong_DivmodNear(m, n);

if (temp == NULL)

return NULL;

result = Py_NewRef(PyTuple_GET_ITEM(temp, 0));

Py_DECREF(temp);

return result;

}

static const int _days_in_month[] = {

0, /* unused; this vector uses 1-based indexing */

31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31

};

static const int _days_before_month[] = {

0, /* unused; this vector uses 1-based indexing */

0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334

};

static int

is_leap(int year)

{

/* Cast year to unsigned. The result is the same either way, but

const unsigned int ayear = (unsigned int)year;

return ayear % 4 == 0 && (ayear % 100 != 0 || ayear % 400 == 0);

}

static int

days_in_month(int year, int month)

{

assert(month >= 1);

assert(month <= 12);

if (month == 2 && is_leap(year))

return 29;

else

return _days_in_month[month];

}

static int

days_before_month(int year, int month)

{

int days;

assert(month >= 1);

assert(month <= 12);

days = _days_before_month[month];

if (month > 2 && is_leap(year))

++days;

return days;

}

static int

days_before_year(int year)

{

int y = year - 1;

/* This is incorrect if year <= 0; we really want the floor

assert (year >= 1);

return y*365 + y/4 - y/100 + y/400;

}

#define DI4Y 1461 /* days_before_year(5); days in 4 years */

#define DI100Y 36524 /* days_before_year(101); days in 100 years */

#define DI400Y 146097 /* days_before_year(401); days in 400 years */

static void

ord_to_ymd(int ordinal, int *year, int *month, int *day)

{

int n, n1, n4, n100, n400, leapyear, preceding;

/* ordinal is a 1-based index, starting at 1-Jan-1. The pattern of

assert(ordinal >= 1);

--ordinal;

n400 = ordinal / DI400Y;

n = ordinal % DI400Y;

*year = n400 * 400 + 1;

/* Now n is the (non-negative) offset, in days, from January 1 of

n100 = n / DI100Y;

n = n % DI100Y;

/* Now compute how many 4-year cycles precede it. */

n4 = n / DI4Y;

n = n % DI4Y;

/* And now how many single years. Again n1 can be 4, and again

n1 = n / 365;

n = n % 365;

*year += n100 * 100 + n4 * 4 + n1;

if (n1 == 4 || n100 == 4) {

assert(n == 0);

*year -= 1;

*month = 12;

*day = 31;

return;

}

/* Now the year is correct, and n is the offset from January 1. We

leapyear = n1 == 3 && (n4 != 24 || n100 == 3);

assert(leapyear == is_leap(*year));

*month = (n + 50) >> 5;

preceding = (_days_before_month[*month] + (*month > 2 && leapyear));

if (preceding > n) {

/* estimate is too large */

*month -= 1;

preceding -= days_in_month(*year, *month);

}

n -= preceding;

assert(0 <= n);

assert(n < days_in_month(*year, *month));

*day = n + 1;

}

static int

ymd_to_ord(int year, int month, int day)

{

return days_before_year(year) + days_before_month(year, month) + day;

}

static int

weekday(int year, int month, int day)

{

return (ymd_to_ord(year, month, day) + 6) % 7;

}

static int

iso_week1_monday(int year)

{

int first_day = ymd_to_ord(year, 1, 1); /* ord of 1/1 */

/* 0 if 1/1 is a Monday, 1 if a Tue, etc. */

int first_weekday = (first_day + 6) % 7;

/* ordinal of closest Monday at or before 1/1 */

int week1_monday = first_day - first_weekday;

if (first_weekday > 3) /* if 1/1 was Fri, Sat, Sun */

week1_monday += 7;

return week1_monday;

}

static int

iso_to_ymd(const int iso_year, const int iso_week, const int iso_day,

int *year, int *month, int *day) {

// Year is bounded to 0 < year < 10000 because 9999-12-31 is (9999, 52, 5)

if (iso_year < MINYEAR || iso_year > MAXYEAR) {

return -4;

}

if (iso_week <= 0 || iso_week >= 53) {

int out_of_range = 1;

if (iso_week == 53) {

// ISO years have 53 weeks in it on years starting with a Thursday

// and on leap years starting on Wednesday

int first_weekday = weekday(iso_year, 1, 1);

if (first_weekday == 3 || (first_weekday == 2 && is_leap(iso_year))) {

out_of_range = 0;

}

}

if (out_of_range) {

return -2;

}

}

if (iso_day <= 0 || iso_day >= 8) {

return -3;

}

// Convert (Y, W, D) to (Y, M, D) in-place

int day_1 = iso_week1_monday(iso_year);

int day_offset = (iso_week - 1)*7 + iso_day - 1;

ord_to_ymd(day_1 + day_offset, year, month, day);

return 0;

}

static int

check_delta_day_range(int days)

{

if (-MAX_DELTA_DAYS <= days && days <= MAX_DELTA_DAYS)

return 0;

PyErr_Format(PyExc_OverflowError,

"days=%d; must have magnitude <= %d",

days, MAX_DELTA_DAYS);

return -1;

}

static int

check_date_args(int year, int month, int day)

{

if (year < MINYEAR || year > MAXYEAR) {

PyErr_Format(PyExc_ValueError, "year %i is out of range", year);

return -1;

}

if (month < 1 || month > 12) {

PyErr_SetString(PyExc_ValueError,

"month must be in 1..12");

return -1;

}

if (day < 1 || day > days_in_month(year, month)) {

PyErr_SetString(PyExc_ValueError,

"day is out of range for month");

return -1;

}

return 0;

}

static int

check_time_args(int h, int m, int s, int us, int fold)

{

if (h < 0 || h > 23) {

PyErr_SetString(PyExc_ValueError,

"hour must be in 0..23");

return -1;

}

if (m < 0 || m > 59) {

PyErr_SetString(PyExc_ValueError,

"minute must be in 0..59");

return -1;

}

if (s < 0 || s > 59) {

PyErr_SetString(PyExc_ValueError,

"second must be in 0..59");

return -1;

}

if (us < 0 || us > 999999) {

PyErr_SetString(PyExc_ValueError,

"microsecond must be in 0..999999");

return -1;

}

if (fold != 0 && fold != 1) {

PyErr_SetString(PyExc_ValueError,

"fold must be either 0 or 1");

return -1;

}

return 0;

}

static void

normalize_pair(int *hi, int *lo, int factor)

{

assert(factor > 0);

assert(lo != hi);

if (*lo < 0 || *lo >= factor) {

const int num_hi = divmod(*lo, factor, lo);

const int new_hi = *hi + num_hi;

assert(! SIGNED_ADD_OVERFLOWED(new_hi, *hi, num_hi));

*hi = new_hi;

}

assert(0 <= *lo && *lo < factor);

}

static void

normalize_d_s_us(int *d, int *s, int *us)

{

if (*us < 0 || *us >= 1000000) {

normalize_pair(s, us, 1000000);

/* |s| can't be bigger than about

}

if (*s < 0 || *s >= 24*3600) {

normalize_pair(d, s, 24*3600);

/* |d| can't be bigger than about

}

assert(0 <= *s && *s < 24*3600);

assert(0 <= *us && *us < 1000000);

}

static int

normalize_y_m_d(int *y, int *m, int *d)

{

int dim; /* # of days in month */

/* In actual use, m is always the month component extracted from a

assert(1 <= *m && *m <= 12);

/* Now only day can be out of bounds (year may also be out of bounds

dim = days_in_month(*y, *m);

if (*d < 1 || *d > dim) {

/* Move day-1 days from the first of the month. First try to

if (*d == 0) {

--*m;

if (*m > 0)

*d = days_in_month(*y, *m);

else {

--*y;

*m = 12;

*d = 31;

}

}

else if (*d == dim + 1) {

/* move forward a day */

++*m;

*d = 1;

if (*m > 12) {

*m = 1;

++*y;

}

}

else {

int ordinal = ymd_to_ord(*y, *m, 1) +

*d - 1;

if (ordinal < 1 || ordinal > MAXORDINAL) {

goto error;

} else {

ord_to_ymd(ordinal, y, m, d);

return 0;

}

}

}

assert(*m > 0);

assert(*d > 0);

if (MINYEAR <= *y && *y <= MAXYEAR)

return 0;

error:

PyErr_SetString(PyExc_OverflowError,

"date value out of range");

return -1;

}

static int

normalize_date(int *year, int *month, int *day)

{

return normalize_y_m_d(year, month, day);

}

static int

normalize_datetime(int *year, int *month, int *day,

int *hour, int *minute, int *second,

int *microsecond)

{

normalize_pair(second, microsecond, 1000000);

normalize_pair(minute, second, 60);

normalize_pair(hour, minute, 60);

normalize_pair(day, hour, 24);

return normalize_date(year, month, day);

}

static PyObject *

time_alloc(PyTypeObject *type, Py_ssize_t aware)

{

size_t size = aware ? sizeof(PyDateTime_Time) : sizeof(_PyDateTime_BaseTime);

PyObject *self = (PyObject *)PyObject_Malloc(size);

if (self == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init(self, type);

return self;

}

static PyObject *

datetime_alloc(PyTypeObject *type, Py_ssize_t aware)

{

size_t size = aware ? sizeof(PyDateTime_DateTime) : sizeof(_PyDateTime_BaseDateTime);

PyObject *self = (PyObject *)PyObject_Malloc(size);

if (self == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init(self, type);

return self;

}

static void

set_date_fields(PyDateTime_Date *self, int y, int m, int d)

{

self->hashcode = -1;

SET_YEAR(self, y);

SET_MONTH(self, m);

SET_DAY(self, d);

}

static unsigned char

is_digit(const char c) {

return ((unsigned int)(c - '0')) < 10;

}

static const char *

parse_digits(const char *ptr, int *var, size_t num_digits)

{

for (size_t i = 0; i < num_digits; ++i) {

unsigned int tmp = (unsigned int)(*(ptr++) - '0');

if (tmp > 9) {

return NULL;

}

*var *= 10;

*var += (signed int)tmp;

}

return ptr;

}

static int

parse_isoformat_date(const char *dtstr, const size_t len, int *year, int *month, int *day)

{

/* Parse the date components of the result of date.isoformat()

const char *p = dtstr;

p = parse_digits(p, year, 4);

if (NULL == p) {

return -1;

}

const unsigned char uses_separator = (*p == '-');

if (uses_separator) {

++p;

}

if(*p == 'W') {

// This is an isocalendar-style date string

p++;

int iso_week = 0;

int iso_day = 0;

p = parse_digits(p, &iso_week, 2);

if (NULL == p) {

return -3;

}

assert(p > dtstr);

if ((size_t)(p - dtstr) < len) {

if (uses_separator && *(p++) != '-') {

return -2;

}

p = parse_digits(p, &iso_day, 1);

if (NULL == p) {

return -4;

}

} else {

iso_day = 1;

}

int rv = iso_to_ymd(*year, iso_week, iso_day, year, month, day);

if (rv) {

return -3 + rv;

} else {

return 0;

}

}

p = parse_digits(p, month, 2);

if (NULL == p) {

return -1;

}

if (uses_separator && *(p++) != '-') {

return -2;

}

p = parse_digits(p, day, 2);

if (p == NULL) {

return -1;

}

return 0;

}

static int

parse_hh_mm_ss_ff(const char *tstr, const char *tstr_end, int *hour,

int *minute, int *second, int *microsecond)

{

*hour = *minute = *second = *microsecond = 0;

const char *p = tstr;

const char *p_end = tstr_end;

int *vals[3] = {hour, minute, second};