#include "Python.h"

#include "structmember.h"

#include <ctype.h>

#include <stddef.h>

#include <stdint.h>

#include "datetime.h"

// Imports

static PyObject *io_open = NULL;

static PyObject *_tzpath_find_tzfile = NULL;

static PyObject *_common_mod = NULL;

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 {

StrongCacheNode *next;

StrongCacheNode *prev;

PyObject *key;

PyObject *zone;

};

static PyTypeObject PyZoneInfo_ZoneInfoType;

// Globals

static PyObject *TIMEDELTA_CACHE = NULL;

static PyObject *ZONEINFO_WEAK_CACHE = NULL;

static StrongCacheNode *ZONEINFO_STRONG_CACHE = NULL;

static size_t ZONEINFO_STRONG_CACHE_MAX_SIZE = 8;

static _ttinfo NO_TTINFO = {NULL, NULL, NULL, 0};

// Constants

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;

// Forward declarations

static int

load_data(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(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(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(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(long seconds);

static int

get_local_timestamp(PyObject *dt, int64_t *local_ts);

static _ttinfo *

find_ttinfo(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 void

eject_from_strong_cache(const PyTypeObject *const type, PyObject *key);

static void

clear_strong_cache(const PyTypeObject *const type);

static void

update_strong_cache(const PyTypeObject *const type, PyObject *key,

PyObject *zone);

static PyObject *

zone_from_strong_cache(const PyTypeObject *const type, PyObject *key);

static PyObject *

zoneinfo_new_instance(PyTypeObject *type, PyObject *key)

{

PyObject *file_obj = NULL;

PyObject *file_path = NULL;

file_path = PyObject_CallFunctionObjArgs(_tzpath_find_tzfile, key, NULL);

if (file_path == NULL) {

return NULL;

}

else if (file_path == Py_None) {

file_obj = PyObject_CallMethod(_common_mod, "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) {

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

if (file_obj == NULL) {

goto error;

}

}

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

goto error;

}

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

Py_DECREF(file_obj);

file_obj = NULL;

if (rv == NULL) {

goto error;

}

Py_DECREF(rv);

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

Py_INCREF(key);

goto cleanup;

error:

Py_XDECREF(self);

self = NULL;

cleanup:

if (file_obj != NULL) {

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

Py_DECREF(tmp);

Py_DECREF(file_obj);

}

Py_DECREF(file_path);

return self;

}

static PyObject *

get_weak_cache(PyTypeObject *type)

{

if (type == &PyZoneInfo_ZoneInfoType) {

return 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;

}

PyObject *instance = zone_from_strong_cache(type, key);

if (instance != NULL) {

return instance;

}

PyObject *weak_cache = get_weak_cache(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(type, key);

if (tmp == NULL) {

return NULL;

}

instance =

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

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

Py_DECREF(tmp);

if (instance == NULL) {

return NULL;

}

}

update_strong_cache(type, key, instance);

return instance;

}

static void

zoneinfo_dealloc(PyObject *obj_self)

{

PyZoneInfo_ZoneInfo *self = (PyZoneInfo_ZoneInfo *)obj_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));

Py_XDECREF(self->key);

Py_XDECREF(self->file_repr);

Py_TYPE(self)->tp_free((PyObject *)self);

}

static PyObject *

zoneinfo_from_file(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

PyObject *file_obj = NULL;

PyObject *file_repr = NULL;

PyObject *key = Py_None;

PyZoneInfo_ZoneInfo *self = NULL;

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

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", kwlist, &file_obj,

&key)) {

return 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;

}

if (load_data(self, file_obj)) {

goto error;

}

self->source = SOURCE_FILE;

self->file_repr = file_repr;

self->key = key;

Py_INCREF(key);

return obj_self;

error:

Py_XDECREF(file_repr);

Py_XDECREF(self);

return NULL;

}

static PyObject *

zoneinfo_no_cache(PyTypeObject *cls, PyObject *args, PyObject *kwargs)

{

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

PyObject *key = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", kwlist, &key)) {

return NULL;

}

PyObject *out = zoneinfo_new_instance(cls, key);

if (out != NULL) {

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

}

return out;

}

static PyObject *

zoneinfo_clear_cache(PyObject *cls, PyObject *args, PyObject *kwargs)

{

PyObject *only_keys = NULL;

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

if (!(PyArg_ParseTupleAndKeywords(args, kwargs, "|$O", kwlist,

&only_keys))) {

return NULL;

}

PyTypeObject *type = (PyTypeObject *)cls;

PyObject *weak_cache = get_weak_cache(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(type);

ZONEINFO_STRONG_CACHE = NULL;

}

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

eject_from_strong_cache(type, item);

// 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_utcoffset(PyObject *self, PyObject *dt)

{

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

if (tti == NULL) {

return NULL;

}

Py_INCREF(tti->utcoff);

return tti->utcoff;

}

static PyObject *

zoneinfo_dst(PyObject *self, PyObject *dt)

{

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

if (tti == NULL) {

return NULL;

}

Py_INCREF(tti->dstoff);

return tti->dstoff;

}

static PyObject *

zoneinfo_tzname(PyObject *self, PyObject *dt)

{

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

if (tti == NULL) {

return NULL;

}

Py_INCREF(tti->tzname);

return tti->tzname;

}

#define HASTZINFO(p) (((_PyDateTime_BaseTZInfo *)(p))->hastzinfo)

#define GET_DT_TZINFO(p) \

(HASTZINFO(p) ? ((PyDateTime_DateTime *)(p))->tzinfo : Py_None)

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_One)) {

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)) {

Py_INCREF(self->key);

return self->key;

}

else {

return zoneinfo_repr(self);

}

}

/* Pickles the ZoneInfo object by key and source.

*

* ZoneInfo objects are pickled by reference to the TZif file that they came

* from, which means that the exact transitions may be different or the file

* may not un-pickle if the data has changed on disk in the interim.

*

* It is necessary to include a bit indicating whether or not the object

* was constructed from the cache, because from-cache objects will hit the

* unpickling process's cache, whereas no-cache objects will bypass it.

*

* Objects constructed from ZoneInfo.from_file cannot be pickled.

*/

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 = PyImport_ImportModule("pickle");

if (pickle == NULL) {

return NULL;

}

PyObject *pickle_error =

PyObject_GetAttrString(pickle, "PicklingError");

Py_DECREF(pickle);

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__unpickle(PyTypeObject *cls, PyObject *args)

{

PyObject *key;

unsigned char from_cache;

if (!PyArg_ParseTuple(args, "OB", &key, &from_cache)) {

return NULL;

}

if (from_cache) {

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

if (val_args == NULL) {

return NULL;

}

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

Py_DECREF(val_args);

return rv;

}

else {

return zoneinfo_new_instance(cls, key);

}

}

/* It is relatively expensive to construct new timedelta objects, and in most

* cases we're looking at a relatively small number of timedeltas, such as

* integer number of hours, etc. We will keep a cache so that we construct

* a minimal number of these.

*

* Possibly this should be replaced with an LRU cache so that it's not possible

* for the memory usage to explode from this, but in order for this to be a

* serious problem, one would need to deliberately craft a malicious time zone

* file with many distinct offsets. As of tzdb 2019c, loading every single zone

* fills the cache with ~450 timedeltas for a total size of ~12kB.

*

* This returns a new reference to the timedelta.

*/

static PyObject *

load_timedelta(long seconds)

{

PyObject *rv = NULL;

PyObject *pyoffset = PyLong_FromLong(seconds);

if (pyoffset == NULL) {

return NULL;

}

int contains = PyDict_Contains(TIMEDELTA_CACHE, pyoffset);

if (contains == -1) {

goto error;

}

if (!contains) {

PyObject *tmp = PyDateTimeAPI->Delta_FromDelta(

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

if (tmp == NULL) {

goto error;

}

rv = PyDict_SetDefault(TIMEDELTA_CACHE, pyoffset, tmp);

Py_DECREF(tmp);

}

else {

rv = PyDict_GetItem(TIMEDELTA_CACHE, pyoffset);

}

Py_DECREF(pyoffset);

Py_INCREF(rv);

return rv;

error:

Py_DECREF(pyoffset);

return NULL;

}

/* Constructor for _ttinfo object - this starts by initializing the _ttinfo

* to { NULL, NULL, NULL }, so that Py_XDECREF will work on partially

* initialized _ttinfo objects.

*/

static int

build_ttinfo(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(utcoffset);

if (out->utcoff == NULL) {

return -1;

}

out->dstoff = load_timedelta(dstoffset);

if (out->dstoff == NULL) {

return -1;

}

out->tzname = tzname;

Py_INCREF(tzname);

return 0;

}

/* Decrease reference count on any non-NULL members of a _ttinfo */

static void

xdecref_ttinfo(_ttinfo *ttinfo)

{

if (ttinfo != NULL) {

Py_XDECREF(ttinfo->utcoff);

Py_XDECREF(ttinfo->dstoff);

Py_XDECREF(ttinfo->tzname);

}

}

/* Equality function for _ttinfo. */

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;

}

/* Given a file-like object, this populates a ZoneInfo object

*

* The current version calls into a Python function to read the data from

* file into Python objects, and this translates those Python objects into

* C values and calculates derived values (e.g. dstoff) in C.

*

* This returns 0 on success and -1 on failure.

*

* The function will never return while `self` is partially initialized —

* the object only needs to be freed / deallocated if this succeeds.

*/

static int

load_data(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(_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) {

goto error;

}

PyObject *abbr = PyTuple_GetItem(data_tuple, 4);

if (abbr == NULL) {

goto error;

}

PyObject *tz_str = PyTuple_GetItem(data_tuple, 5);

if (tz_str == NULL) {

goto error;

}

// Load the relevant sizes

Py_ssize_t num_transitions = PyTuple_Size(trans_utc);

if (num_transitions < 0) {

goto error;

}

Py_ssize_t num_ttinfos = PyTuple_Size(utcoff_list);

if (num_ttinfos < 0) {

goto error;

}

self->num_transitions = (size_t)num_transitions;

self->num_ttinfos = (size_t)num_ttinfos;

// Load the transition indices and list

self->trans_list_utc =

PyMem_Malloc(self->num_transitions * sizeof(int64_t));

trans_idx = PyMem_Malloc(self->num_transitions * sizeof(Py_ssize_t));

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

PyObject *num = PyTuple_GetItem(trans_utc, i);

if (num == NULL) {

goto error;

}

self->trans_list_utc[i] = PyLong_AsLongLong(num);

if (self->trans_list_utc[i] == -1 && PyErr_Occurred()) {

goto error;

}

num = PyTuple_GetItem(trans_idx_list, i);

if (num == NULL) {

goto error;

}

Py_ssize_t cur_trans_idx = PyLong_AsSsize_t(num);

if (cur_trans_idx == -1) {

goto error;

}

trans_idx[i] = (size_t)cur_trans_idx;

if (trans_idx[i] > self->num_ttinfos) {

PyErr_Format(

PyExc_ValueError,

"Invalid transition index found while reading TZif: %zd",

cur_trans_idx);

goto error;

}

}

// Load UTC offsets and isdst (size num_ttinfos)

utcoff = PyMem_Malloc(self->num_ttinfos * sizeof(long));

isdst = PyMem_Malloc(self->num_ttinfos * sizeof(unsigned char));

if (utcoff == NULL || isdst == NULL) {

goto error;

}

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

PyObject *num = PyTuple_GetItem(utcoff_list, i);

if (num == NULL) {

goto error;

}

utcoff[i] = PyLong_AsLong(num);

if (utcoff[i] == -1 && PyErr_Occurred()) {

goto error;

}

num = PyTuple_GetItem(isdst_list, i);

if (num == NULL) {

goto error;

}

int isdst_with_error = PyObject_IsTrue(num);

if (isdst_with_error == -1) {

goto error;

}

else {

isdst[i] = (unsigned char)isdst_with_error;

}

}

dstoff = PyMem_Calloc(self->num_ttinfos, sizeof(long));

if (dstoff == NULL) {

goto error;

}

// Derive dstoff and trans_list_wall from the information we've loaded

utcoff_to_dstoff(trans_idx, utcoff, dstoff, isdst, self->num_transitions,

self->num_ttinfos);

if (ts_to_local(trans_idx, self->trans_list_utc, utcoff,

self->trans_list_wall, self->num_ttinfos,

self->num_transitions)) {

goto error;

}

// Build _ttinfo objects from utcoff, dstoff and abbr

self->_ttinfos = PyMem_Malloc(self->num_ttinfos * sizeof(_ttinfo));

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

PyObject *tzname = PyTuple_GetItem(abbr, i);

if (tzname == NULL) {

goto error;

}

ttinfos_allocated++;

if (build_ttinfo(utcoff[i], dstoff[i], tzname, &(self->_ttinfos[i]))) {

goto error;

}