#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

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

#include "structmember.h"

#include <ctype.h>

#include <stddef.h>

#include <stdint.h>

#include "datetime.h"

#include "clinic/_zoneinfo.c.h"

typedef struct TransitionRuleType TransitionRuleType;

typedef struct StrongCacheNode StrongCacheNode;

typedef struct {

PyObject *utcoff;

PyObject *dstoff;

PyObject *tzname;

long utcoff_seconds;

} _ttinfo;

typedef struct {

_ttinfo std;

_ttinfo dst;

int dst_diff;

TransitionRuleType *start;

TransitionRuleType *end;

unsigned char std_only;

} _tzrule;

typedef struct {

PyDateTime_TZInfo base;

PyObject *key;

PyObject *file_repr;

PyObject *weakreflist;

size_t num_transitions;

size_t num_ttinfos;

int64_t *trans_list_utc;

int64_t *trans_list_wall[2];

_ttinfo **trans_ttinfos; // References to the ttinfo for each transition

_ttinfo *ttinfo_before;

_tzrule tzrule_after;

_ttinfo *_ttinfos; // Unique array of ttinfos for ease of deallocation

unsigned char fixed_offset;

unsigned char source;

} PyZoneInfo_ZoneInfo;

struct TransitionRuleType {

int64_t (*year_to_timestamp)(TransitionRuleType *, int);

};

typedef struct {

TransitionRuleType base;

uint8_t month;

uint8_t week;

uint8_t day;

int8_t hour;

int8_t minute;

int8_t second;

} CalendarRule;

typedef struct {

TransitionRuleType base;

uint8_t julian;

unsigned int day;

int8_t hour;

int8_t minute;

int8_t second;

} DayRule;

struct StrongCacheNode {

};

typedef struct {

PyTypeObject *ZoneInfoType;

// Imports

PyObject *io_open;

PyObject *_tzpath_find_tzfile;

PyObject *_common_mod;

// Caches

PyObject *TIMEDELTA_CACHE;

PyObject *ZONEINFO_WEAK_CACHE;

StrongCacheNode *ZONEINFO_STRONG_CACHE;

_ttinfo NO_TTINFO;

} zoneinfo_state;

static const int EPOCHORDINAL = 719163;

static int DAYS_IN_MONTH[] = {

-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,

};

static int DAYS_BEFORE_MONTH[] = {

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

};

static const int SOURCE_NOCACHE = 0;

static const int SOURCE_CACHE = 1;

static const int SOURCE_FILE = 2;

static const size_t ZONEINFO_STRONG_CACHE_MAX_SIZE = 8;

static int

load_data(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self,

PyObject *file_obj);

static void

utcoff_to_dstoff(size_t *trans_idx, long *utcoffs, long *dstoffs,

unsigned char *isdsts, size_t num_transitions,

size_t num_ttinfos);

static int

ts_to_local(size_t *trans_idx, int64_t *trans_utc, long *utcoff,

int64_t *trans_local[2], size_t num_ttinfos,

size_t num_transitions);

static int

parse_tz_str(zoneinfo_state *state, PyObject *tz_str_obj, _tzrule *out);

static Py_ssize_t

parse_abbr(const char *const p, PyObject **abbr);

static Py_ssize_t

parse_tz_delta(const char *const p, long *total_seconds);

static Py_ssize_t

parse_transition_time(const char *const p, int8_t *hour, int8_t *minute,

int8_t *second);

static Py_ssize_t

parse_transition_rule(const char *const p, TransitionRuleType **out);

static _ttinfo *

find_tzrule_ttinfo(_tzrule *rule, int64_t ts, unsigned char fold, int year);

static _ttinfo *

find_tzrule_ttinfo_fromutc(_tzrule *rule, int64_t ts, int year,

unsigned char *fold);

static int

build_ttinfo(zoneinfo_state *state, long utcoffset, long dstoffset,

PyObject *tzname, _ttinfo *out);

static void

xdecref_ttinfo(_ttinfo *ttinfo);

static int

ttinfo_eq(const _ttinfo *const tti0, const _ttinfo *const tti1);

static int

build_tzrule(zoneinfo_state *state, PyObject *std_abbr, PyObject *dst_abbr,

long std_offset, long dst_offset, TransitionRuleType *start,

TransitionRuleType *end, _tzrule *out);

static void

free_tzrule(_tzrule *tzrule);

static PyObject *

load_timedelta(zoneinfo_state *state, long seconds);

static int

get_local_timestamp(PyObject *dt, int64_t *local_ts);

static _ttinfo *

find_ttinfo(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *dt);

static int

ymd_to_ord(int y, int m, int d);

static int

is_leap_year(int year);

static size_t

_bisect(const int64_t value, const int64_t *arr, size_t size);

static int

eject_from_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,

PyObject *key);

static void

clear_strong_cache(zoneinfo_state *state, const PyTypeObject *const type);

static void

update_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,

PyObject *key, PyObject *zone);

static PyObject *

zone_from_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,

PyObject *const key);

static inline zoneinfo_state *

zoneinfo_get_state(PyObject *mod)

{

zoneinfo_state *state = (zoneinfo_state *)PyModule_GetState(mod);

assert(state != NULL);

return state;

}

static inline zoneinfo_state *

zoneinfo_get_state_by_cls(PyTypeObject *cls)

{

zoneinfo_state *state = (zoneinfo_state *)PyType_GetModuleState(cls);

assert(state != NULL);

return state;

}

static struct PyModuleDef zoneinfomodule;

static inline zoneinfo_state *

zoneinfo_get_state_by_self(PyTypeObject *self)

{

PyObject *mod = PyType_GetModuleByDef(self, &zoneinfomodule);

assert(mod != NULL);

return zoneinfo_get_state(mod);

}

static PyObject *

zoneinfo_new_instance(zoneinfo_state *state, PyTypeObject *type, PyObject *key)

{

PyObject *file_obj = NULL;

PyObject *file_path = NULL;

file_path = PyObject_CallFunctionObjArgs(state->_tzpath_find_tzfile,

key, NULL);

if (file_path == NULL) {

return NULL;

}

else if (file_path == Py_None) {

PyObject *meth = state->_common_mod;

file_obj = PyObject_CallMethod(meth, "load_tzdata", "O", key);

if (file_obj == NULL) {

Py_DECREF(file_path);

return NULL;

}

}

PyObject *self = (PyObject *)(type->tp_alloc(type, 0));

if (self == NULL) {

goto error;

}

if (file_obj == NULL) {

PyObject *func = state->io_open;

file_obj = PyObject_CallFunction(func, "Os", file_path, "rb");

if (file_obj == NULL) {

goto error;

}

}

if (load_data(state, (PyZoneInfo_ZoneInfo *)self, file_obj)) {

goto error;

}

PyObject *rv = PyObject_CallMethod(file_obj, "close", NULL);

Py_SETREF(file_obj, NULL);

if (rv == NULL) {

goto error;

}

Py_DECREF(rv);

((PyZoneInfo_ZoneInfo *)self)->key = Py_NewRef(key);

goto cleanup;

error:

Py_CLEAR(self);

cleanup:

if (file_obj != NULL) {

PyObject *exc, *val, *tb;

PyErr_Fetch(&exc, &val, &tb);

PyObject *tmp = PyObject_CallMethod(file_obj, "close", NULL);

_PyErr_ChainExceptions(exc, val, tb);

if (tmp == NULL) {

Py_CLEAR(self);

}

Py_XDECREF(tmp);

Py_DECREF(file_obj);

}

Py_DECREF(file_path);

return self;

}

static PyObject *

get_weak_cache(zoneinfo_state *state, PyTypeObject *type)

{

if (type == state->ZoneInfoType) {

return state->ZONEINFO_WEAK_CACHE;

}

else {

PyObject *cache =

PyObject_GetAttrString((PyObject *)type, "_weak_cache");

// We are assuming that the type lives at least as long as the function

// that calls get_weak_cache, and that it holds a reference to the

// cache, so we'll return a "borrowed reference".

Py_XDECREF(cache);

return cache;

}

}

static PyObject *

zoneinfo_new(PyTypeObject *type, PyObject *args, PyObject *kw)

{

PyObject *key = NULL;

static char *kwlist[] = {"key", NULL};

if (PyArg_ParseTupleAndKeywords(args, kw, "O", kwlist, &key) == 0) {

return NULL;

}

zoneinfo_state *state = zoneinfo_get_state_by_self(type);

PyObject *instance = zone_from_strong_cache(state, type, key);

if (instance != NULL || PyErr_Occurred()) {

return instance;

}

PyObject *weak_cache = get_weak_cache(state, type);

instance = PyObject_CallMethod(weak_cache, "get", "O", key, Py_None);

if (instance == NULL) {

return NULL;

}

if (instance == Py_None) {

Py_DECREF(instance);

PyObject *tmp = zoneinfo_new_instance(state, type, key);

if (tmp == NULL) {

return NULL;

}

instance =

PyObject_CallMethod(weak_cache, "setdefault", "OO", key, tmp);

Py_DECREF(tmp);

if (instance == NULL) {

return NULL;

}

((PyZoneInfo_ZoneInfo *)instance)->source = SOURCE_CACHE;

}

update_strong_cache(state, type, key, instance);

return instance;

}

static int

zoneinfo_traverse(PyZoneInfo_ZoneInfo *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->key);

return 0;

}

static int

zoneinfo_clear(PyZoneInfo_ZoneInfo *self)

{

Py_CLEAR(self->key);

Py_CLEAR(self->file_repr);

return 0;

}

static void

zoneinfo_dealloc(PyObject *obj_self)

{

PyZoneInfo_ZoneInfo *self = (PyZoneInfo_ZoneInfo *)obj_self;

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(self);

if (self->weakreflist != NULL) {

PyObject_ClearWeakRefs(obj_self);

}

if (self->trans_list_utc != NULL) {

PyMem_Free(self->trans_list_utc);

}

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

if (self->trans_list_wall[i] != NULL) {

PyMem_Free(self->trans_list_wall[i]);

}

}

if (self->_ttinfos != NULL) {

for (size_t i = 0; i < self->num_ttinfos; ++i) {

xdecref_ttinfo(&(self->_ttinfos[i]));

}

PyMem_Free(self->_ttinfos);

}

if (self->trans_ttinfos != NULL) {

PyMem_Free(self->trans_ttinfos);

}

free_tzrule(&(self->tzrule_after));

zoneinfo_clear(self);

tp->tp_free(obj_self);

Py_DECREF(tp);

}

static PyObject *

zoneinfo_ZoneInfo_from_file_impl(PyTypeObject *type, PyTypeObject *cls,

PyObject *file_obj, PyObject *key)

{

PyObject *file_repr = NULL;

PyZoneInfo_ZoneInfo *self = NULL;

PyObject *obj_self = (PyObject *)(type->tp_alloc(type, 0));

self = (PyZoneInfo_ZoneInfo *)obj_self;

if (self == NULL) {

return NULL;

}

file_repr = PyUnicode_FromFormat("%R", file_obj);

if (file_repr == NULL) {

goto error;

}

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

if (load_data(state, self, file_obj)) {

goto error;

}

self->source = SOURCE_FILE;

self->file_repr = file_repr;

self->key = Py_NewRef(key);

return obj_self;

error:

Py_XDECREF(file_repr);

Py_XDECREF(self);

return NULL;

}

static PyObject *

zoneinfo_ZoneInfo_no_cache_impl(PyTypeObject *type, PyTypeObject *cls,

PyObject *key)

{

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

PyObject *out = zoneinfo_new_instance(state, type, key);

if (out != NULL) {

((PyZoneInfo_ZoneInfo *)out)->source = SOURCE_NOCACHE;

}

return out;

}

static PyObject *

zoneinfo_ZoneInfo_clear_cache_impl(PyTypeObject *type, PyTypeObject *cls,

PyObject *only_keys)

{

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

PyObject *weak_cache = get_weak_cache(state, type);

if (only_keys == NULL || only_keys == Py_None) {

PyObject *rv = PyObject_CallMethod(weak_cache, "clear", NULL);

if (rv != NULL) {

Py_DECREF(rv);

}

clear_strong_cache(state, type);

}

else {

PyObject *item = NULL;

PyObject *pop = PyUnicode_FromString("pop");

if (pop == NULL) {

return NULL;

}

PyObject *iter = PyObject_GetIter(only_keys);

if (iter == NULL) {

Py_DECREF(pop);

return NULL;

}

while ((item = PyIter_Next(iter))) {

// Remove from strong cache

if (eject_from_strong_cache(state, type, item) < 0) {

Py_DECREF(item);

break;

}

// Remove from weak cache

PyObject *tmp = PyObject_CallMethodObjArgs(weak_cache, pop, item,

Py_None, NULL);

Py_DECREF(item);

if (tmp == NULL) {

break;

}

Py_DECREF(tmp);

}

Py_DECREF(iter);

Py_DECREF(pop);

}

if (PyErr_Occurred()) {

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

zoneinfo_ZoneInfo_utcoffset_impl(PyObject *self, PyTypeObject *cls,

PyObject *dt)

{

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

_ttinfo *tti = find_ttinfo(state, (PyZoneInfo_ZoneInfo *)self, dt);

if (tti == NULL) {

return NULL;

}

return Py_NewRef(tti->utcoff);

}

static PyObject *

zoneinfo_ZoneInfo_dst_impl(PyObject *self, PyTypeObject *cls, PyObject *dt)

{

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

_ttinfo *tti = find_ttinfo(state, (PyZoneInfo_ZoneInfo *)self, dt);

if (tti == NULL) {

return NULL;

}

return Py_NewRef(tti->dstoff);

}

static PyObject *

zoneinfo_ZoneInfo_tzname_impl(PyObject *self, PyTypeObject *cls,

PyObject *dt)

{

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

_ttinfo *tti = find_ttinfo(state, (PyZoneInfo_ZoneInfo *)self, dt);

if (tti == NULL) {

return NULL;

}

return Py_NewRef(tti->tzname);

}

#define GET_DT_TZINFO PyDateTime_DATE_GET_TZINFO

static PyObject *

zoneinfo_fromutc(PyObject *obj_self, PyObject *dt)

{

if (!PyDateTime_Check(dt)) {

PyErr_SetString(PyExc_TypeError,

"fromutc: argument must be a datetime");

return NULL;

}

if (GET_DT_TZINFO(dt) != obj_self) {

PyErr_SetString(PyExc_ValueError,

"fromutc: dt.tzinfo "

"is not self");

return NULL;

}

PyZoneInfo_ZoneInfo *self = (PyZoneInfo_ZoneInfo *)obj_self;

int64_t timestamp;

if (get_local_timestamp(dt, &timestamp)) {

return NULL;

}

size_t num_trans = self->num_transitions;

_ttinfo *tti = NULL;

unsigned char fold = 0;

if (num_trans >= 1 && timestamp < self->trans_list_utc[0]) {

tti = self->ttinfo_before;

}

else if (num_trans == 0 ||

timestamp > self->trans_list_utc[num_trans - 1]) {

tti = find_tzrule_ttinfo_fromutc(&(self->tzrule_after), timestamp,

PyDateTime_GET_YEAR(dt), &fold);

// Immediately after the last manual transition, the fold/gap is

// between self->trans_ttinfos[num_transitions - 1] and whatever

// ttinfo applies immediately after the last transition, not between

// the STD and DST rules in the tzrule_after, so we may need to

// adjust the fold value.

if (num_trans) {

_ttinfo *tti_prev = NULL;

if (num_trans == 1) {

tti_prev = self->ttinfo_before;

}

else {

tti_prev = self->trans_ttinfos[num_trans - 2];

}

int64_t diff = tti_prev->utcoff_seconds - tti->utcoff_seconds;

if (diff > 0 &&

timestamp < (self->trans_list_utc[num_trans - 1] + diff)) {

fold = 1;

}

}

}

else {

size_t idx = _bisect(timestamp, self->trans_list_utc, num_trans);

_ttinfo *tti_prev = NULL;

if (idx >= 2) {

tti_prev = self->trans_ttinfos[idx - 2];

tti = self->trans_ttinfos[idx - 1];

}

else {

tti_prev = self->ttinfo_before;

tti = self->trans_ttinfos[0];

}

// Detect fold

int64_t shift =

(int64_t)(tti_prev->utcoff_seconds - tti->utcoff_seconds);

if (shift > (timestamp - self->trans_list_utc[idx - 1])) {

fold = 1;

}

}

PyObject *tmp = PyNumber_Add(dt, tti->utcoff);

if (tmp == NULL) {

return NULL;

}

if (fold) {

if (PyDateTime_CheckExact(tmp)) {

((PyDateTime_DateTime *)tmp)->fold = 1;

dt = tmp;

}

else {

PyObject *replace = PyObject_GetAttrString(tmp, "replace");

PyObject *args = PyTuple_New(0);

PyObject *kwargs = PyDict_New();

Py_DECREF(tmp);

if (args == NULL || kwargs == NULL || replace == NULL) {

Py_XDECREF(args);

Py_XDECREF(kwargs);

Py_XDECREF(replace);

return NULL;

}

dt = NULL;

if (!PyDict_SetItemString(kwargs, "fold", _PyLong_GetOne())) {

dt = PyObject_Call(replace, args, kwargs);

}

Py_DECREF(args);

Py_DECREF(kwargs);

Py_DECREF(replace);

if (dt == NULL) {

return NULL;

}

}

}

else {

dt = tmp;

}

return dt;

}

static PyObject *

zoneinfo_repr(PyZoneInfo_ZoneInfo *self)

{

PyObject *rv = NULL;

const char *type_name = Py_TYPE((PyObject *)self)->tp_name;

if (!(self->key == Py_None)) {

rv = PyUnicode_FromFormat("%s(key=%R)", type_name, self->key);

}

else {

assert(PyUnicode_Check(self->file_repr));

rv = PyUnicode_FromFormat("%s.from_file(%U)", type_name,

self->file_repr);

}

return rv;

}

static PyObject *

zoneinfo_str(PyZoneInfo_ZoneInfo *self)

{

if (!(self->key == Py_None)) {

return Py_NewRef(self->key);

}

else {

return zoneinfo_repr(self);

}

}

static PyObject *

zoneinfo_reduce(PyObject *obj_self, PyObject *unused)

{

PyZoneInfo_ZoneInfo *self = (PyZoneInfo_ZoneInfo *)obj_self;

if (self->source == SOURCE_FILE) {

// Objects constructed from files cannot be pickled.

PyObject *pickle_error =

_PyImport_GetModuleAttrString("pickle", "PicklingError");

if (pickle_error == NULL) {

return NULL;

}

PyErr_Format(pickle_error,

"Cannot pickle a ZoneInfo file from a file stream.");

Py_DECREF(pickle_error);

return NULL;

}

unsigned char from_cache = self->source == SOURCE_CACHE ? 1 : 0;

PyObject *constructor = PyObject_GetAttrString(obj_self, "_unpickle");

if (constructor == NULL) {

return NULL;

}

PyObject *rv = Py_BuildValue("O(OB)", constructor, self->key, from_cache);

Py_DECREF(constructor);

return rv;

}

static PyObject *

zoneinfo_ZoneInfo__unpickle_impl(PyTypeObject *type, PyTypeObject *cls,

PyObject *key, unsigned char from_cache)

{

if (from_cache) {

PyObject *val_args = Py_BuildValue("(O)", key);

if (val_args == NULL) {

return NULL;

}

PyObject *rv = zoneinfo_new(type, val_args, NULL);

Py_DECREF(val_args);

return rv;

}

else {

zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);

return zoneinfo_new_instance(state, type, key);

}

}

static PyObject *

load_timedelta(zoneinfo_state *state, long seconds)

{

PyObject *rv;

PyObject *pyoffset = PyLong_FromLong(seconds);

if (pyoffset == NULL) {

return NULL;

}

rv = PyDict_GetItemWithError(state->TIMEDELTA_CACHE, pyoffset);

if (rv == NULL) {

if (PyErr_Occurred()) {

goto error;

}

PyObject *tmp = PyDateTimeAPI->Delta_FromDelta(

0, seconds, 0, 1, PyDateTimeAPI->DeltaType);

if (tmp == NULL) {

goto error;

}

rv = PyDict_SetDefault(state->TIMEDELTA_CACHE, pyoffset, tmp);

Py_DECREF(tmp);

}

Py_XINCREF(rv);

Py_DECREF(pyoffset);

return rv;

error:

Py_DECREF(pyoffset);

return NULL;

}

static int

build_ttinfo(zoneinfo_state *state, long utcoffset, long dstoffset,

PyObject *tzname, _ttinfo *out)

{

out->utcoff = NULL;

out->dstoff = NULL;

out->tzname = NULL;

out->utcoff_seconds = utcoffset;

out->utcoff = load_timedelta(state, utcoffset);

if (out->utcoff == NULL) {

return -1;

}

out->dstoff = load_timedelta(state, dstoffset);

if (out->dstoff == NULL) {

return -1;

}

out->tzname = Py_NewRef(tzname);

return 0;

}

static void

xdecref_ttinfo(_ttinfo *ttinfo)

{

if (ttinfo != NULL) {

Py_XDECREF(ttinfo->utcoff);

Py_XDECREF(ttinfo->dstoff);

Py_XDECREF(ttinfo->tzname);

}

}

static int

ttinfo_eq(const _ttinfo *const tti0, const _ttinfo *const tti1)

{

int rv;

if ((rv = PyObject_RichCompareBool(tti0->utcoff, tti1->utcoff, Py_EQ)) <

1) {

goto end;

}

if ((rv = PyObject_RichCompareBool(tti0->dstoff, tti1->dstoff, Py_EQ)) <

1) {

goto end;

}

if ((rv = PyObject_RichCompareBool(tti0->tzname, tti1->tzname, Py_EQ)) <

1) {

goto end;

}

end:

return rv;

}

static int

load_data(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *file_obj)

{

PyObject *data_tuple = NULL;

long *utcoff = NULL;

long *dstoff = NULL;

size_t *trans_idx = NULL;

unsigned char *isdst = NULL;

self->trans_list_utc = NULL;

self->trans_list_wall[0] = NULL;

self->trans_list_wall[1] = NULL;

self->trans_ttinfos = NULL;

self->_ttinfos = NULL;

self->file_repr = NULL;

size_t ttinfos_allocated = 0;

data_tuple = PyObject_CallMethod(state->_common_mod, "load_data", "O",

file_obj);

if (data_tuple == NULL) {

goto error;

}

if (!PyTuple_CheckExact(data_tuple)) {

PyErr_Format(PyExc_TypeError, "Invalid data result type: %r",

data_tuple);

goto error;

}

// Unpack the data tuple

PyObject *trans_idx_list = PyTuple_GetItem(data_tuple, 0);

if (trans_idx_list == NULL) {

goto error;

}

PyObject *trans_utc = PyTuple_GetItem(data_tuple, 1);

if (trans_utc == NULL) {

goto error;

}

PyObject *utcoff_list = PyTuple_GetItem(data_tuple, 2);

if (utcoff_list == NULL) {

goto error;

}

PyObject *isdst_list = PyTuple_GetItem(data_tuple, 3);

if (isdst_list == NULL) {