diff --git "a/cpython_chunk_33.py" "b/cpython_chunk_33.py" new file mode 100644--- /dev/null +++ "b/cpython_chunk_33.py" @@ -0,0 +1,16308 @@ +# Auto-generated from cpython_chunk_33.txt + +TEXT_DATA = r""" +#include "Python.h" +#include "pycore_call.h" // _PyObject_CallNoArgs() +#include "pycore_dict.h" // _PyDict_GetItem_KnownHash() +#include "pycore_long.h" // _PyLong_GetZero() +#include "pycore_moduleobject.h" // _PyModule_GetState() +#include "pycore_pyatomic_ft_wrappers.h" +#include "pycore_typeobject.h" // _PyType_GetModuleState() +#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS() +#include +typedef struct { +PyTypeObject *deque_type; +PyTypeObject *defdict_type; +PyTypeObject *dequeiter_type; +PyTypeObject *dequereviter_type; +PyTypeObject *tuplegetter_type; +} collections_state; +static inline collections_state * +get_module_state(PyObject *mod) +{ +void *state = _PyModule_GetState(mod); +assert(state != NULL); +return (collections_state *)state; +} +static inline collections_state * +get_module_state_by_cls(PyTypeObject *cls) +{ +void *state = _PyType_GetModuleState(cls); +assert(state != NULL); +return (collections_state *)state; +} +static struct PyModuleDef _collectionsmodule; +static inline collections_state * +find_module_state_by_def(PyTypeObject *type) +{ +PyObject *mod = PyType_GetModuleByDef(type, &_collectionsmodule); +assert(mod != NULL); +return get_module_state(mod); +} +/*[clinic input] +module _collections +class _tuplegetter "_tuplegetterobject *" "clinic_state()->tuplegetter_type" +class _collections.deque "dequeobject *" "clinic_state()->deque_type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a033cc2a8476b3f1]*/ +typedef struct dequeobject dequeobject; +/* We can safely assume type to be the defining class, +* since tuplegetter is not a base type */ +#define clinic_state() (get_module_state_by_cls(type)) +#include "clinic/_collectionsmodule.c.h" +#undef clinic_state +/*[python input] +class dequeobject_converter(self_converter): +type = "dequeobject *" +[python start generated code]*/ +/*[python end generated code: output=da39a3ee5e6b4b0d input=b6ae4a3ff852be2f]*/ +/* collections module implementation of a deque() datatype +Written and maintained by Raymond D. Hettinger +*/ +/* The block length may be set to any number over 1. Larger numbers +* reduce the number of calls to the memory allocator, give faster +* indexing and rotation, and reduce the link to data overhead ratio. +* Making the block length a power of two speeds-up the modulo +* and division calculations in deque_item() and deque_ass_item(). +*/ +#define BLOCKLEN 64 +#define CENTER ((BLOCKLEN - 1) / 2) +#define MAXFREEBLOCKS 16 +/* Data for deque objects is stored in a doubly-linked list of fixed +* length blocks. This assures that appends or pops never move any +* other data elements besides the one being appended or popped. +* +* Another advantage is that it completely avoids use of realloc(), +* resulting in more predictable performance. +* +* Textbook implementations of doubly-linked lists store one datum +* per link, but that gives them a 200% memory overhead (a prev and +* next link for each datum) and it costs one malloc() call per data +* element. By using fixed-length blocks, the link to data ratio is +* significantly improved and there are proportionally fewer calls +* to malloc() and free(). The data blocks of consecutive pointers +* also improve cache locality. +* +* The list of blocks is never empty, so d.leftblock and d.rightblock +* are never equal to NULL. The list is not circular. +* +* A deque d's first element is at d.leftblock[leftindex] +* and its last element is at d.rightblock[rightindex]. +* +* Unlike Python slice indices, these indices are inclusive on both +* ends. This makes the algorithms for left and right operations +* more symmetrical and it simplifies the design. +* +* The indices, d.leftindex and d.rightindex are always in the range: +* 0 <= index < BLOCKLEN +* +* And their exact relationship is: +* (d.leftindex + d.len - 1) % BLOCKLEN == d.rightindex +* +* Whenever d.leftblock == d.rightblock, then: +* d.leftindex + d.len - 1 == d.rightindex +* +* However, when d.leftblock != d.rightblock, the d.leftindex and +* d.rightindex become indices into distinct blocks and either may +* be larger than the other. +* +* Empty deques have: +* d.len == 0 +* d.leftblock == d.rightblock +* d.leftindex == CENTER + 1 +* d.rightindex == CENTER +* +* Checking for d.len == 0 is the intended way to see whether d is empty. +*/ +typedef struct BLOCK { +struct BLOCK *leftlink; +PyObject *data[BLOCKLEN]; +struct BLOCK *rightlink; +} block; +struct dequeobject { +PyObject_VAR_HEAD +block *leftblock; +block *rightblock; +Py_ssize_t leftindex; /* 0 <= leftindex < BLOCKLEN */ +Py_ssize_t rightindex; /* 0 <= rightindex < BLOCKLEN */ +size_t state; /* incremented whenever the indices move */ +Py_ssize_t maxlen; /* maxlen is -1 for unbounded deques */ +Py_ssize_t numfreeblocks; +block *freeblocks[MAXFREEBLOCKS]; +PyObject *weakreflist; +}; +#define dequeobject_CAST(op) ((dequeobject *)(op)) +/* For debug builds, add error checking to track the endpoints +* in the chain of links. The goal is to make sure that link +* assignments only take place at endpoints so that links already +* in use do not get overwritten. +* +* CHECK_END should happen before each assignment to a block's link field. +* MARK_END should happen whenever a link field becomes a new endpoint. +* This happens when new blocks are added or whenever an existing +* block is freed leaving another existing block as the new endpoint. +*/ +#ifndef NDEBUG +#define MARK_END(link) link = NULL; +#define CHECK_END(link) assert(link == NULL); +#define CHECK_NOT_END(link) assert(link != NULL); +#else +#define MARK_END(link) +#define CHECK_END(link) +#define CHECK_NOT_END(link) +#endif +/* A simple freelisting scheme is used to minimize calls to the memory +allocator. It accommodates common use cases where new blocks are being +added at about the same rate as old blocks are being freed. +*/ +static inline block * +newblock(dequeobject *deque) { +block *b; +if (deque->numfreeblocks) { +deque->numfreeblocks--; +return deque->freeblocks[deque->numfreeblocks]; +} +b = PyMem_Malloc(sizeof(block)); +if (b != NULL) { +return b; +} +PyErr_NoMemory(); +return NULL; +} +static inline void +freeblock(dequeobject *deque, block *b) +{ +if (deque->numfreeblocks < MAXFREEBLOCKS) { +deque->freeblocks[deque->numfreeblocks] = b; +deque->numfreeblocks++; +} else { +PyMem_Free(b); +} +} +static PyObject * +deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ +dequeobject *deque; +block *b; +/* create dequeobject structure */ +deque = (dequeobject *)type->tp_alloc(type, 0); +if (deque == NULL) +return NULL; +b = newblock(deque); +if (b == NULL) { +Py_DECREF(deque); +return NULL; +} +MARK_END(b->leftlink); +MARK_END(b->rightlink); +assert(BLOCKLEN >= 2); +Py_SET_SIZE(deque, 0); +deque->leftblock = b; +deque->rightblock = b; +deque->leftindex = CENTER + 1; +deque->rightindex = CENTER; +deque->state = 0; +deque->maxlen = -1; +deque->numfreeblocks = 0; +deque->weakreflist = NULL; +return (PyObject *)deque; +} +/*[clinic input] +@critical_section +_collections.deque.pop as deque_pop +deque: dequeobject +Remove and return the rightmost element. +[clinic start generated code]*/ +static PyObject * +deque_pop_impl(dequeobject *deque) +/*[clinic end generated code: output=2e5f7890c4251f07 input=55c5b6a8ad51d72f]*/ +{ +PyObject *item; +block *prevblock; +if (Py_SIZE(deque) == 0) { +PyErr_SetString(PyExc_IndexError, "pop from an empty deque"); +return NULL; +} +item = deque->rightblock->data[deque->rightindex]; +deque->rightindex--; +Py_SET_SIZE(deque, Py_SIZE(deque) - 1); +deque->state++; +if (deque->rightindex < 0) { +if (Py_SIZE(deque)) { +prevblock = deque->rightblock->leftlink; +assert(deque->leftblock != deque->rightblock); +freeblock(deque, deque->rightblock); +CHECK_NOT_END(prevblock); +MARK_END(prevblock->rightlink); +deque->rightblock = prevblock; +deque->rightindex = BLOCKLEN - 1; +} else { +assert(deque->leftblock == deque->rightblock); +assert(deque->leftindex == deque->rightindex+1); +/* re-center instead of freeing a block */ +deque->leftindex = CENTER + 1; +deque->rightindex = CENTER; +} +} +return item; +} +/*[clinic input] +@critical_section +_collections.deque.popleft as deque_popleft +deque: dequeobject +Remove and return the leftmost element. +[clinic start generated code]*/ +static PyObject * +deque_popleft_impl(dequeobject *deque) +/*[clinic end generated code: output=62b154897097ff68 input=1571ce88fe3053de]*/ +{ +PyObject *item; +block *prevblock; +if (Py_SIZE(deque) == 0) { +PyErr_SetString(PyExc_IndexError, "pop from an empty deque"); +return NULL; +} +assert(deque->leftblock != NULL); +item = deque->leftblock->data[deque->leftindex]; +deque->leftindex++; +Py_SET_SIZE(deque, Py_SIZE(deque) - 1); +deque->state++; +if (deque->leftindex == BLOCKLEN) { +if (Py_SIZE(deque)) { +assert(deque->leftblock != deque->rightblock); +prevblock = deque->leftblock->rightlink; +freeblock(deque, deque->leftblock); +CHECK_NOT_END(prevblock); +MARK_END(prevblock->leftlink); +deque->leftblock = prevblock; +deque->leftindex = 0; +} else { +assert(deque->leftblock == deque->rightblock); +assert(deque->leftindex == deque->rightindex+1); +/* re-center instead of freeing a block */ +deque->leftindex = CENTER + 1; +deque->rightindex = CENTER; +} +} +return item; +} +/* The deque's size limit is d.maxlen. The limit can be zero or positive. +* If there is no limit, then d.maxlen == -1. +* +* After an item is added to a deque, we check to see if the size has +* grown past the limit. If it has, we get the size back down to the limit +* by popping an item off of the opposite end. The methods that can +* trigger this are append(), appendleft(), extend(), and extendleft(). +* +* The macro to check whether a deque needs to be trimmed uses a single +* unsigned test that returns true whenever 0 <= maxlen < Py_SIZE(deque). +*/ +#define NEEDS_TRIM(deque, maxlen) ((size_t)(maxlen) < (size_t)(Py_SIZE(deque))) +static inline int +deque_append_lock_held(dequeobject *deque, PyObject *item, Py_ssize_t maxlen) +{ +if (deque->rightindex == BLOCKLEN - 1) { +block *b = newblock(deque); +if (b == NULL) +return -1; +b->leftlink = deque->rightblock; +CHECK_END(deque->rightblock->rightlink); +deque->rightblock->rightlink = b; +deque->rightblock = b; +MARK_END(b->rightlink); +deque->rightindex = -1; +} +Py_SET_SIZE(deque, Py_SIZE(deque) + 1); +deque->rightindex++; +deque->rightblock->data[deque->rightindex] = item; +if (NEEDS_TRIM(deque, maxlen)) { +PyObject *olditem = deque_popleft_impl(deque); +Py_DECREF(olditem); +} else { +deque->state++; +} +return 0; +} +/*[clinic input] +@critical_section +_collections.deque.append as deque_append +deque: dequeobject +item: object +/ +Add an element to the right side of the deque. +[clinic start generated code]*/ +static PyObject * +deque_append_impl(dequeobject *deque, PyObject *item) +/*[clinic end generated code: output=9c7bcb8b599c6362 input=b0eeeb09b9f5cf18]*/ +{ +if (deque_append_lock_held(deque, Py_NewRef(item), deque->maxlen) < 0) +return NULL; +Py_RETURN_NONE; +} +static inline int +deque_appendleft_lock_held(dequeobject *deque, PyObject *item, +Py_ssize_t maxlen) +{ +if (deque->leftindex == 0) { +block *b = newblock(deque); +if (b == NULL) +return -1; +b->rightlink = deque->leftblock; +CHECK_END(deque->leftblock->leftlink); +deque->leftblock->leftlink = b; +deque->leftblock = b; +MARK_END(b->leftlink); +deque->leftindex = BLOCKLEN; +} +Py_SET_SIZE(deque, Py_SIZE(deque) + 1); +deque->leftindex--; +deque->leftblock->data[deque->leftindex] = item; +if (NEEDS_TRIM(deque, maxlen)) { +PyObject *olditem = deque_pop_impl(deque); +Py_DECREF(olditem); +} else { +deque->state++; +} +return 0; +} +/*[clinic input] +@critical_section +_collections.deque.appendleft as deque_appendleft +deque: dequeobject +item: object +/ +Add an element to the left side of the deque. +[clinic start generated code]*/ +static PyObject * +deque_appendleft_impl(dequeobject *deque, PyObject *item) +/*[clinic end generated code: output=9a192edbcd0f20db input=236c2fbceaf08e14]*/ +{ +if (deque_appendleft_lock_held(deque, Py_NewRef(item), deque->maxlen) < 0) +return NULL; +Py_RETURN_NONE; +} +static PyObject* +finalize_iterator(PyObject *it) +{ +if (PyErr_Occurred()) { +if (PyErr_ExceptionMatches(PyExc_StopIteration)) +PyErr_Clear(); +else { +Py_DECREF(it); +return NULL; +} +} +Py_DECREF(it); +Py_RETURN_NONE; +} +/* Run an iterator to exhaustion. Shortcut for +the extend/extendleft methods when maxlen == 0. */ +static PyObject* +consume_iterator(PyObject *it) +{ +PyObject *(*iternext)(PyObject *); +PyObject *item; +iternext = *Py_TYPE(it)->tp_iternext; +while ((item = iternext(it)) != NULL) { +Py_DECREF(item); +} +return finalize_iterator(it); +} +/*[clinic input] +@critical_section +_collections.deque.extend as deque_extend +deque: dequeobject +iterable: object +/ +Extend the right side of the deque with elements from the iterable. +[clinic start generated code]*/ +static PyObject * +deque_extend_impl(dequeobject *deque, PyObject *iterable) +/*[clinic end generated code: output=8b5ffa57ce82d980 input=85861954127c81da]*/ +{ +PyObject *it, *item; +PyObject *(*iternext)(PyObject *); +Py_ssize_t maxlen = deque->maxlen; +/* Handle case where id(deque) == id(iterable) */ +if ((PyObject *)deque == iterable) { +PyObject *result; +PyObject *s = PySequence_List(iterable); +if (s == NULL) +return NULL; +result = deque_extend((PyObject*)deque, s); +Py_DECREF(s); +return result; +} +it = PyObject_GetIter(iterable); +if (it == NULL) +return NULL; +if (maxlen == 0) +return consume_iterator(it); +/* Space saving heuristic. Start filling from the left */ +if (Py_SIZE(deque) == 0) { +assert(deque->leftblock == deque->rightblock); +assert(deque->leftindex == deque->rightindex+1); +deque->leftindex = 1; +deque->rightindex = 0; +} +iternext = *Py_TYPE(it)->tp_iternext; +while ((item = iternext(it)) != NULL) { +if (deque_append_lock_held(deque, item, maxlen) == -1) { +Py_DECREF(item); +Py_DECREF(it); +return NULL; +} +} +return finalize_iterator(it); +} +/*[clinic input] +@critical_section +_collections.deque.extendleft as deque_extendleft +deque: dequeobject +iterable: object +/ +Extend the left side of the deque with elements from the iterable. +[clinic start generated code]*/ +static PyObject * +deque_extendleft_impl(dequeobject *deque, PyObject *iterable) +/*[clinic end generated code: output=ba44191aa8e35a26 input=640dabd086115689]*/ +{ +PyObject *it, *item; +PyObject *(*iternext)(PyObject *); +Py_ssize_t maxlen = deque->maxlen; +/* Handle case where id(deque) == id(iterable) */ +if ((PyObject *)deque == iterable) { +PyObject *result; +PyObject *s = PySequence_List(iterable); +if (s == NULL) +return NULL; +result = deque_extendleft_impl(deque, s); +Py_DECREF(s); +return result; +} +it = PyObject_GetIter(iterable); +if (it == NULL) +return NULL; +if (maxlen == 0) +return consume_iterator(it); +/* Space saving heuristic. Start filling from the right */ +if (Py_SIZE(deque) == 0) { +assert(deque->leftblock == deque->rightblock); +assert(deque->leftindex == deque->rightindex+1); +deque->leftindex = BLOCKLEN - 1; +deque->rightindex = BLOCKLEN - 2; +} +iternext = *Py_TYPE(it)->tp_iternext; +while ((item = iternext(it)) != NULL) { +if (deque_appendleft_lock_held(deque, item, maxlen) == -1) { +Py_DECREF(item); +Py_DECREF(it); +return NULL; +} +} +return finalize_iterator(it); +} +static PyObject * +deque_inplace_concat(PyObject *self, PyObject *other) +{ +dequeobject *deque = dequeobject_CAST(self); +PyObject *result; +// deque_extend is thread-safe +result = deque_extend((PyObject*)deque, other); +if (result == NULL) +return result; +Py_INCREF(deque); +Py_DECREF(result); +return (PyObject *)deque; +} +/*[clinic input] +@critical_section +_collections.deque.copy as deque_copy +deque: dequeobject +Return a shallow copy of a deque. +[clinic start generated code]*/ +static PyObject * +deque_copy_impl(dequeobject *deque) +/*[clinic end generated code: output=6409b3d1ad2898b5 input=51d2ed1a23bab5e2]*/ +{ +PyObject *result; +dequeobject *old_deque = deque; +collections_state *state = find_module_state_by_def(Py_TYPE(deque)); +if (Py_IS_TYPE(deque, state->deque_type)) { +dequeobject *new_deque; +PyObject *rv; +new_deque = (dequeobject *)deque_new(state->deque_type, NULL, NULL); +if (new_deque == NULL) +return NULL; +new_deque->maxlen = old_deque->maxlen; +/* Fast path for the deque_repeat() common case where len(deque) == 1 +* +* It's safe to not acquire the per-object lock for new_deque; it's +* invisible to other threads. +*/ +if (Py_SIZE(deque) == 1) { +PyObject *item = old_deque->leftblock->data[old_deque->leftindex]; +rv = deque_append_impl(new_deque, item); +} else { +rv = deque_extend_impl(new_deque, (PyObject *)deque); +} +if (rv != NULL) { +Py_DECREF(rv); +return (PyObject *)new_deque; +} +Py_DECREF(new_deque); +return NULL; +} +if (old_deque->maxlen < 0) +result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), +(PyObject *)deque); +else +result = PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi", +deque, old_deque->maxlen, NULL); +if (result != NULL && !PyObject_TypeCheck(result, state->deque_type)) { +PyErr_Format(PyExc_TypeError, +"%.200s() must return a deque, not %.200s", +Py_TYPE(deque)->tp_name, Py_TYPE(result)->tp_name); +Py_DECREF(result); +return NULL; +} +return result; +} +/*[clinic input] +@critical_section +_collections.deque.__copy__ as deque___copy__ = _collections.deque.copy +Return a shallow copy of a deque. +[clinic start generated code]*/ +static PyObject * +deque___copy___impl(dequeobject *deque) +/*[clinic end generated code: output=7c5821504342bf23 input=f5464036f9686a55]*/ +{ +return deque_copy_impl(deque); +} +static PyObject * +deque_concat_lock_held(dequeobject *deque, PyObject *other) +{ +PyObject *new_deque, *result; +int rv; +collections_state *state = find_module_state_by_def(Py_TYPE(deque)); +rv = PyObject_IsInstance(other, (PyObject *)state->deque_type); +if (rv <= 0) { +if (rv == 0) { +PyErr_Format(PyExc_TypeError, +"can only concatenate deque (not \"%.200s\") to deque", +Py_TYPE(other)->tp_name); +} +return NULL; +} +new_deque = deque_copy_impl(deque); +if (new_deque == NULL) +return NULL; +// It's safe to not acquire the per-object lock for new_deque; it's +// invisible to other threads. +result = deque_extend_impl((dequeobject *)new_deque, other); +if (result == NULL) { +Py_DECREF(new_deque); +return NULL; +} +Py_DECREF(result); +return new_deque; +} +static PyObject * +deque_concat(PyObject *self, PyObject *other) +{ +dequeobject *deque = dequeobject_CAST(self); +PyObject *result; +Py_BEGIN_CRITICAL_SECTION(deque); +result = deque_concat_lock_held(deque, other); +Py_END_CRITICAL_SECTION(); +return result; +} +static int +deque_clear(PyObject *self) +{ +block *b; +block *prevblock; +block *leftblock; +Py_ssize_t leftindex; +Py_ssize_t n, m; +PyObject *item; +PyObject **itemptr, **limit; +dequeobject *deque = dequeobject_CAST(self); +if (Py_SIZE(deque) == 0) +return 0; +/* During the process of clearing a deque, decrefs can cause the +deque to mutate. To avoid fatal confusion, we have to make the +deque empty before clearing the blocks and never refer to +anything via deque->ref while clearing. (This is the same +technique used for clearing lists, sets, and dicts.) +Making the deque empty requires allocating a new empty block. In +the unlikely event that memory is full, we fall back to an +alternate method that doesn't require a new block. Repeating +pops in a while-loop is slower, possibly re-entrant (and a clever +adversary could cause it to never terminate). +*/ +b = newblock(deque); +if (b == NULL) { +PyErr_Clear(); +goto alternate_method; +} +/* Remember the old size, leftblock, and leftindex */ +n = Py_SIZE(deque); +leftblock = deque->leftblock; +leftindex = deque->leftindex; +/* Set the deque to be empty using the newly allocated block */ +MARK_END(b->leftlink); +MARK_END(b->rightlink); +Py_SET_SIZE(deque, 0); +deque->leftblock = b; +deque->rightblock = b; +deque->leftindex = CENTER + 1; +deque->rightindex = CENTER; +deque->state++; +/* Now the old size, leftblock, and leftindex are disconnected from +the empty deque and we can use them to decref the pointers. +*/ +m = (BLOCKLEN - leftindex > n) ? n : BLOCKLEN - leftindex; +itemptr = &leftblock->data[leftindex]; +limit = itemptr + m; +n -= m; +while (1) { +if (itemptr == limit) { +if (n == 0) +break; +CHECK_NOT_END(leftblock->rightlink); +prevblock = leftblock; +leftblock = leftblock->rightlink; +m = (n > BLOCKLEN) ? BLOCKLEN : n; +itemptr = leftblock->data; +limit = itemptr + m; +n -= m; +freeblock(deque, prevblock); +} +item = *(itemptr++); +Py_DECREF(item); +} +CHECK_END(leftblock->rightlink); +freeblock(deque, leftblock); +return 0; +alternate_method: +while (Py_SIZE(deque)) { +item = deque_pop_impl(deque); +assert (item != NULL); +Py_DECREF(item); +} +return 0; +} +/*[clinic input] +@critical_section +_collections.deque.clear as deque_clearmethod +deque: dequeobject +Remove all elements from the deque. +[clinic start generated code]*/ +static PyObject * +deque_clearmethod_impl(dequeobject *deque) +/*[clinic end generated code: output=79b2513e097615c1 input=3a22e9605d20c5e9]*/ +{ +(void)deque_clear((PyObject *)deque); +Py_RETURN_NONE; +} +static PyObject * +deque_inplace_repeat_lock_held(dequeobject *deque, Py_ssize_t n) +{ +Py_ssize_t i, m, size; +PyObject *seq; +PyObject *rv; +size = Py_SIZE(deque); +if (size == 0 || n == 1) { +return Py_NewRef(deque); +} +if (n <= 0) { +(void)deque_clear((PyObject *)deque); +return Py_NewRef(deque); +} +if (size == 1) { +/* common case, repeating a single element */ +PyObject *item = deque->leftblock->data[deque->leftindex]; +if (deque->maxlen >= 0 && n > deque->maxlen) +n = deque->maxlen; +deque->state++; +for (i = 0 ; i < n-1 ; ) { +if (deque->rightindex == BLOCKLEN - 1) { +block *b = newblock(deque); +if (b == NULL) { +Py_SET_SIZE(deque, Py_SIZE(deque) + i); +return NULL; +} +b->leftlink = deque->rightblock; +CHECK_END(deque->rightblock->rightlink); +deque->rightblock->rightlink = b; +deque->rightblock = b; +MARK_END(b->rightlink); +deque->rightindex = -1; +} +m = n - 1 - i; +if (m > BLOCKLEN - 1 - deque->rightindex) +m = BLOCKLEN - 1 - deque->rightindex; +i += m; +while (m--) { +deque->rightindex++; +deque->rightblock->data[deque->rightindex] = Py_NewRef(item); +} +} +Py_SET_SIZE(deque, Py_SIZE(deque) + i); +return Py_NewRef(deque); +} +if ((size_t)size > PY_SSIZE_T_MAX / (size_t)n) { +return PyErr_NoMemory(); +} +seq = PySequence_List((PyObject *)deque); +if (seq == NULL) +return seq; +/* Reduce the number of repetitions when maxlen would be exceeded */ +if (deque->maxlen >= 0 && n * size > deque->maxlen) +n = (deque->maxlen + size - 1) / size; +for (i = 0 ; i < n-1 ; i++) { +rv = deque_extend_impl(deque, seq); +if (rv == NULL) { +Py_DECREF(seq); +return NULL; +} +Py_DECREF(rv); +} +Py_INCREF(deque); +Py_DECREF(seq); +return (PyObject *)deque; +} +static PyObject * +deque_inplace_repeat(PyObject *self, Py_ssize_t n) +{ +dequeobject *deque = dequeobject_CAST(self); +PyObject *result; +Py_BEGIN_CRITICAL_SECTION(deque); +result = deque_inplace_repeat_lock_held(deque, n); +Py_END_CRITICAL_SECTION(); +return result; +} +static PyObject * +deque_repeat(PyObject *self, Py_ssize_t n) +{ +dequeobject *deque = dequeobject_CAST(self); +dequeobject *new_deque; +PyObject *rv; +Py_BEGIN_CRITICAL_SECTION(deque); +new_deque = (dequeobject *)deque_copy_impl(deque); +Py_END_CRITICAL_SECTION(); +if (new_deque == NULL) +return NULL; +// It's safe to not acquire the per-object lock for new_deque; it's +// invisible to other threads. +rv = deque_inplace_repeat_lock_held(new_deque, n); +Py_DECREF(new_deque); +return rv; +} +/* The rotate() method is part of the public API and is used internally +as a primitive for other methods. +Rotation by 1 or -1 is a common case, so any optimizations for high +volume rotations should take care not to penalize the common case. +Conceptually, a rotate by one is equivalent to a pop on one side and an +append on the other. However, a pop/append pair is unnecessarily slow +because it requires an incref/decref pair for an object located randomly +in memory. It is better to just move the object pointer from one block +to the next without changing the reference count. +When moving batches of pointers, it is tempting to use memcpy() but that +proved to be slower than a simple loop for a variety of reasons. +Memcpy() cannot know in advance that we're copying pointers instead of +bytes, that the source and destination are pointer aligned and +non-overlapping, that moving just one pointer is a common case, that we +never need to move more than BLOCKLEN pointers, and that at least one +pointer is always moved. +For high volume rotations, newblock() and freeblock() are never called +more than once. Previously emptied blocks are immediately reused as a +destination block. If a block is left-over at the end, it is freed. +*/ +static int +_deque_rotate(dequeobject *deque, Py_ssize_t n) +{ +block *b = NULL; +block *leftblock = deque->leftblock; +block *rightblock = deque->rightblock; +Py_ssize_t leftindex = deque->leftindex; +Py_ssize_t rightindex = deque->rightindex; +Py_ssize_t len=Py_SIZE(deque), halflen=len>>1; +int rv = -1; +if (len <= 1) +return 0; +if (n > halflen || n < -halflen) { +n %= len; +if (n > halflen) +n -= len; +else if (n < -halflen) +n += len; +} +assert(len > 1); +assert(-halflen <= n && n <= halflen); +deque->state++; +while (n > 0) { +if (leftindex == 0) { +if (b == NULL) { +b = newblock(deque); +if (b == NULL) +goto done; +} +b->rightlink = leftblock; +CHECK_END(leftblock->leftlink); +leftblock->leftlink = b; +leftblock = b; +MARK_END(b->leftlink); +leftindex = BLOCKLEN; +b = NULL; +} +assert(leftindex > 0); +{ +PyObject **src, **dest; +Py_ssize_t m = n; +if (m > rightindex + 1) +m = rightindex + 1; +if (m > leftindex) +m = leftindex; +assert (m > 0 && m <= len); +rightindex -= m; +leftindex -= m; +src = &rightblock->data[rightindex + 1]; +dest = &leftblock->data[leftindex]; +n -= m; +do { +*(dest++) = *(src++); +} while (--m); +} +if (rightindex < 0) { +assert(leftblock != rightblock); +assert(b == NULL); +b = rightblock; +CHECK_NOT_END(rightblock->leftlink); +rightblock = rightblock->leftlink; +MARK_END(rightblock->rightlink); +rightindex = BLOCKLEN - 1; +} +} +while (n < 0) { +if (rightindex == BLOCKLEN - 1) { +if (b == NULL) { +b = newblock(deque); +if (b == NULL) +goto done; +} +b->leftlink = rightblock; +CHECK_END(rightblock->rightlink); +rightblock->rightlink = b; +rightblock = b; +MARK_END(b->rightlink); +rightindex = -1; +b = NULL; +} +assert (rightindex < BLOCKLEN - 1); +{ +PyObject **src, **dest; +Py_ssize_t m = -n; +if (m > BLOCKLEN - leftindex) +m = BLOCKLEN - leftindex; +if (m > BLOCKLEN - 1 - rightindex) +m = BLOCKLEN - 1 - rightindex; +assert (m > 0 && m <= len); +src = &leftblock->data[leftindex]; +dest = &rightblock->data[rightindex + 1]; +leftindex += m; +rightindex += m; +n += m; +do { +*(dest++) = *(src++); +} while (--m); +} +if (leftindex == BLOCKLEN) { +assert(leftblock != rightblock); +assert(b == NULL); +b = leftblock; +CHECK_NOT_END(leftblock->rightlink); +leftblock = leftblock->rightlink; +MARK_END(leftblock->leftlink); +leftindex = 0; +} +} +rv = 0; +done: +if (b != NULL) +freeblock(deque, b); +deque->leftblock = leftblock; +deque->rightblock = rightblock; +deque->leftindex = leftindex; +deque->rightindex = rightindex; +return rv; +} +/*[clinic input] +@critical_section +_collections.deque.rotate as deque_rotate +deque: dequeobject +n: Py_ssize_t = 1 +/ +Rotate the deque n steps to the right. If n is negative, rotates left. +[clinic start generated code]*/ +static PyObject * +deque_rotate_impl(dequeobject *deque, Py_ssize_t n) +/*[clinic end generated code: output=96c2402a371eb15d input=5bf834296246e002]*/ +{ +if (!_deque_rotate(deque, n)) +Py_RETURN_NONE; +return NULL; +} +/*[clinic input] +@critical_section +_collections.deque.reverse as deque_reverse +deque: dequeobject +Reverse *IN PLACE*. +[clinic start generated code]*/ +static PyObject * +deque_reverse_impl(dequeobject *deque) +/*[clinic end generated code: output=bdeebc2cf8c1f064 input=26f4167fd623027f]*/ +{ +block *leftblock = deque->leftblock; +block *rightblock = deque->rightblock; +Py_ssize_t leftindex = deque->leftindex; +Py_ssize_t rightindex = deque->rightindex; +Py_ssize_t n = Py_SIZE(deque) >> 1; +PyObject *tmp; +while (--n >= 0) { +/* Validate that pointers haven't met in the middle */ +assert(leftblock != rightblock || leftindex < rightindex); +CHECK_NOT_END(leftblock); +CHECK_NOT_END(rightblock); +/* Swap */ +tmp = leftblock->data[leftindex]; +leftblock->data[leftindex] = rightblock->data[rightindex]; +rightblock->data[rightindex] = tmp; +/* Advance left block/index pair */ +leftindex++; +if (leftindex == BLOCKLEN) { +leftblock = leftblock->rightlink; +leftindex = 0; +} +/* Step backwards with the right block/index pair */ +rightindex--; +if (rightindex < 0) { +rightblock = rightblock->leftlink; +rightindex = BLOCKLEN - 1; +} +} +Py_RETURN_NONE; +} +/*[clinic input] +@critical_section +_collections.deque.count as deque_count +deque: dequeobject +value as v: object +/ +Return number of occurrences of value. +[clinic start generated code]*/ +static PyObject * +deque_count_impl(dequeobject *deque, PyObject *v) +/*[clinic end generated code: output=2ca26c49b6ab0400 input=4ef67ef2b34dc1fc]*/ +{ +block *b = deque->leftblock; +Py_ssize_t index = deque->leftindex; +Py_ssize_t n = Py_SIZE(deque); +Py_ssize_t count = 0; +size_t start_state = deque->state; +PyObject *item; +int cmp; +while (--n >= 0) { +CHECK_NOT_END(b); +item = Py_NewRef(b->data[index]); +cmp = PyObject_RichCompareBool(item, v, Py_EQ); +Py_DECREF(item); +if (cmp < 0) +return NULL; +count += cmp; +if (start_state != deque->state) { +PyErr_SetString(PyExc_RuntimeError, +"deque mutated during iteration"); +return NULL; +} +/* Advance left block/index pair */ +index++; +if (index == BLOCKLEN) { +b = b->rightlink; +index = 0; +} +} +return PyLong_FromSsize_t(count); +} +static int +deque_contains_lock_held(dequeobject *deque, PyObject *v) +{ +block *b = deque->leftblock; +Py_ssize_t index = deque->leftindex; +Py_ssize_t n = Py_SIZE(deque); +size_t start_state = deque->state; +PyObject *item; +int cmp; +while (--n >= 0) { +CHECK_NOT_END(b); +item = Py_NewRef(b->data[index]); +cmp = PyObject_RichCompareBool(item, v, Py_EQ); +Py_DECREF(item); +if (cmp) { +return cmp; +} +if (start_state != deque->state) { +PyErr_SetString(PyExc_RuntimeError, +"deque mutated during iteration"); +return -1; +} +index++; +if (index == BLOCKLEN) { +b = b->rightlink; +index = 0; +} +} +return 0; +} +static int +deque_contains(PyObject *self, PyObject *v) +{ +dequeobject *deque = dequeobject_CAST(self); +int result; +Py_BEGIN_CRITICAL_SECTION(deque); +result = deque_contains_lock_held(deque, v); +Py_END_CRITICAL_SECTION(); +return result; +} +static Py_ssize_t +deque_len(PyObject *self) +{ +PyVarObject *deque = _PyVarObject_CAST(self); +return FT_ATOMIC_LOAD_SSIZE(deque->ob_size); +} +/*[clinic input] +@critical_section +@text_signature "($self, value, [start, [stop]])" +_collections.deque.index as deque_index +deque: dequeobject +value as v: object +start: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='0') = NULL +stop: object(converter='_PyEval_SliceIndexNotNone', type='Py_ssize_t', c_default='Py_SIZE(deque)') = NULL +/ +Return first index of value. +Raises ValueError if the value is not present. +[clinic start generated code]*/ +static PyObject * +deque_index_impl(dequeobject *deque, PyObject *v, Py_ssize_t start, +Py_ssize_t stop) +/*[clinic end generated code: output=df45132753175ef9 input=90f48833a91e1743]*/ +{ +Py_ssize_t i, n; +PyObject *item; +block *b = deque->leftblock; +Py_ssize_t index = deque->leftindex; +size_t start_state = deque->state; +int cmp; +if (start < 0) { +start += Py_SIZE(deque); +if (start < 0) +start = 0; +} +if (stop < 0) { +stop += Py_SIZE(deque); +if (stop < 0) +stop = 0; +} +if (stop > Py_SIZE(deque)) +stop = Py_SIZE(deque); +if (start > stop) +start = stop; +assert(0 <= start && start <= stop && stop <= Py_SIZE(deque)); +for (i=0 ; i < start - BLOCKLEN ; i += BLOCKLEN) { +b = b->rightlink; +} +for ( ; i < start ; i++) { +index++; +if (index == BLOCKLEN) { +b = b->rightlink; +index = 0; +} +} +n = stop - i; +while (--n >= 0) { +CHECK_NOT_END(b); +item = Py_NewRef(b->data[index]); +cmp = PyObject_RichCompareBool(item, v, Py_EQ); +Py_DECREF(item); +if (cmp > 0) +return PyLong_FromSsize_t(stop - n - 1); +if (cmp < 0) +return NULL; +if (start_state != deque->state) { +PyErr_SetString(PyExc_RuntimeError, +"deque mutated during iteration"); +return NULL; +} +index++; +if (index == BLOCKLEN) { +b = b->rightlink; +index = 0; +} +} +PyErr_SetString(PyExc_ValueError, "deque.index(x): x not in deque"); +return NULL; +} +/* insert(), remove(), and delitem() are implemented in terms of +rotate() for simplicity and reasonable performance near the end +points. If for some reason these methods become popular, it is not +hard to re-implement this using direct data movement (similar to +the code used in list slice assignments) and achieve a performance +boost (by moving each pointer only once instead of twice). +*/ +/*[clinic input] +@critical_section +_collections.deque.insert as deque_insert +deque: dequeobject +index: Py_ssize_t +value: object +/ +Insert value before index. +[clinic start generated code]*/ +static PyObject * +deque_insert_impl(dequeobject *deque, Py_ssize_t index, PyObject *value) +/*[clinic end generated code: output=ef4d2c15d5532b80 input=dbee706586cc9cde]*/ +{ +Py_ssize_t n = Py_SIZE(deque); +PyObject *rv; +if (deque->maxlen == Py_SIZE(deque)) { +PyErr_SetString(PyExc_IndexError, "deque already at its maximum size"); +return NULL; +} +if (index >= n) +return deque_append_impl(deque, value); +if (index <= -n || index == 0) +return deque_appendleft_impl(deque, value); +if (_deque_rotate(deque, -index)) +return NULL; +if (index < 0) +rv = deque_append_impl(deque, value); +else +rv = deque_appendleft_impl(deque, value); +if (rv == NULL) +return NULL; +Py_DECREF(rv); +if (_deque_rotate(deque, index)) +return NULL; +Py_RETURN_NONE; +} +static int +valid_index(Py_ssize_t i, Py_ssize_t limit) +{ +/* The cast to size_t lets us use just a single comparison +to check whether i is in the range: 0 <= i < limit */ +return (size_t) i < (size_t) limit; +} +static PyObject * +deque_item_lock_held(dequeobject *deque, Py_ssize_t i) +{ +block *b; +PyObject *item; +Py_ssize_t n, index=i; +if (!valid_index(i, Py_SIZE(deque))) { +PyErr_SetString(PyExc_IndexError, "deque index out of range"); +return NULL; +} +if (i == 0) { +i = deque->leftindex; +b = deque->leftblock; +} else if (i == Py_SIZE(deque) - 1) { +i = deque->rightindex; +b = deque->rightblock; +} else { +i += deque->leftindex; +n = (Py_ssize_t)((size_t) i / BLOCKLEN); +i = (Py_ssize_t)((size_t) i % BLOCKLEN); +if (index < (Py_SIZE(deque) >> 1)) { +b = deque->leftblock; +while (--n >= 0) +b = b->rightlink; +} else { +n = (Py_ssize_t)( +((size_t)(deque->leftindex + Py_SIZE(deque) - 1)) +/ BLOCKLEN - n); +b = deque->rightblock; +while (--n >= 0) +b = b->leftlink; +} +} +item = b->data[i]; +return Py_NewRef(item); +} +static PyObject * +deque_item(PyObject *self, Py_ssize_t i) +{ +dequeobject *deque = dequeobject_CAST(self); +PyObject *result; +Py_BEGIN_CRITICAL_SECTION(deque); +result = deque_item_lock_held(deque, i); +Py_END_CRITICAL_SECTION(); +return result; +} +static int +deque_del_item(dequeobject *deque, Py_ssize_t i) +{ +PyObject *item; +int rv; +assert (i >= 0 && i < Py_SIZE(deque)); +if (_deque_rotate(deque, -i)) +return -1; +item = deque_popleft_impl(deque); +rv = _deque_rotate(deque, i); +assert (item != NULL); +Py_DECREF(item); +return rv; +} +/*[clinic input] +@critical_section +_collections.deque.remove as deque_remove +deque: dequeobject +value: object +/ +Remove first occurrence of value. +[clinic start generated code]*/ +static PyObject * +deque_remove_impl(dequeobject *deque, PyObject *value) +/*[clinic end generated code: output=54cff28b8ef78c5b input=60eb3f8aa4de532a]*/ +{ +PyObject *item; +block *b = deque->leftblock; +Py_ssize_t i, n = Py_SIZE(deque), index = deque->leftindex; +size_t start_state = deque->state; +int cmp, rv; +for (i = 0 ; i < n; i++) { +item = Py_NewRef(b->data[index]); +cmp = PyObject_RichCompareBool(item, value, Py_EQ); +Py_DECREF(item); +if (cmp < 0) { +return NULL; +} +if (start_state != deque->state) { +PyErr_SetString(PyExc_IndexError, +"deque mutated during iteration"); +return NULL; +} +if (cmp > 0) { +break; +} +index++; +if (index == BLOCKLEN) { +b = b->rightlink; +index = 0; +} +} +if (i == n) { +PyErr_SetString(PyExc_ValueError, "deque.remove(x): x not in deque"); +return NULL; +} +rv = deque_del_item(deque, i); +if (rv == -1) { +return NULL; +} +Py_RETURN_NONE; +} +static int +deque_ass_item_lock_held(dequeobject *deque, Py_ssize_t i, PyObject *v) +{ +block *b; +Py_ssize_t n, len=Py_SIZE(deque), halflen=(len+1)>>1, index=i; +if (!valid_index(i, len)) { +PyErr_SetString(PyExc_IndexError, "deque index out of range"); +return -1; +} +if (v == NULL) +return deque_del_item(deque, i); +i += deque->leftindex; +n = (Py_ssize_t)((size_t) i / BLOCKLEN); +i = (Py_ssize_t)((size_t) i % BLOCKLEN); +if (index <= halflen) { +b = deque->leftblock; +while (--n >= 0) +b = b->rightlink; +} else { +n = (Py_ssize_t)( +((size_t)(deque->leftindex + Py_SIZE(deque) - 1)) +/ BLOCKLEN - n); +b = deque->rightblock; +while (--n >= 0) +b = b->leftlink; +} +Py_SETREF(b->data[i], Py_NewRef(v)); +return 0; +} +static int +deque_ass_item(PyObject *self, Py_ssize_t i, PyObject *v) +{ +dequeobject *deque = dequeobject_CAST(self); +int result; +Py_BEGIN_CRITICAL_SECTION(deque); +result = deque_ass_item_lock_held(deque, i, v); +Py_END_CRITICAL_SECTION(); +return result; +} +static void +deque_dealloc(PyObject *self) +{ +dequeobject *deque = dequeobject_CAST(self); +PyTypeObject *tp = Py_TYPE(deque); +Py_ssize_t i; +PyObject_GC_UnTrack(deque); +FT_CLEAR_WEAKREFS(self, deque->weakreflist); +if (deque->leftblock != NULL) { +(void)deque_clear(self); +assert(deque->leftblock != NULL); +freeblock(deque, deque->leftblock); +} +deque->leftblock = NULL; +deque->rightblock = NULL; +for (i=0 ; i < deque->numfreeblocks ; i++) { +PyMem_Free(deque->freeblocks[i]); +} +tp->tp_free(deque); +Py_DECREF(tp); +} +static int +deque_traverse(PyObject *self, visitproc visit, void *arg) +{ +dequeobject *deque = dequeobject_CAST(self); +Py_VISIT(Py_TYPE(deque)); +block *b; +PyObject *item; +Py_ssize_t index; +Py_ssize_t indexlo = deque->leftindex; +Py_ssize_t indexhigh; +for (b = deque->leftblock; b != deque->rightblock; b = b->rightlink) { +for (index = indexlo; index < BLOCKLEN ; index++) { +item = b->data[index]; +Py_VISIT(item); +} +indexlo = 0; +} +indexhigh = deque->rightindex; +for (index = indexlo; index <= indexhigh; index++) { +item = b->data[index]; +Py_VISIT(item); +} +return 0; +} +/*[clinic input] +_collections.deque.__reduce__ as deque___reduce__ +deque: dequeobject +Return state information for pickling. +[clinic start generated code]*/ +static PyObject * +deque___reduce___impl(dequeobject *deque) +/*[clinic end generated code: output=cb85d9e0b7d2c5ad input=991a933a5bc7a526]*/ +{ +PyObject *state, *it; +state = _PyObject_GetState((PyObject *)deque); +if (state == NULL) { +return NULL; +} +it = PyObject_GetIter((PyObject *)deque); +if (it == NULL) { +Py_DECREF(state); +return NULL; +} +// It's safe to access deque->maxlen here without holding the per object +// lock for deque; deque->maxlen is only assigned during construction. +if (deque->maxlen < 0) { +return Py_BuildValue("O()NN", Py_TYPE(deque), state, it); +} +else { +return Py_BuildValue("O(()n)NN", Py_TYPE(deque), deque->maxlen, state, it); +} +} +PyDoc_STRVAR(reduce_doc, "Return state information for pickling."); +static PyObject * +deque_repr(PyObject *deque) +{ +PyObject *aslist, *result; +int i; +i = Py_ReprEnter(deque); +if (i != 0) { +if (i < 0) +return NULL; +return PyUnicode_FromString("[...]"); +} +aslist = PySequence_List(deque); +if (aslist == NULL) { +Py_ReprLeave(deque); +return NULL; +} +Py_ssize_t maxlen = dequeobject_CAST(deque)->maxlen; +if (maxlen >= 0) +result = PyUnicode_FromFormat("%s(%R, maxlen=%zd)", +_PyType_Name(Py_TYPE(deque)), aslist, +maxlen); +else +result = PyUnicode_FromFormat("%s(%R)", +_PyType_Name(Py_TYPE(deque)), aslist); +Py_ReprLeave(deque); +Py_DECREF(aslist); +return result; +} +static PyObject * +deque_richcompare(PyObject *v, PyObject *w, int op) +{ +PyObject *it1=NULL, *it2=NULL, *x, *y; +Py_ssize_t vs, ws; +int b, cmp=-1; +collections_state *state = find_module_state_by_def(Py_TYPE(v)); +if (!PyObject_TypeCheck(v, state->deque_type) || +!PyObject_TypeCheck(w, state->deque_type)) { +Py_RETURN_NOTIMPLEMENTED; +} +/* Shortcuts */ +vs = Py_SIZE(v); +ws = Py_SIZE(w); +if (op == Py_EQ) { +if (v == w) +Py_RETURN_TRUE; +if (vs != ws) +Py_RETURN_FALSE; +} +if (op == Py_NE) { +if (v == w) +Py_RETURN_FALSE; +if (vs != ws) +Py_RETURN_TRUE; +} +/* Search for the first index where items are different */ +it1 = PyObject_GetIter(v); +if (it1 == NULL) +goto done; +it2 = PyObject_GetIter(w); +if (it2 == NULL) +goto done; +for (;;) { +x = PyIter_Next(it1); +if (x == NULL && PyErr_Occurred()) +goto done; +y = PyIter_Next(it2); +if (x == NULL || y == NULL) +break; +b = PyObject_RichCompareBool(x, y, Py_EQ); +if (b == 0) { +cmp = PyObject_RichCompareBool(x, y, op); +Py_DECREF(x); +Py_DECREF(y); +goto done; +} +Py_DECREF(x); +Py_DECREF(y); +if (b < 0) +goto done; +} +/* We reached the end of one deque or both */ +Py_XDECREF(x); +Py_XDECREF(y); +if (PyErr_Occurred()) +goto done; +switch (op) { +case Py_LT: cmp = y != NULL; break; /* if w was longer */ +case Py_LE: cmp = x == NULL; break; /* if v was not longer */ +case Py_EQ: cmp = x == y; break; /* if we reached the end of both */ +case Py_NE: cmp = x != y; break; /* if one deque continues */ +case Py_GT: cmp = x != NULL; break; /* if v was longer */ +case Py_GE: cmp = y == NULL; break; /* if w was not longer */ +} +done: +Py_XDECREF(it1); +Py_XDECREF(it2); +if (cmp == 1) +Py_RETURN_TRUE; +if (cmp == 0) +Py_RETURN_FALSE; +return NULL; +} +/*[clinic input] +@critical_section +@text_signature "([iterable[, maxlen]])" +_collections.deque.__init__ as deque_init +deque: dequeobject +iterable: object = NULL +maxlen as maxlenobj: object = NULL +A list-like sequence optimized for data accesses near its endpoints. +[clinic start generated code]*/ +static int +deque_init_impl(dequeobject *deque, PyObject *iterable, PyObject *maxlenobj) +/*[clinic end generated code: output=7084a39d71218dcd input=2b9e37af1fd73143]*/ +{ +Py_ssize_t maxlen = -1; +if (maxlenobj != NULL && maxlenobj != Py_None) { +maxlen = PyLong_AsSsize_t(maxlenobj); +if (maxlen == -1 && PyErr_Occurred()) +return -1; +if (maxlen < 0) { +PyErr_SetString(PyExc_ValueError, "maxlen must be non-negative"); +return -1; +} +} +deque->maxlen = maxlen; +if (Py_SIZE(deque) > 0) +(void)deque_clear((PyObject *)deque); +if (iterable != NULL) { +PyObject *rv = deque_extend_impl(deque, iterable); +if (rv == NULL) +return -1; +Py_DECREF(rv); +} +return 0; +} +/*[clinic input] +@critical_section +_collections.deque.__sizeof__ as deque___sizeof__ +deque: dequeobject +Return the size of the deque in memory, in bytes. +[clinic start generated code]*/ +static PyObject * +deque___sizeof___impl(dequeobject *deque) +/*[clinic end generated code: output=4d36e9fb4f30bbaf input=762312f2d4813535]*/ +{ +size_t res = _PyObject_SIZE(Py_TYPE(deque)); +size_t blocks; +blocks = (size_t)(deque->leftindex + Py_SIZE(deque) + BLOCKLEN - 1) / BLOCKLEN; +assert(((size_t)deque->leftindex + (size_t)Py_SIZE(deque) - 1) == +((blocks - 1) * BLOCKLEN + (size_t)deque->rightindex)); +res += blocks * sizeof(block); +return PyLong_FromSize_t(res); +} +static PyObject * +deque_get_maxlen(PyObject *self, void *Py_UNUSED(closure)) +{ +dequeobject *deque = dequeobject_CAST(self); +if (deque->maxlen < 0) +Py_RETURN_NONE; +return PyLong_FromSsize_t(deque->maxlen); +} +static PyObject *deque_reviter(dequeobject *deque); +/*[clinic input] +_collections.deque.__reversed__ as deque___reversed__ +deque: dequeobject +Return a reverse iterator over the deque. +[clinic start generated code]*/ +static PyObject * +deque___reversed___impl(dequeobject *deque) +/*[clinic end generated code: output=3e7e7e715883cf2e input=3d494c25a6fe5c7e]*/ +{ +return deque_reviter(deque); +} +/* deque object ********************************************************/ +static PyGetSetDef deque_getset[] = { +{"maxlen", deque_get_maxlen, NULL, +"maximum size of a deque or None if unbounded"}, +{0} +}; +static PyObject *deque_iter(PyObject *deque); +static PyMethodDef deque_methods[] = { +DEQUE_APPEND_METHODDEF +DEQUE_APPENDLEFT_METHODDEF +DEQUE_CLEARMETHOD_METHODDEF +DEQUE___COPY___METHODDEF +DEQUE_COPY_METHODDEF +DEQUE_COUNT_METHODDEF +DEQUE_EXTEND_METHODDEF +DEQUE_EXTENDLEFT_METHODDEF +DEQUE_INDEX_METHODDEF +DEQUE_INSERT_METHODDEF +DEQUE_POP_METHODDEF +DEQUE_POPLEFT_METHODDEF +DEQUE___REDUCE___METHODDEF +DEQUE_REMOVE_METHODDEF +DEQUE___REVERSED___METHODDEF +DEQUE_REVERSE_METHODDEF +DEQUE_ROTATE_METHODDEF +DEQUE___SIZEOF___METHODDEF +{"__class_getitem__", Py_GenericAlias, +METH_O|METH_CLASS, PyDoc_STR("See PEP 585")}, +{NULL, NULL} /* sentinel */ +}; +static PyMemberDef deque_members[] = { +{"__weaklistoffset__", Py_T_PYSSIZET, offsetof(dequeobject, weakreflist), Py_READONLY}, +{NULL}, +}; +static PyType_Slot deque_slots[] = { +{Py_tp_dealloc, deque_dealloc}, +{Py_tp_repr, deque_repr}, +{Py_tp_hash, PyObject_HashNotImplemented}, +{Py_tp_getattro, PyObject_GenericGetAttr}, +{Py_tp_doc, (void *)deque_init__doc__}, +{Py_tp_traverse, deque_traverse}, +{Py_tp_clear, deque_clear}, +{Py_tp_richcompare, deque_richcompare}, +{Py_tp_iter, deque_iter}, +{Py_tp_getset, deque_getset}, +{Py_tp_init, deque_init}, +{Py_tp_alloc, PyType_GenericAlloc}, +{Py_tp_new, deque_new}, +{Py_tp_free, PyObject_GC_Del}, +{Py_tp_methods, deque_methods}, +{Py_tp_members, deque_members}, +// Sequence protocol +{Py_sq_length, deque_len}, +{Py_sq_concat, deque_concat}, +{Py_sq_repeat, deque_repeat}, +{Py_sq_item, deque_item}, +{Py_sq_ass_item, deque_ass_item}, +{Py_sq_contains, deque_contains}, +{Py_sq_inplace_concat, deque_inplace_concat}, +{Py_sq_inplace_repeat, deque_inplace_repeat}, +{0, NULL}, +}; +static PyType_Spec deque_spec = { +.name = "collections.deque", +.basicsize = sizeof(dequeobject), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | +Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_SEQUENCE | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = deque_slots, +}; +/*********************** Deque Iterator **************************/ +typedef struct { +PyObject_HEAD +block *b; +Py_ssize_t index; +dequeobject *deque; +size_t state; /* state when the iterator is created */ +Py_ssize_t counter; /* number of items remaining for iteration */ +} dequeiterobject; +#define dequeiterobject_CAST(op) ((dequeiterobject *)(op)) +static PyObject * +deque_iter(PyObject *self) +{ +dequeiterobject *it; +dequeobject *deque = dequeobject_CAST(self); +collections_state *state = find_module_state_by_def(Py_TYPE(deque)); +it = PyObject_GC_New(dequeiterobject, state->dequeiter_type); +if (it == NULL) +return NULL; +Py_BEGIN_CRITICAL_SECTION(deque); +it->b = deque->leftblock; +it->index = deque->leftindex; +it->deque = (dequeobject*)Py_NewRef(deque); +it->state = deque->state; +it->counter = Py_SIZE(deque); +Py_END_CRITICAL_SECTION(); +PyObject_GC_Track(it); +return (PyObject *)it; +} +static int +dequeiter_traverse(PyObject *op, visitproc visit, void *arg) +{ +dequeiterobject *dio = dequeiterobject_CAST(op); +Py_VISIT(Py_TYPE(dio)); +Py_VISIT(dio->deque); +return 0; +} +static int +dequeiter_clear(PyObject *op) +{ +dequeiterobject *dio = dequeiterobject_CAST(op); +Py_CLEAR(dio->deque); +return 0; +} +static void +dequeiter_dealloc(PyObject *dio) +{ +/* bpo-31095: UnTrack is needed before calling any callbacks */ +PyTypeObject *tp = Py_TYPE(dio); +PyObject_GC_UnTrack(dio); +(void)dequeiter_clear(dio); +PyObject_GC_Del(dio); +Py_DECREF(tp); +} +static PyObject * +dequeiter_next_lock_held(dequeiterobject *it, dequeobject *deque) +{ +PyObject *item; +if (it->deque->state != it->state) { +it->counter = 0; +PyErr_SetString(PyExc_RuntimeError, +"deque mutated during iteration"); +return NULL; +} +if (it->counter == 0) +return NULL; +assert (!(it->b == it->deque->rightblock && +it->index > it->deque->rightindex)); +item = it->b->data[it->index]; +it->index++; +it->counter--; +if (it->index == BLOCKLEN && it->counter > 0) { +CHECK_NOT_END(it->b->rightlink); +it->b = it->b->rightlink; +it->index = 0; +} +return Py_NewRef(item); +} +static PyObject * +dequeiter_next(PyObject *op) +{ +PyObject *result; +dequeiterobject *it = dequeiterobject_CAST(op); +// It's safe to access it->deque without holding the per-object lock for it +// here; it->deque is only assigned during construction of it. +dequeobject *deque = it->deque; +Py_BEGIN_CRITICAL_SECTION2(it, deque); +result = dequeiter_next_lock_held(it, deque); +Py_END_CRITICAL_SECTION2(); +return result; +} +static PyObject * +dequeiter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ +Py_ssize_t i, index=0; +PyObject *deque; +dequeiterobject *it; +collections_state *state = get_module_state_by_cls(type); +if (!PyArg_ParseTuple(args, "O!|n", state->deque_type, &deque, &index)) +return NULL; +assert(type == state->dequeiter_type); +it = (dequeiterobject*)deque_iter(deque); +if (!it) +return NULL; +/* consume items from the queue */ +for(i=0; icounter) { +Py_DECREF(it); +return NULL; +} else +break; +} +} +return (PyObject*)it; +} +static PyObject * +dequeiter_len(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +dequeiterobject *it = dequeiterobject_CAST(op); +Py_ssize_t len = FT_ATOMIC_LOAD_SSIZE(it->counter); +return PyLong_FromSsize_t(len); +} +PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it))."); +static PyObject * +dequeiter_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +dequeiterobject *it = dequeiterobject_CAST(op); +PyTypeObject *ty = Py_TYPE(it); +// It's safe to access it->deque without holding the per-object lock for it +// here; it->deque is only assigned during construction of it. +dequeobject *deque = it->deque; +Py_ssize_t size, counter; +Py_BEGIN_CRITICAL_SECTION2(it, deque); +size = Py_SIZE(deque); +counter = it->counter; +Py_END_CRITICAL_SECTION2(); +return Py_BuildValue("O(On)", ty, deque, size - counter); +} +static PyMethodDef dequeiter_methods[] = { +{"__length_hint__", dequeiter_len, METH_NOARGS, length_hint_doc}, +{"__reduce__", dequeiter_reduce, METH_NOARGS, reduce_doc}, +{NULL, NULL} /* sentinel */ +}; +static PyType_Slot dequeiter_slots[] = { +{Py_tp_dealloc, dequeiter_dealloc}, +{Py_tp_getattro, PyObject_GenericGetAttr}, +{Py_tp_traverse, dequeiter_traverse}, +{Py_tp_clear, dequeiter_clear}, +{Py_tp_iter, PyObject_SelfIter}, +{Py_tp_iternext, dequeiter_next}, +{Py_tp_methods, dequeiter_methods}, +{Py_tp_new, dequeiter_new}, +{0, NULL}, +}; +static PyType_Spec dequeiter_spec = { +.name = "collections._deque_iterator", +.basicsize = sizeof(dequeiterobject), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = dequeiter_slots, +}; +/*********************** Deque Reverse Iterator **************************/ +static PyObject * +deque_reviter(dequeobject *deque) +{ +dequeiterobject *it; +collections_state *state = find_module_state_by_def(Py_TYPE(deque)); +it = PyObject_GC_New(dequeiterobject, state->dequereviter_type); +if (it == NULL) +return NULL; +Py_BEGIN_CRITICAL_SECTION(deque); +it->b = deque->rightblock; +it->index = deque->rightindex; +it->deque = (dequeobject*)Py_NewRef(deque); +it->state = deque->state; +it->counter = Py_SIZE(deque); +Py_END_CRITICAL_SECTION(); +PyObject_GC_Track(it); +return (PyObject *)it; +} +static PyObject * +dequereviter_next_lock_held(dequeiterobject *it, dequeobject *deque) +{ +PyObject *item; +if (it->counter == 0) +return NULL; +if (it->deque->state != it->state) { +it->counter = 0; +PyErr_SetString(PyExc_RuntimeError, +"deque mutated during iteration"); +return NULL; +} +assert (!(it->b == it->deque->leftblock && +it->index < it->deque->leftindex)); +item = it->b->data[it->index]; +it->index--; +it->counter--; +if (it->index < 0 && it->counter > 0) { +CHECK_NOT_END(it->b->leftlink); +it->b = it->b->leftlink; +it->index = BLOCKLEN - 1; +} +return Py_NewRef(item); +} +static PyObject * +dequereviter_next(PyObject *self) +{ +PyObject *item; +dequeiterobject *it = dequeiterobject_CAST(self); +// It's safe to access it->deque without holding the per-object lock for it +// here; it->deque is only assigned during construction of it. +dequeobject *deque = it->deque; +Py_BEGIN_CRITICAL_SECTION2(it, deque); +item = dequereviter_next_lock_held(it, deque); +Py_END_CRITICAL_SECTION2(); +return item; +} +static PyObject * +dequereviter_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ +Py_ssize_t i, index=0; +PyObject *deque; +dequeiterobject *it; +collections_state *state = get_module_state_by_cls(type); +if (!PyArg_ParseTuple(args, "O!|n", state->deque_type, &deque, &index)) +return NULL; +assert(type == state->dequereviter_type); +it = (dequeiterobject *)deque_reviter((dequeobject *)deque); +if (!it) +return NULL; +/* consume items from the queue */ +for(i=0; icounter) { +Py_DECREF(it); +return NULL; +} else +break; +} +} +return (PyObject*)it; +} +static PyType_Slot dequereviter_slots[] = { +{Py_tp_dealloc, dequeiter_dealloc}, +{Py_tp_getattro, PyObject_GenericGetAttr}, +{Py_tp_traverse, dequeiter_traverse}, +{Py_tp_clear, dequeiter_clear}, +{Py_tp_iter, PyObject_SelfIter}, +{Py_tp_iternext, dequereviter_next}, +{Py_tp_methods, dequeiter_methods}, +{Py_tp_new, dequereviter_new}, +{0, NULL}, +}; +static PyType_Spec dequereviter_spec = { +.name = "collections._deque_reverse_iterator", +.basicsize = sizeof(dequeiterobject), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = dequereviter_slots, +}; +/* defaultdict type *********************************************************/ +typedef struct { +PyDictObject dict; +PyObject *default_factory; +} defdictobject; +#define defdictobject_CAST(op) ((defdictobject *)(op)) +static PyType_Spec defdict_spec; +PyDoc_STRVAR(defdict_missing_doc, +"__missing__(key) # Called by __getitem__ for missing key; pseudo-code:\n\ +if self.default_factory is None: raise KeyError((key,))\n\ +self[key] = value = self.default_factory()\n\ +return value\n\ +"); +static PyObject * +defdict_missing(PyObject *op, PyObject *key) +{ +defdictobject *dd = defdictobject_CAST(op); +PyObject *factory = dd->default_factory; +PyObject *value; +if (factory == NULL || factory == Py_None) { +/* XXX Call dict.__missing__(key) */ +PyObject *tup; +tup = PyTuple_Pack(1, key); +if (!tup) return NULL; +PyErr_SetObject(PyExc_KeyError, tup); +Py_DECREF(tup); +return NULL; +} +value = _PyObject_CallNoArgs(factory); +if (value == NULL) +return value; +PyObject *result = NULL; +(void)PyDict_SetDefaultRef(op, key, value, &result); +// 'result' is NULL, or a strong reference to 'value' or 'op[key]' +Py_DECREF(value); +return result; +} +static inline PyObject* +new_defdict(PyObject *op, PyObject *arg) +{ +defdictobject *dd = defdictobject_CAST(op); +return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd), +dd->default_factory ? dd->default_factory : Py_None, arg, NULL); +} +PyDoc_STRVAR(defdict_copy_doc, "D.copy() -> a shallow copy of D."); +static PyObject * +defdict_copy(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +/* This calls the object's class. That only works for subclasses +whose class constructor has the same signature. Subclasses that +define a different constructor signature must override copy(). +*/ +return new_defdict(op, op); +} +static PyObject * +defdict_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +/* __reduce__ must return a 5-tuple as follows: +- factory function +- tuple of args for the factory function +- additional state (here None) +- sequence iterator (here None) +- dictionary iterator (yielding successive (key, value) pairs +This API is used by pickle.py and copy.py. +For this to be useful with pickle.py, the default_factory +must be picklable; e.g., None, a built-in, or a global +function in a module or package. +Both shallow and deep copying are supported, but for deep +copying, the default_factory must be deep-copyable; e.g. None, +or a built-in (functions are not copyable at this time). +This only works for subclasses as long as their constructor +signature is compatible; the first argument must be the +optional default_factory, defaulting to None. +*/ +PyObject *args; +PyObject *items; +PyObject *iter; +PyObject *result; +defdictobject *dd = defdictobject_CAST(op); +if (dd->default_factory == NULL || dd->default_factory == Py_None) +args = PyTuple_New(0); +else +args = PyTuple_Pack(1, dd->default_factory); +if (args == NULL) +return NULL; +items = PyObject_CallMethodNoArgs(op, &_Py_ID(items)); +if (items == NULL) { +Py_DECREF(args); +return NULL; +} +iter = PyObject_GetIter(items); +if (iter == NULL) { +Py_DECREF(items); +Py_DECREF(args); +return NULL; +} +result = PyTuple_Pack(5, Py_TYPE(dd), args, +Py_None, Py_None, iter); +Py_DECREF(iter); +Py_DECREF(items); +Py_DECREF(args); +return result; +} +static PyMethodDef defdict_methods[] = { +{"__missing__", defdict_missing, METH_O, +defdict_missing_doc}, +{"copy", defdict_copy, METH_NOARGS, +defdict_copy_doc}, +{"__copy__", defdict_copy, METH_NOARGS, +defdict_copy_doc}, +{"__reduce__", defdict_reduce, METH_NOARGS, +reduce_doc}, +{"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS, +PyDoc_STR("See PEP 585")}, +{NULL} +}; +static PyMemberDef defdict_members[] = { +{"default_factory", _Py_T_OBJECT, +offsetof(defdictobject, default_factory), 0, +PyDoc_STR("Factory for default value called by __missing__().")}, +{NULL} +}; +static void +defdict_dealloc(PyObject *op) +{ +defdictobject *dd = defdictobject_CAST(op); +/* bpo-31095: UnTrack is needed before calling any callbacks */ +PyTypeObject *tp = Py_TYPE(dd); +PyObject_GC_UnTrack(dd); +Py_CLEAR(dd->default_factory); +PyDict_Type.tp_dealloc(op); +Py_DECREF(tp); +} +static PyObject * +defdict_repr(PyObject *op) +{ +defdictobject *dd = defdictobject_CAST(op); +PyObject *baserepr; +PyObject *defrepr; +PyObject *result; +baserepr = PyDict_Type.tp_repr(op); +if (baserepr == NULL) +return NULL; +if (dd->default_factory == NULL) +defrepr = PyUnicode_FromString("None"); +else +{ +int status = Py_ReprEnter(dd->default_factory); +if (status != 0) { +if (status < 0) { +Py_DECREF(baserepr); +return NULL; +} +defrepr = PyUnicode_FromString("..."); +} +else +defrepr = PyObject_Repr(dd->default_factory); +Py_ReprLeave(dd->default_factory); +} +if (defrepr == NULL) { +Py_DECREF(baserepr); +return NULL; +} +result = PyUnicode_FromFormat("%s(%U, %U)", +_PyType_Name(Py_TYPE(dd)), +defrepr, baserepr); +Py_DECREF(defrepr); +Py_DECREF(baserepr); +return result; +} +static PyObject* +defdict_or(PyObject* left, PyObject* right) +{ +PyObject *self, *other; +int ret = PyType_GetBaseByToken(Py_TYPE(left), &defdict_spec, NULL); +if (ret < 0) { +return NULL; +} +if (ret) { +self = left; +other = right; +} +else { +assert(PyType_GetBaseByToken(Py_TYPE(right), &defdict_spec, NULL) == 1); +self = right; +other = left; +} +if (!PyDict_Check(other)) { +Py_RETURN_NOTIMPLEMENTED; +} +// Like copy(), this calls the object's class. +// Override __or__/__ror__ for subclasses with different constructors. +PyObject *new = new_defdict(self, left); +if (!new) { +return NULL; +} +if (PyDict_Update(new, right)) { +Py_DECREF(new); +return NULL; +} +return new; +} +static int +defdict_traverse(PyObject *op, visitproc visit, void *arg) +{ +defdictobject *self = defdictobject_CAST(op); +Py_VISIT(Py_TYPE(self)); +Py_VISIT(self->default_factory); +return PyDict_Type.tp_traverse(op, visit, arg); +} +static int +defdict_tp_clear(PyObject *op) +{ +defdictobject *dd = defdictobject_CAST(op); +Py_CLEAR(dd->default_factory); +return PyDict_Type.tp_clear(op); +} +static int +defdict_init(PyObject *self, PyObject *args, PyObject *kwds) +{ +defdictobject *dd = defdictobject_CAST(self); +PyObject *olddefault = dd->default_factory; +PyObject *newdefault = NULL; +PyObject *newargs; +int result; +if (args == NULL || !PyTuple_Check(args)) +newargs = PyTuple_New(0); +else { +Py_ssize_t n = PyTuple_GET_SIZE(args); +if (n > 0) { +newdefault = PyTuple_GET_ITEM(args, 0); +if (!PyCallable_Check(newdefault) && newdefault != Py_None) { +PyErr_SetString(PyExc_TypeError, +"first argument must be callable or None"); +return -1; +} +} +newargs = PySequence_GetSlice(args, 1, n); +} +if (newargs == NULL) +return -1; +dd->default_factory = Py_XNewRef(newdefault); +result = PyDict_Type.tp_init(self, newargs, kwds); +Py_DECREF(newargs); +Py_XDECREF(olddefault); +return result; +} +PyDoc_STRVAR(defdict_doc, +"defaultdict(default_factory=None, /, [...]) --> dict with default factory\n\ +\n\ +The default factory is called without arguments to produce\n\ +a new value when a key is not present, in __getitem__ only.\n\ +A defaultdict compares equal to a dict with the same items.\n\ +All remaining arguments are treated the same as if they were\n\ +passed to the dict constructor, including keyword arguments.\n\ +"); +/* See comment in xxsubtype.c */ +#define DEFERRED_ADDRESS(ADDR) 0 +static PyType_Slot defdict_slots[] = { +{Py_tp_token, Py_TP_USE_SPEC}, +{Py_tp_dealloc, defdict_dealloc}, +{Py_tp_repr, defdict_repr}, +{Py_nb_or, defdict_or}, +{Py_tp_getattro, PyObject_GenericGetAttr}, +{Py_tp_doc, (void *)defdict_doc}, +{Py_tp_traverse, defdict_traverse}, +{Py_tp_clear, defdict_tp_clear}, +{Py_tp_methods, defdict_methods}, +{Py_tp_members, defdict_members}, +{Py_tp_init, defdict_init}, +{Py_tp_alloc, PyType_GenericAlloc}, +{Py_tp_free, PyObject_GC_Del}, +{0, NULL}, +}; +static PyType_Spec defdict_spec = { +.name = "collections.defaultdict", +.basicsize = sizeof(defdictobject), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = defdict_slots, +}; +/* helper function for Counter *********************************************/ +/*[clinic input] +_collections._count_elements +mapping: object +iterable: object +/ +Count elements in the iterable, updating the mapping +[clinic start generated code]*/ +static PyObject * +_collections__count_elements_impl(PyObject *module, PyObject *mapping, +PyObject *iterable) +/*[clinic end generated code: output=7e0c1789636b3d8f input=e79fad04534a0b45]*/ +{ +PyObject *it, *oldval; +PyObject *newval = NULL; +PyObject *key = NULL; +PyObject *bound_get = NULL; +PyObject *mapping_get; +PyObject *dict_get; +PyObject *mapping_setitem; +PyObject *dict_setitem; +PyObject *one = _PyLong_GetOne(); // borrowed reference +it = PyObject_GetIter(iterable); +if (it == NULL) +return NULL; +/* Only take the fast path when get() and __setitem__() +* have not been overridden. +*/ +mapping_get = _PyType_LookupRef(Py_TYPE(mapping), &_Py_ID(get)); +dict_get = _PyType_Lookup(&PyDict_Type, &_Py_ID(get)); +mapping_setitem = _PyType_LookupRef(Py_TYPE(mapping), &_Py_ID(__setitem__)); +dict_setitem = _PyType_Lookup(&PyDict_Type, &_Py_ID(__setitem__)); +if (mapping_get != NULL && mapping_get == dict_get && +mapping_setitem != NULL && mapping_setitem == dict_setitem && +PyDict_Check(mapping)) +{ +while (1) { +/* Fast path advantages: +1. Eliminate double hashing +(by re-using the same hash for both the get and set) +2. Avoid argument overhead of PyObject_CallFunctionObjArgs +(argument tuple creation and parsing) +3. Avoid indirection through a bound method object +(creates another argument tuple) +4. Avoid initial increment from zero +(reuse an existing one-object instead) +*/ +Py_hash_t hash; +key = PyIter_Next(it); +if (key == NULL) +break; +hash = _PyObject_HashFast(key); +if (hash == -1) { +goto done; +} +oldval = _PyDict_GetItem_KnownHash(mapping, key, hash); +if (oldval == NULL) { +if (PyErr_Occurred()) +goto done; +if (_PyDict_SetItem_KnownHash(mapping, key, one, hash) < 0) +goto done; +} else { +/* oldval is a borrowed reference. Keep it alive across +PyNumber_Add(), which can execute arbitrary user code and +mutate (or even clear) the underlying dict. */ +Py_INCREF(oldval); +newval = PyNumber_Add(oldval, one); +Py_DECREF(oldval); +if (newval == NULL) +goto done; +if (_PyDict_SetItem_KnownHash(mapping, key, newval, hash) < 0) +goto done; +Py_CLEAR(newval); +} +Py_DECREF(key); +} +} +else { +bound_get = PyObject_GetAttr(mapping, &_Py_ID(get)); +if (bound_get == NULL) +goto done; +PyObject *zero = _PyLong_GetZero(); // borrowed reference +while (1) { +key = PyIter_Next(it); +if (key == NULL) +break; +oldval = PyObject_CallFunctionObjArgs(bound_get, key, zero, NULL); +if (oldval == NULL) +break; +if (oldval == zero) { +newval = Py_NewRef(one); +} else { +newval = PyNumber_Add(oldval, one); +} +Py_DECREF(oldval); +if (newval == NULL) +break; +if (PyObject_SetItem(mapping, key, newval) < 0) +break; +Py_CLEAR(newval); +Py_DECREF(key); +} +} +done: +Py_XDECREF(mapping_get); +Py_XDECREF(mapping_setitem); +Py_DECREF(it); +Py_XDECREF(key); +Py_XDECREF(newval); +Py_XDECREF(bound_get); +if (PyErr_Occurred()) +return NULL; +Py_RETURN_NONE; +} +/* Helper function for namedtuple() ************************************/ +typedef struct { +PyObject_HEAD +Py_ssize_t index; +PyObject* doc; +} _tuplegetterobject; +#define tuplegetterobject_CAST(op) ((_tuplegetterobject *)(op)) +/*[clinic input] +@classmethod +_tuplegetter.__new__ as tuplegetter_new +index: Py_ssize_t +doc: object +/ +[clinic start generated code]*/ +static PyObject * +tuplegetter_new_impl(PyTypeObject *type, Py_ssize_t index, PyObject *doc) +/*[clinic end generated code: output=014be444ad80263f input=87c576a5bdbc0bbb]*/ +{ +_tuplegetterobject* self; +self = (_tuplegetterobject *)type->tp_alloc(type, 0); +if (self == NULL) { +return NULL; +} +self->index = index; +self->doc = Py_NewRef(doc); +return (PyObject *)self; +} +static PyObject * +tuplegetter_descr_get(PyObject *self, PyObject *obj, PyObject *type) +{ +Py_ssize_t index = tuplegetterobject_CAST(self)->index; +PyObject *result; +if (obj == NULL) { +return Py_NewRef(self); +} +if (!PyTuple_Check(obj)) { +if (obj == Py_None) { +return Py_NewRef(self); +} +PyErr_Format(PyExc_TypeError, +"descriptor for index '%zd' for tuple subclasses " +"doesn't apply to '%s' object", +index, +Py_TYPE(obj)->tp_name); +return NULL; +} +if (!valid_index(index, PyTuple_GET_SIZE(obj))) { +PyErr_SetString(PyExc_IndexError, "tuple index out of range"); +return NULL; +} +result = PyTuple_GET_ITEM(obj, index); +return Py_NewRef(result); +} +static int +tuplegetter_descr_set(PyObject *self, PyObject *obj, PyObject *value) +{ +if (value == NULL) { +PyErr_SetString(PyExc_AttributeError, "can't delete attribute"); +} else { +PyErr_SetString(PyExc_AttributeError, "can't set attribute"); +} +return -1; +} +static int +tuplegetter_traverse(PyObject *self, visitproc visit, void *arg) +{ +_tuplegetterobject *tuplegetter = tuplegetterobject_CAST(self); +Py_VISIT(Py_TYPE(tuplegetter)); +Py_VISIT(tuplegetter->doc); +return 0; +} +static int +tuplegetter_clear(PyObject *self) +{ +_tuplegetterobject *tuplegetter = tuplegetterobject_CAST(self); +Py_CLEAR(tuplegetter->doc); +return 0; +} +static void +tuplegetter_dealloc(PyObject *self) +{ +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +(void)tuplegetter_clear(self); +tp->tp_free(self); +Py_DECREF(tp); +} +static PyObject* +tuplegetter_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +_tuplegetterobject *self = tuplegetterobject_CAST(op); +return Py_BuildValue("(O(nO))", (PyObject *)Py_TYPE(self), +self->index, self->doc); +} +static PyObject* +tuplegetter_repr(PyObject *op) +{ +_tuplegetterobject *self = tuplegetterobject_CAST(op); +return PyUnicode_FromFormat("%s(%zd, %R)", +_PyType_Name(Py_TYPE(self)), +self->index, self->doc); +} +static PyMemberDef tuplegetter_members[] = { +{"__doc__", _Py_T_OBJECT, offsetof(_tuplegetterobject, doc), 0}, +{0} +}; +static PyMethodDef tuplegetter_methods[] = { +{"__reduce__", tuplegetter_reduce, METH_NOARGS, NULL}, +{NULL}, +}; +static PyType_Slot tuplegetter_slots[] = { +{Py_tp_dealloc, tuplegetter_dealloc}, +{Py_tp_repr, tuplegetter_repr}, +{Py_tp_traverse, tuplegetter_traverse}, +{Py_tp_clear, tuplegetter_clear}, +{Py_tp_methods, tuplegetter_methods}, +{Py_tp_members, tuplegetter_members}, +{Py_tp_descr_get, tuplegetter_descr_get}, +{Py_tp_descr_set, tuplegetter_descr_set}, +{Py_tp_new, tuplegetter_new}, +{0, NULL}, +}; +static PyType_Spec tuplegetter_spec = { +.name = "collections._tuplegetter", +.basicsize = sizeof(_tuplegetterobject), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = tuplegetter_slots, +}; +/* module level code ********************************************************/ +static int +collections_traverse(PyObject *mod, visitproc visit, void *arg) +{ +collections_state *state = get_module_state(mod); +Py_VISIT(state->deque_type); +Py_VISIT(state->defdict_type); +Py_VISIT(state->dequeiter_type); +Py_VISIT(state->dequereviter_type); +Py_VISIT(state->tuplegetter_type); +return 0; +} +static int +collections_clear(PyObject *mod) +{ +collections_state *state = get_module_state(mod); +Py_CLEAR(state->deque_type); +Py_CLEAR(state->defdict_type); +Py_CLEAR(state->dequeiter_type); +Py_CLEAR(state->dequereviter_type); +Py_CLEAR(state->tuplegetter_type); +return 0; +} +static void +collections_free(void *module) +{ +(void)collections_clear((PyObject *)module); +} +PyDoc_STRVAR(collections_doc, +"High performance data structures.\n\ +- deque: ordered collection accessible from endpoints only\n\ +- defaultdict: dict subclass with a default value factory\n\ +"); +static struct PyMethodDef collections_methods[] = { +_COLLECTIONS__COUNT_ELEMENTS_METHODDEF +{NULL, NULL} /* sentinel */ +}; +#define ADD_TYPE(MOD, SPEC, TYPE, BASE) do { \ +TYPE = (PyTypeObject *)PyType_FromMetaclass(NULL, MOD, SPEC, \ +(PyObject *)BASE); \ +if (TYPE == NULL) { \ +return -1; \ +} \ +if (PyModule_AddType(MOD, TYPE) < 0) { \ +return -1; \ +} \ +} while (0) +static int +collections_exec(PyObject *module) { +collections_state *state = get_module_state(module); +ADD_TYPE(module, &deque_spec, state->deque_type, NULL); +ADD_TYPE(module, &defdict_spec, state->defdict_type, &PyDict_Type); +ADD_TYPE(module, &dequeiter_spec, state->dequeiter_type, NULL); +ADD_TYPE(module, &dequereviter_spec, state->dequereviter_type, NULL); +ADD_TYPE(module, &tuplegetter_spec, state->tuplegetter_type, NULL); +if (PyModule_AddType(module, &PyODict_Type) < 0) { +return -1; +} +return 0; +} +#undef ADD_TYPE +static struct PyModuleDef_Slot collections_slots[] = { +{Py_mod_exec, collections_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL} +}; +static struct PyModuleDef _collectionsmodule = { +.m_base = PyModuleDef_HEAD_INIT, +.m_name = "_collections", +.m_doc = collections_doc, +.m_size = sizeof(collections_state), +.m_methods = collections_methods, +.m_slots = collections_slots, +.m_traverse = collections_traverse, +.m_clear = collections_clear, +.m_free = collections_free, +}; +PyMODINIT_FUNC +PyInit__collections(void) +{ +return PyModuleDef_Init(&_collectionsmodule); +} + +/* +* C extensions module to test importing multiple modules from one compiled +* file (issue16421). This file defines 3 modules (_testimportmodule, +* foo, bar), only the first one is called the same as the compiled file. +*/ +#include "pyconfig.h" // Py_GIL_DISABLED +#ifndef Py_GIL_DISABLED +# define Py_LIMITED_API 0x030d0000 +#endif +#include +static PyModuleDef_Slot shared_slots[] = { +{Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL}, +}; +static struct PyModuleDef _testimportmultiple = { +PyModuleDef_HEAD_INIT, +"_testimportmultiple", +"_testimportmultiple doc", +0, +NULL, +shared_slots, +NULL, +NULL, +NULL +}; +PyMODINIT_FUNC PyInit__testimportmultiple(void) +{ +return PyModuleDef_Init(&_testimportmultiple); +} +static struct PyModuleDef _foomodule = { +PyModuleDef_HEAD_INIT, +"_testimportmultiple_foo", +"_testimportmultiple_foo doc", +0, +NULL, +shared_slots, +NULL, +NULL, +NULL +}; +PyMODINIT_FUNC PyInit__testimportmultiple_foo(void) +{ +return PyModuleDef_Init(&_foomodule); +} +static struct PyModuleDef _barmodule = { +PyModuleDef_HEAD_INIT, +"_testimportmultiple_bar", +"_testimportmultiple_bar doc", +0, +NULL, +shared_slots, +NULL, +NULL, +NULL +}; +PyMODINIT_FUNC PyInit__testimportmultiple_bar(void){ +return PyModuleDef_Init(&_barmodule); +} + +/* Time module */ +#include "Python.h" +#include "pycore_fileutils.h" // _Py_BEGIN_SUPPRESS_IPH +#include "pycore_moduleobject.h" // _PyModule_GetState() +#include "pycore_namespace.h" // _PyNamespace_New() +#include "pycore_runtime.h" // _Py_ID() +#include "pycore_time.h" // _PyTimeFraction +#include // clock() +#ifdef HAVE_SYS_TIMES_H +# include // times() +#endif +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#if defined(HAVE_SYS_RESOURCE_H) +# include // getrusage(RUSAGE_SELF) +#endif +#ifdef QUICKWIN +# include +#endif +#if defined(HAVE_PTHREAD_H) +# include // pthread_getcpuclockid() +#endif +#if defined(_AIX) +# include +#endif +#if defined(__WATCOMC__) && !defined(__QNX__) +# include +#else +# ifdef MS_WINDOWS +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include +# endif /* MS_WINDOWS */ +#endif /* !__WATCOMC__ || __QNX__ */ +#ifdef _Py_MEMORY_SANITIZER +# include +#endif +#ifdef _MSC_VER +# define _Py_timezone _timezone +# define _Py_daylight _daylight +# define _Py_tzname _tzname +#else +# define _Py_timezone timezone +# define _Py_daylight daylight +# define _Py_tzname tzname +#endif +#if defined(__APPLE__ ) && defined(__has_builtin) +# if __has_builtin(__builtin_available) +# define HAVE_CLOCK_GETTIME_RUNTIME __builtin_available(macOS 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *) +# endif +#endif +#ifndef HAVE_CLOCK_GETTIME_RUNTIME +# define HAVE_CLOCK_GETTIME_RUNTIME 1 +#endif +#define SEC_TO_NS (1000 * 1000 * 1000) +/*[clinic input] +module time +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a668a08771581f36]*/ +/* Forward declarations */ +static int pysleep(PyTime_t timeout); +typedef struct { +PyTypeObject *struct_time_type; +// gh-115714: Don't use times() on WASI. +#if defined(HAVE_TIMES) && !defined(__wasi__) +// times() clock frequency in hertz +_PyTimeFraction times_base; +#endif +#ifdef HAVE_CLOCK +// clock() frequency in hertz +_PyTimeFraction clock_base; +#endif +} time_module_state; +static inline time_module_state* +get_time_state(PyObject *module) +{ +void *state = _PyModule_GetState(module); +assert(state != NULL); +return (time_module_state *)state; +} +static PyObject* +_PyFloat_FromPyTime(PyTime_t t) +{ +double d = PyTime_AsSecondsDouble(t); +return PyFloat_FromDouble(d); +} +static PyObject * +time_time(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (PyTime_Time(&t) < 0) { +return NULL; +} +return _PyFloat_FromPyTime(t); +} +PyDoc_STRVAR(time_doc, +"time() -> floating-point number\n\ +\n\ +Return the current time in seconds since the Epoch.\n\ +Fractions of a second may be present if the system clock provides them."); +static PyObject * +time_time_ns(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (PyTime_Time(&t) < 0) { +return NULL; +} +return PyLong_FromInt64(t); +} +PyDoc_STRVAR(time_ns_doc, +"time_ns() -> int\n\ +\n\ +Return the current time in nanoseconds since the Epoch."); +#ifdef HAVE_CLOCK +#ifndef CLOCKS_PER_SEC +# ifdef CLK_TCK +# define CLOCKS_PER_SEC CLK_TCK +# else +# define CLOCKS_PER_SEC 1000000 +# endif +#endif +static int +py_clock(time_module_state *state, PyTime_t *tp, _Py_clock_info_t *info) +{ +_PyTimeFraction *base = &state->clock_base; +if (info) { +info->implementation = "clock()"; +info->resolution = _PyTimeFraction_Resolution(base); +info->monotonic = 1; +info->adjustable = 0; +} +clock_t ticks = clock(); +if (ticks == (clock_t)-1) { +PyErr_SetString(PyExc_RuntimeError, +"the processor time used is not available " +"or its value cannot be represented"); +return -1; +} +*tp = _PyTimeFraction_Mul(ticks, base); +return 0; +} +#endif /* HAVE_CLOCK */ +#ifdef HAVE_CLOCK_GETTIME +#ifdef __APPLE__ +/* +* The clock_* functions will be removed from the module +* dict entirely when the C API is not available. +*/ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunguarded-availability" +#endif +static int +time_clockid_converter(PyObject *obj, clockid_t *p) +{ +#ifdef _AIX +long long clk_id = PyLong_AsLongLong(obj); +#elif defined(__DragonFly__) || defined(__CYGWIN__) +long clk_id = PyLong_AsLong(obj); +#else +int clk_id = PyLong_AsInt(obj); +#endif +if (clk_id == -1 && PyErr_Occurred()) { +PyErr_Format(PyExc_TypeError, +"clk_id should be integer, not %s", +_PyType_Name(Py_TYPE(obj))); +return 0; +} +// Make sure that we picked the right type (check sizes type) +Py_BUILD_ASSERT(sizeof(clk_id) == sizeof(*p)); +*p = (clockid_t)clk_id; +return 1; +} +/*[python input] +class clockid_t_converter(CConverter): +type = "clockid_t" +converter = 'time_clockid_converter' +[python start generated code]*/ +/*[python end generated code: output=da39a3ee5e6b4b0d input=53867111501f46c8]*/ +/*[clinic input] +time.clock_gettime +clk_id: clockid_t +/ +Return the time of the specified clock clk_id as a float. +[clinic start generated code]*/ +static PyObject * +time_clock_gettime_impl(PyObject *module, clockid_t clk_id) +/*[clinic end generated code: output=832b9ebc03328020 input=7e89fcc42ca15e5d]*/ +{ +struct timespec tp; +int ret = clock_gettime(clk_id, &tp); +if (ret != 0) { +PyErr_SetFromErrno(PyExc_OSError); +return NULL; +} +return PyFloat_FromDouble(tp.tv_sec + tp.tv_nsec * 1e-9); +} +/*[clinic input] +time.clock_gettime_ns +clk_id: clockid_t +/ +Return the time of the specified clock clk_id as nanoseconds (int). +[clinic start generated code]*/ +static PyObject * +time_clock_gettime_ns_impl(PyObject *module, clockid_t clk_id) +/*[clinic end generated code: output=4a045c3a36e60044 input=aabc248db8c8e3e5]*/ +{ +struct timespec ts; +int ret = clock_gettime(clk_id, &ts); +if (ret != 0) { +PyErr_SetFromErrno(PyExc_OSError); +return NULL; +} +PyTime_t t; +if (_PyTime_FromTimespec(&t, &ts) < 0) { +return NULL; +} +return PyLong_FromInt64(t); +} +#endif /* HAVE_CLOCK_GETTIME */ +#ifdef HAVE_CLOCK_SETTIME +static PyObject * +time_clock_settime(PyObject *self, PyObject *args) +{ +int clk_id; +PyObject *obj; +PyTime_t t; +struct timespec tp; +int ret; +if (!PyArg_ParseTuple(args, "iO:clock_settime", &clk_id, &obj)) +return NULL; +if (_PyTime_FromSecondsObject(&t, obj, _PyTime_ROUND_FLOOR) < 0) +return NULL; +if (_PyTime_AsTimespec(t, &tp) == -1) +return NULL; +ret = clock_settime((clockid_t)clk_id, &tp); +if (ret != 0) { +PyErr_SetFromErrno(PyExc_OSError); +return NULL; +} +Py_RETURN_NONE; +} +PyDoc_STRVAR(clock_settime_doc, +"clock_settime(clk_id, time)\n\ +\n\ +Set the time of the specified clock clk_id."); +static PyObject * +time_clock_settime_ns(PyObject *self, PyObject *args) +{ +int clk_id; +PyObject *obj; +PyTime_t t; +struct timespec ts; +int ret; +if (!PyArg_ParseTuple(args, "iO:clock_settime", &clk_id, &obj)) { +return NULL; +} +if (PyLong_AsInt64(obj, &t) < 0) { +return NULL; +} +if (_PyTime_AsTimespec(t, &ts) == -1) { +return NULL; +} +ret = clock_settime((clockid_t)clk_id, &ts); +if (ret != 0) { +PyErr_SetFromErrno(PyExc_OSError); +return NULL; +} +Py_RETURN_NONE; +} +PyDoc_STRVAR(clock_settime_ns_doc, +"clock_settime_ns(clk_id, time)\n\ +\n\ +Set the time of the specified clock clk_id with nanoseconds."); +#endif /* HAVE_CLOCK_SETTIME */ +#ifdef HAVE_CLOCK_GETRES +static PyObject * +time_clock_getres(PyObject *self, PyObject *args) +{ +int ret; +int clk_id; +struct timespec tp; +if (!PyArg_ParseTuple(args, "i:clock_getres", &clk_id)) +return NULL; +ret = clock_getres((clockid_t)clk_id, &tp); +if (ret != 0) { +PyErr_SetFromErrno(PyExc_OSError); +return NULL; +} +return PyFloat_FromDouble(tp.tv_sec + tp.tv_nsec * 1e-9); +} +PyDoc_STRVAR(clock_getres_doc, +"clock_getres(clk_id) -> floating-point number\n\ +\n\ +Return the resolution (precision) of the specified clock clk_id."); +#ifdef __APPLE__ +#pragma clang diagnostic pop +#endif +#endif /* HAVE_CLOCK_GETRES */ +#ifdef HAVE_PTHREAD_GETCPUCLOCKID +static PyObject * +time_pthread_getcpuclockid(PyObject *self, PyObject *args) +{ +unsigned long thread_id; +int err; +clockid_t clk_id; +if (!PyArg_ParseTuple(args, "k:pthread_getcpuclockid", &thread_id)) { +return NULL; +} +err = pthread_getcpuclockid((pthread_t)thread_id, &clk_id); +if (err) { +errno = err; +PyErr_SetFromErrno(PyExc_OSError); +return NULL; +} +#ifdef _Py_MEMORY_SANITIZER +__msan_unpoison(&clk_id, sizeof(clk_id)); +#endif +return PyLong_FromLong(clk_id); +} +PyDoc_STRVAR(pthread_getcpuclockid_doc, +"pthread_getcpuclockid(thread_id) -> int\n\ +\n\ +Return the clk_id of a thread's CPU time clock."); +#endif /* HAVE_PTHREAD_GETCPUCLOCKID */ +static PyObject * +time_sleep(PyObject *self, PyObject *timeout_obj) +{ +if (PySys_Audit("time.sleep", "O", timeout_obj) < 0) { +return NULL; +} +PyTime_t timeout; +if (_PyTime_FromSecondsObject(&timeout, timeout_obj, _PyTime_ROUND_TIMEOUT)) +return NULL; +if (timeout < 0) { +PyErr_SetString(PyExc_ValueError, +"sleep length must be non-negative"); +return NULL; +} +if (pysleep(timeout) != 0) { +return NULL; +} +Py_RETURN_NONE; +} +PyDoc_STRVAR(sleep_doc, +"sleep(seconds)\n\ +\n\ +Delay execution for a given number of seconds. The argument may be\n\ +a floating-point number for subsecond precision."); +static PyStructSequence_Field struct_time_type_fields[] = { +{"tm_year", "year, for example, 1993"}, +{"tm_mon", "month of year, range [1, 12]"}, +{"tm_mday", "day of month, range [1, 31]"}, +{"tm_hour", "hours, range [0, 23]"}, +{"tm_min", "minutes, range [0, 59]"}, +{"tm_sec", "seconds, range [0, 61])"}, +{"tm_wday", "day of week, range [0, 6], Monday is 0"}, +{"tm_yday", "day of year, range [1, 366]"}, +{"tm_isdst", "1 if summer time is in effect, 0 if not, and -1 if unknown"}, +{"tm_zone", "abbreviation of timezone name"}, +{"tm_gmtoff", "offset from UTC in seconds"}, +{0} +}; +static PyStructSequence_Desc struct_time_type_desc = { +"time.struct_time", +"The time value as returned by gmtime(), localtime(), and strptime(), and\n" +" accepted by asctime(), mktime() and strftime(). May be considered as a\n" +" sequence of 9 integers.\n\n" +" Note that several fields' values are not the same as those defined by\n" +" the C language standard for struct tm. For example, the value of the\n" +" field tm_year is the actual year, not year - 1900. See individual\n" +" fields' descriptions for details.", +struct_time_type_fields, +9, +}; +#if defined(MS_WINDOWS) +#ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION +#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002 +#endif +static DWORD timer_flags = (DWORD)-1; +#endif +static PyObject * +tmtotuple(time_module_state *state, struct tm *p +#ifndef HAVE_STRUCT_TM_TM_ZONE +, const char *zone, time_t gmtoff +#endif +) +{ +PyObject *v = PyStructSequence_New(state->struct_time_type); +if (v == NULL) +return NULL; +#define SET_ITEM(INDEX, CALL) \ +do { \ +PyObject *obj = (CALL); \ +if (obj == NULL) { \ +Py_DECREF(v); \ +return NULL; \ +} \ +PyStructSequence_SET_ITEM(v, (INDEX), obj); \ +} while (0) +#define SET(INDEX, VAL) \ +SET_ITEM((INDEX), PyLong_FromLong((long) (VAL))) +SET(0, p->tm_year + 1900); +SET(1, p->tm_mon + 1); /* Want January == 1 */ +SET(2, p->tm_mday); +SET(3, p->tm_hour); +SET(4, p->tm_min); +SET(5, p->tm_sec); +SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */ +SET(7, p->tm_yday + 1); /* Want January, 1 == 1 */ +SET(8, p->tm_isdst); +#ifdef HAVE_STRUCT_TM_TM_ZONE +SET_ITEM(9, PyUnicode_DecodeLocale(p->tm_zone, "surrogateescape")); +SET(10, p->tm_gmtoff); +#else +SET_ITEM(9, PyUnicode_DecodeLocale(zone, "surrogateescape")); +SET_ITEM(10, _PyLong_FromTime_t(gmtoff)); +#endif /* HAVE_STRUCT_TM_TM_ZONE */ +#undef SET +#undef SET_ITEM +return v; +} +/* Parse arg tuple that can contain an optional float-or-None value; +format needs to be "|O:name". +Returns non-zero on success (parallels PyArg_ParseTuple). +*/ +static int +parse_time_t_args(PyObject *args, const char *format, time_t *pwhen) +{ +PyObject *ot = NULL; +time_t whent; +if (!PyArg_ParseTuple(args, format, &ot)) +return 0; +if (ot == NULL || ot == Py_None) { +whent = time(NULL); +} +else { +if (_PyTime_ObjectToTime_t(ot, &whent, _PyTime_ROUND_FLOOR) == -1) +return 0; +} +*pwhen = whent; +return 1; +} +static PyObject * +time_gmtime(PyObject *module, PyObject *args) +{ +time_t when; +struct tm buf; +if (!parse_time_t_args(args, "|O:gmtime", &when)) +return NULL; +errno = 0; +if (_PyTime_gmtime(when, &buf) != 0) +return NULL; +time_module_state *state = get_time_state(module); +#ifdef HAVE_STRUCT_TM_TM_ZONE +return tmtotuple(state, &buf); +#else +return tmtotuple(state, &buf, "UTC", 0); +#endif +} +#ifndef HAVE_TIMEGM +static time_t +timegm(struct tm *p) +{ +/* XXX: the following implementation will not work for tm_year < 1970. +but it is likely that platforms that don't have timegm do not support +negative timestamps anyways. */ +return p->tm_sec + p->tm_min*60 + p->tm_hour*3600 + p->tm_yday*86400 + +(p->tm_year-70)*31536000 + ((p->tm_year-69)/4)*86400 - +((p->tm_year-1)/100)*86400 + ((p->tm_year+299)/400)*86400; +} +#endif +PyDoc_STRVAR(gmtime_doc, +"gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n\ +tm_sec, tm_wday, tm_yday, tm_isdst)\n\ +\n\ +Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n\ +GMT). When 'seconds' is not passed in, convert the current time instead.\n\ +\n\ +If the platform supports the tm_gmtoff and tm_zone, they are available as\n\ +attributes only."); +static PyObject * +time_localtime(PyObject *module, PyObject *args) +{ +time_t when; +struct tm buf; +if (!parse_time_t_args(args, "|O:localtime", &when)) +return NULL; +if (_PyTime_localtime(when, &buf) != 0) +return NULL; +time_module_state *state = get_time_state(module); +#ifdef HAVE_STRUCT_TM_TM_ZONE +return tmtotuple(state, &buf); +#else +{ +struct tm local = buf; +char zone[100]; +time_t gmtoff; +strftime(zone, sizeof(zone), "%Z", &buf); +gmtoff = timegm(&buf) - when; +return tmtotuple(state, &local, zone, gmtoff); +} +#endif +} +#if defined(__linux__) && !defined(__GLIBC__) +static const char *utc_string = NULL; +#endif +PyDoc_STRVAR(localtime_doc, +"localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,\n\ +tm_sec,tm_wday,tm_yday,tm_isdst)\n\ +\n\ +Convert seconds since the Epoch to a time tuple expressing local time.\n\ +When 'seconds' is not passed in, convert the current time instead."); +/* Convert 9-item tuple to tm structure. Return 1 on success, set +* an exception and return 0 on error. +*/ +static int +gettmarg(time_module_state *state, PyObject *args, +struct tm *p, const char *format) +{ +int y; +memset((void *) p, '\0', sizeof(struct tm)); +if (!PyTuple_Check(args)) { +PyErr_SetString(PyExc_TypeError, +"Tuple or struct_time argument required"); +return 0; +} +if (!PyArg_ParseTuple(args, format, +&y, &p->tm_mon, &p->tm_mday, +&p->tm_hour, &p->tm_min, &p->tm_sec, +&p->tm_wday, &p->tm_yday, &p->tm_isdst)) +return 0; +if (y < INT_MIN + 1900) { +PyErr_SetString(PyExc_OverflowError, "year out of range"); +return 0; +} +p->tm_year = y - 1900; +p->tm_mon--; +p->tm_wday = (p->tm_wday + 1) % 7; +p->tm_yday--; +#ifdef HAVE_STRUCT_TM_TM_ZONE +if (Py_IS_TYPE(args, state->struct_time_type)) { +PyObject *item; +item = PyStructSequence_GET_ITEM(args, 9); +if (item != Py_None) { +p->tm_zone = (char *)PyUnicode_AsUTF8(item); +if (p->tm_zone == NULL) { +return 0; +} +#if defined(__linux__) && !defined(__GLIBC__) +// Make an attempt to return the C library's own timezone strings to +// it. musl refuses to process a tm_zone field unless it produced +// it. See issue #34672. +if (utc_string && strcmp(p->tm_zone, utc_string) == 0) { +p->tm_zone = utc_string; +} +else if (tzname[0] && strcmp(p->tm_zone, tzname[0]) == 0) { +p->tm_zone = tzname[0]; +} +else if (tzname[1] && strcmp(p->tm_zone, tzname[1]) == 0) { +p->tm_zone = tzname[1]; +} +#endif +} +item = PyStructSequence_GET_ITEM(args, 10); +if (item != Py_None) { +p->tm_gmtoff = PyLong_AsLong(item); +if (PyErr_Occurred()) +return 0; +} +} +#endif /* HAVE_STRUCT_TM_TM_ZONE */ +return 1; +} +/* Check values of the struct tm fields before it is passed to strftime() and +* asctime(). Return 1 if all values are valid, otherwise set an exception +* and returns 0. +*/ +static int +checktm(struct tm* buf) +{ +/* Checks added to make sure strftime() and asctime() does not crash Python by +indexing blindly into some array for a textual representation +by some bad index (fixes bug #897625 and #6608). +Also support values of zero from Python code for arguments in which +that is out of range by forcing that value to the lowest value that +is valid (fixed bug #1520914). +Valid ranges based on what is allowed in struct tm: +- tm_year: [0, max(int)] (1) +- tm_mon: [0, 11] (2) +- tm_mday: [1, 31] +- tm_hour: [0, 23] +- tm_min: [0, 59] +- tm_sec: [0, 60] +- tm_wday: [0, 6] (1) +- tm_yday: [0, 365] (2) +- tm_isdst: [-max(int), max(int)] +(1) gettmarg() handles bounds-checking. +(2) Python's acceptable range is one greater than the range in C, +thus need to check against automatic decrement by gettmarg(). +*/ +if (buf->tm_mon == -1) +buf->tm_mon = 0; +else if (buf->tm_mon < 0 || buf->tm_mon > 11) { +PyErr_SetString(PyExc_ValueError, "month out of range"); +return 0; +} +if (buf->tm_mday == 0) +buf->tm_mday = 1; +else if (buf->tm_mday < 0 || buf->tm_mday > 31) { +PyErr_SetString(PyExc_ValueError, "day of month out of range"); +return 0; +} +if (buf->tm_hour < 0 || buf->tm_hour > 23) { +PyErr_SetString(PyExc_ValueError, "hour out of range"); +return 0; +} +if (buf->tm_min < 0 || buf->tm_min > 59) { +PyErr_SetString(PyExc_ValueError, "minute out of range"); +return 0; +} +if (buf->tm_sec < 0 || buf->tm_sec > 61) { +PyErr_SetString(PyExc_ValueError, "seconds out of range"); +return 0; +} +/* tm_wday does not need checking of its upper-bound since taking +``% 7`` in gettmarg() automatically restricts the range. */ +if (buf->tm_wday < 0) { +PyErr_SetString(PyExc_ValueError, "day of week out of range"); +return 0; +} +if (buf->tm_yday == -1) +buf->tm_yday = 0; +else if (buf->tm_yday < 0 || buf->tm_yday > 365) { +PyErr_SetString(PyExc_ValueError, "day of year out of range"); +return 0; +} +return 1; +} +#define STRFTIME_FORMAT_CODES \ +"Commonly used format codes:\n\ +\n\ +%Y Year with century as a decimal number.\n\ +%m Month as a decimal number [01,12].\n\ +%d Day of the month as a decimal number [01,31].\n\ +%H Hour (24-hour clock) as a decimal number [00,23].\n\ +%M Minute as a decimal number [00,59].\n\ +%S Second as a decimal number [00,61].\n\ +%z Time zone offset from UTC.\n\ +%a Locale's abbreviated weekday name.\n\ +%A Locale's full weekday name.\n\ +%b Locale's abbreviated month name.\n\ +%B Locale's full month name.\n\ +%c Locale's appropriate date and time representation.\n\ +%I Hour (12-hour clock) as a decimal number [01,12].\n\ +%p Locale's equivalent of either AM or PM.\n\ +\n\ +Other codes may be available on your platform. See documentation for\n\ +the C library strftime function.\n" +#ifdef HAVE_STRFTIME +#ifdef HAVE_WCSFTIME +#define time_char wchar_t +#define format_time wcsftime +#define time_strlen wcslen +#else +#define time_char char +#define format_time strftime +#define time_strlen strlen +#endif +static PyObject * +time_strftime1(time_char **outbuf, size_t *bufsize, +time_char *format, size_t fmtlen, +struct tm *tm) +{ +size_t buflen; +#if defined(MS_WINDOWS) && !defined(HAVE_WCSFTIME) +/* check that the format string contains only valid directives */ +for (const time_char *f = strchr(format, '%'); +f != NULL; +f = strchr(f + 2, '%')) +{ +if (f[1] == '#') +++f; /* not documented by python, */ +if (f[1] == '\0') +break; +if ((f[1] == 'y') && tm->tm_year < 0) { +PyErr_SetString(PyExc_ValueError, +"format %y requires year >= 1900 on Windows"); +return NULL; +} +} +#elif (defined(_AIX) || (defined(__sun) && defined(__SVR4))) && defined(HAVE_WCSFTIME) +for (const time_char *f = wcschr(format, '%'); +f != NULL; +f = wcschr(f + 2, '%')) +{ +if (f[1] == L'\0') +break; +/* Issue #19634: On AIX, wcsftime("y", (1899, 1, 1, 0, 0, 0, 0, 0, 0)) +returns "0/" instead of "99" */ +if (f[1] == L'y' && tm->tm_year < 0) { +PyErr_SetString(PyExc_ValueError, +"format %y requires year >= 1900 on AIX"); +return NULL; +} +} +#endif +/* I hate these functions that presume you know how big the output +* will be ahead of time... +*/ +while (1) { +if (*bufsize > PY_SSIZE_T_MAX/sizeof(time_char)) { +PyErr_NoMemory(); +return NULL; +} +*outbuf = (time_char *)PyMem_Realloc(*outbuf, +*bufsize*sizeof(time_char)); +if (*outbuf == NULL) { +PyErr_NoMemory(); +return NULL; +} +#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) +errno = 0; +#endif +_Py_BEGIN_SUPPRESS_IPH +buflen = format_time(*outbuf, *bufsize, format, tm); +_Py_END_SUPPRESS_IPH +#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__) +/* VisualStudio .NET 2005 does this properly */ +if (buflen == 0 && errno == EINVAL) { +PyErr_SetString(PyExc_ValueError, "Invalid format string"); +return NULL; +} +#endif +if (buflen == 0 && *bufsize < 256 * fmtlen) { +*bufsize += *bufsize; +continue; +} +/* If the buffer is 256 times as long as the format, +it's probably not failing for lack of room! +More likely, the format yields an empty result, +e.g. an empty format, or %Z when the timezone +is unknown. */ +#ifdef HAVE_WCSFTIME +return PyUnicode_FromWideChar(*outbuf, buflen); +#else +return PyUnicode_DecodeLocaleAndSize(*outbuf, buflen, "surrogateescape"); +#endif +} +} +static PyObject * +time_strftime(PyObject *module, PyObject *args) +{ +PyObject *tup = NULL; +struct tm buf; +PyObject *format_arg; +Py_ssize_t format_size; +time_char *format, *outbuf = NULL; +size_t fmtlen, bufsize = 1024; +memset((void *) &buf, '\0', sizeof(buf)); +if (!PyArg_ParseTuple(args, "U|O:strftime", &format_arg, &tup)) +return NULL; +time_module_state *state = get_time_state(module); +if (tup == NULL) { +time_t tt = time(NULL); +if (_PyTime_localtime(tt, &buf) != 0) +return NULL; +} +else if (!gettmarg(state, tup, &buf, +"iiiiiiiii;strftime(): illegal time tuple argument") || +!checktm(&buf)) +{ +return NULL; +} +// Some platforms only support a limited range of years. +// +// Android works with negative years on the emulator, but fails on some +// physical devices (#123017). +#if defined(_MSC_VER) || (defined(__sun) && defined(__SVR4)) || defined(_AIX) \ +|| defined(__VXWORKS__) || defined(__ANDROID__) +if (buf.tm_year + 1900 < 1 || 9999 < buf.tm_year + 1900) { +PyErr_SetString(PyExc_ValueError, +"strftime() requires year in [1; 9999]"); +return NULL; +} +#endif +/* Normalize tm_isdst just in case someone foolishly implements %Z +based on the assumption that tm_isdst falls within the range of +[-1, 1] */ +if (buf.tm_isdst < -1) +buf.tm_isdst = -1; +else if (buf.tm_isdst > 1) +buf.tm_isdst = 1; +format_size = PyUnicode_GET_LENGTH(format_arg); +if ((size_t)format_size > PY_SSIZE_T_MAX/sizeof(time_char) - 1) { +PyErr_NoMemory(); +return NULL; +} +format = PyMem_Malloc((format_size + 1)*sizeof(time_char)); +if (format == NULL) { +PyErr_NoMemory(); +return NULL; +} +PyUnicodeWriter *writer = PyUnicodeWriter_Create(0); +if (writer == NULL) { +goto error; +} +Py_ssize_t i = 0; +while (i < format_size) { +fmtlen = 0; +for (; i < format_size; i++) { +Py_UCS4 c = PyUnicode_READ_CHAR(format_arg, i); +if (!c || c > 127) { +break; +} +format[fmtlen++] = (char)c; +} +if (fmtlen) { +format[fmtlen] = 0; +PyObject *unicode = time_strftime1(&outbuf, &bufsize, +format, fmtlen, &buf); +if (unicode == NULL) { +goto error; +} +if (PyUnicodeWriter_WriteStr(writer, unicode) < 0) { +Py_DECREF(unicode); +goto error; +} +Py_DECREF(unicode); +} +Py_ssize_t start = i; +for (; i < format_size; i++) { +Py_UCS4 c = PyUnicode_READ_CHAR(format_arg, i); +if (c == '%') { +break; +} +} +if (PyUnicodeWriter_WriteSubstring(writer, format_arg, start, i) < 0) { +goto error; +} +} +PyMem_Free(outbuf); +PyMem_Free(format); +return PyUnicodeWriter_Finish(writer); +error: +PyMem_Free(outbuf); +PyMem_Free(format); +PyUnicodeWriter_Discard(writer); +return NULL; +} +#undef time_char +#undef format_time +PyDoc_STRVAR(strftime_doc, +"strftime(format[, tuple]) -> string\n\ +\n\ +Convert a time tuple to a string according to a format specification.\n\ +See the library reference manual for formatting codes. When the time tuple\n\ +is not present, current time as returned by localtime() is used.\n\ +\n" STRFTIME_FORMAT_CODES); +#endif /* HAVE_STRFTIME */ +static PyObject * +time_strptime(PyObject *self, PyObject *args) +{ +PyObject *func, *result; +func = PyImport_ImportModuleAttrString("_strptime", "_strptime_time"); +if (!func) { +return NULL; +} +result = PyObject_Call(func, args, NULL); +Py_DECREF(func); +return result; +} +PyDoc_STRVAR(strptime_doc, +"strptime(string, format) -> struct_time\n\ +\n\ +Parse a string to a time tuple according to a format specification.\n\ +See the library reference manual for formatting codes (same as\n\ +strftime()).\n\ +\n" STRFTIME_FORMAT_CODES); +static PyObject * +_asctime(struct tm *timeptr) +{ +/* Inspired by Open Group reference implementation available at +* http://pubs.opengroup.org/onlinepubs/009695399/functions/asctime.html */ +static const char wday_name[7][4] = { +"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" +}; +static const char mon_name[12][4] = { +"Jan", "Feb", "Mar", "Apr", "May", "Jun", +"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; +return PyUnicode_FromFormat( +"%s %s%3d %.2d:%.2d:%.2d %d", +wday_name[timeptr->tm_wday], +mon_name[timeptr->tm_mon], +timeptr->tm_mday, timeptr->tm_hour, +timeptr->tm_min, timeptr->tm_sec, +1900 + timeptr->tm_year); +} +static PyObject * +time_asctime(PyObject *module, PyObject *args) +{ +PyObject *tup = NULL; +struct tm buf; +if (!PyArg_UnpackTuple(args, "asctime", 0, 1, &tup)) +return NULL; +time_module_state *state = get_time_state(module); +if (tup == NULL) { +time_t tt = time(NULL); +if (_PyTime_localtime(tt, &buf) != 0) +return NULL; +} +else if (!gettmarg(state, tup, &buf, +"iiiiiiiii;asctime(): illegal time tuple argument") || +!checktm(&buf)) +{ +return NULL; +} +return _asctime(&buf); +} +PyDoc_STRVAR(asctime_doc, +"asctime([tuple]) -> string\n\ +\n\ +Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n\ +When the time tuple is not present, current time as returned by localtime()\n\ +is used."); +static PyObject * +time_ctime(PyObject *self, PyObject *args) +{ +time_t tt; +struct tm buf; +if (!parse_time_t_args(args, "|O:ctime", &tt)) +return NULL; +if (_PyTime_localtime(tt, &buf) != 0) +return NULL; +return _asctime(&buf); +} +PyDoc_STRVAR(ctime_doc, +"ctime(seconds) -> string\n\ +\n\ +Convert a time in seconds since the Epoch to a string in local time.\n\ +This is equivalent to asctime(localtime(seconds)). When the time tuple is\n\ +not present, current time as returned by localtime() is used."); +#ifdef HAVE_MKTIME +static PyObject * +time_mktime(PyObject *module, PyObject *tm_tuple) +{ +struct tm tm; +time_t tt; +time_module_state *state = get_time_state(module); +if (!gettmarg(state, tm_tuple, &tm, +"iiiiiiiii;mktime(): illegal time tuple argument")) +{ +return NULL; +} +#if defined(_AIX) || (defined(__VXWORKS__) && !defined(_WRS_CONFIG_LP64)) +/* bpo-19748: AIX mktime() valid range is 00:00:00 UTC, January 1, 1970 +to 03:14:07 UTC, January 19, 2038. Thanks to the workaround below, +it is possible to support years in range [1902; 2037] */ +if (tm.tm_year < 2 || tm.tm_year > 137) { +/* bpo-19748: On AIX, mktime() does not report overflow error +for timestamp < -2^31 or timestamp > 2**31-1. VxWorks has the +same issue when working in 32 bit mode. */ +PyErr_SetString(PyExc_OverflowError, +"mktime argument out of range"); +return NULL; +} +#endif +#ifdef _AIX +/* bpo-34373: AIX mktime() has an integer overflow for years in range +[1902; 1969]. Workaround the issue by using a year greater or equal than +1970 (tm_year >= 70): mktime() behaves correctly in that case +(ex: properly report errors). tm_year and tm_wday are adjusted after +mktime() call. */ +int orig_tm_year = tm.tm_year; +int delta_days = 0; +while (tm.tm_year < 70) { +/* Use 4 years to account properly leap years */ +tm.tm_year += 4; +delta_days -= (366 + (365 * 3)); +} +#endif +tm.tm_wday = -1; /* sentinel; original value ignored */ +tt = mktime(&tm); +/* Return value of -1 does not necessarily mean an error, but tm_wday +* cannot remain set to -1 if mktime succeeded. */ +if (tt == (time_t)(-1) +/* Return value of -1 does not necessarily mean an error, but +* tm_wday cannot remain set to -1 if mktime succeeded. */ +&& tm.tm_wday == -1) +{ +PyErr_SetString(PyExc_OverflowError, +"mktime argument out of range"); +return NULL; +} +#ifdef _AIX +if (delta_days != 0) { +tm.tm_year = orig_tm_year; +if (tm.tm_wday != -1) { +tm.tm_wday = (tm.tm_wday + delta_days) % 7; +} +tt += delta_days * (24 * 3600); +} +#endif +return PyFloat_FromDouble((double)tt); +} +PyDoc_STRVAR(mktime_doc, +"mktime(tuple) -> floating-point number\n\ +\n\ +Convert a time tuple in local time to seconds since the Epoch.\n\ +Note that mktime(gmtime(0)) will not generally return zero for most\n\ +time zones; instead the returned value will either be equal to that\n\ +of the timezone or altzone attributes on the time module."); +#endif /* HAVE_MKTIME */ +#ifdef HAVE_WORKING_TZSET +static int init_timezone(PyObject *module); +static PyObject * +time_tzset(PyObject *self, PyObject *unused) +{ +PyObject* m; +m = PyImport_ImportModule("time"); +if (m == NULL) { +return NULL; +} +#if !defined(MS_WINDOWS) || defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) +tzset(); +#endif +/* Reset timezone, altzone, daylight and tzname */ +if (init_timezone(m) < 0) { +return NULL; +} +Py_DECREF(m); +if (PyErr_Occurred()) +return NULL; +Py_RETURN_NONE; +} +PyDoc_STRVAR(tzset_doc, +"tzset()\n\ +\n\ +Initialize, or reinitialize, the local timezone to the value stored in\n\ +os.environ['TZ']. The TZ environment variable should be specified in\n\ +standard Unix timezone format as documented in the tzset man page\n\ +(eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n\ +fall back to UTC. If the TZ environment variable is not set, the local\n\ +timezone is set to the systems best guess of wallclock time.\n\ +Changing the TZ environment variable without calling tzset *may* change\n\ +the local timezone used by methods such as localtime, but this behaviour\n\ +should not be relied on."); +#endif /* HAVE_WORKING_TZSET */ +static PyObject * +time_monotonic(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (PyTime_Monotonic(&t) < 0) { +return NULL; +} +return _PyFloat_FromPyTime(t); +} +PyDoc_STRVAR(monotonic_doc, +"monotonic() -> float\n\ +\n\ +Monotonic clock, cannot go backward."); +static PyObject * +time_monotonic_ns(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (PyTime_Monotonic(&t) < 0) { +return NULL; +} +return PyLong_FromInt64(t); +} +PyDoc_STRVAR(monotonic_ns_doc, +"monotonic_ns() -> int\n\ +\n\ +Monotonic clock, cannot go backward, as nanoseconds."); +static PyObject * +time_perf_counter(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (PyTime_PerfCounter(&t) < 0) { +return NULL; +} +return _PyFloat_FromPyTime(t); +} +PyDoc_STRVAR(perf_counter_doc, +"perf_counter() -> float\n\ +\n\ +Performance counter for benchmarking."); +static PyObject * +time_perf_counter_ns(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (PyTime_PerfCounter(&t) < 0) { +return NULL; +} +return PyLong_FromInt64(t); +} +PyDoc_STRVAR(perf_counter_ns_doc, +"perf_counter_ns() -> int\n\ +\n\ +Performance counter for benchmarking as nanoseconds."); +// gh-115714: Don't use times() on WASI. +#if defined(HAVE_TIMES) && !defined(__wasi__) +static int +process_time_times(time_module_state *state, PyTime_t *tp, +_Py_clock_info_t *info) +{ +_PyTimeFraction *base = &state->times_base; +struct tms process; +if (times(&process) == (clock_t)-1) { +return 0; +} +if (info) { +info->implementation = "times()"; +info->resolution = _PyTimeFraction_Resolution(base); +info->monotonic = 1; +info->adjustable = 0; +} +PyTime_t ns; +ns = _PyTimeFraction_Mul(process.tms_utime, base); +ns += _PyTimeFraction_Mul(process.tms_stime, base); +*tp = ns; +return 1; +} +#endif +static int +py_process_time(time_module_state *state, PyTime_t *tp, +_Py_clock_info_t *info) +{ +#if defined(MS_WINDOWS) +HANDLE process; +FILETIME creation_time, exit_time, kernel_time, user_time; +ULARGE_INTEGER large; +PyTime_t ktime, utime; +BOOL ok; +process = GetCurrentProcess(); +ok = GetProcessTimes(process, &creation_time, &exit_time, +&kernel_time, &user_time); +if (!ok) { +PyErr_SetFromWindowsErr(0); +return -1; +} +if (info) { +info->implementation = "GetProcessTimes()"; +info->resolution = 1e-7; +info->monotonic = 1; +info->adjustable = 0; +} +large.u.LowPart = kernel_time.dwLowDateTime; +large.u.HighPart = kernel_time.dwHighDateTime; +ktime = large.QuadPart; +large.u.LowPart = user_time.dwLowDateTime; +large.u.HighPart = user_time.dwHighDateTime; +utime = large.QuadPart; +/* ktime and utime have a resolution of 100 nanoseconds */ +*tp = (ktime + utime) * 100; +return 0; +#else +/* clock_gettime */ +// gh-115714: Don't use CLOCK_PROCESS_CPUTIME_ID on WASI. +/* CLOCK_PROF is defined on NetBSD, but not supported. +* CLOCK_PROCESS_CPUTIME_ID is broken on NetBSD for the same reason as +* CLOCK_THREAD_CPUTIME_ID (see comment below). +*/ +#if defined(HAVE_CLOCK_GETTIME) \ +&& (defined(CLOCK_PROCESS_CPUTIME_ID) || defined(CLOCK_PROF)) \ +&& !defined(__wasi__) \ +&& !defined(__NetBSD__) +struct timespec ts; +if (HAVE_CLOCK_GETTIME_RUNTIME) { +#ifdef CLOCK_PROF +const clockid_t clk_id = CLOCK_PROF; +const char *function = "clock_gettime(CLOCK_PROF)"; +#else +const clockid_t clk_id = CLOCK_PROCESS_CPUTIME_ID; +const char *function = "clock_gettime(CLOCK_PROCESS_CPUTIME_ID)"; +#endif +if (clock_gettime(clk_id, &ts) == 0) { +if (info) { +struct timespec res; +info->implementation = function; +info->monotonic = 1; +info->adjustable = 0; +if (clock_getres(clk_id, &res)) { +PyErr_SetFromErrno(PyExc_OSError); +return -1; +} +info->resolution = res.tv_sec + res.tv_nsec * 1e-9; +} +if (_PyTime_FromTimespec(tp, &ts) < 0) { +return -1; +} +return 0; +} +} +#endif +/* getrusage(RUSAGE_SELF) */ +#if defined(HAVE_SYS_RESOURCE_H) && defined(HAVE_GETRUSAGE) +struct rusage ru; +if (getrusage(RUSAGE_SELF, &ru) == 0) { +PyTime_t utime, stime; +if (info) { +info->implementation = "getrusage(RUSAGE_SELF)"; +info->monotonic = 1; +info->adjustable = 0; +info->resolution = 1e-6; +} +if (_PyTime_FromTimeval(&utime, &ru.ru_utime) < 0) { +return -1; +} +if (_PyTime_FromTimeval(&stime, &ru.ru_stime) < 0) { +return -1; +} +PyTime_t total = utime + stime; +*tp = total; +return 0; +} +#endif +/* times() */ +// gh-115714: Don't use times() on WASI. +#if defined(HAVE_TIMES) && !defined(__wasi__) +int res = process_time_times(state, tp, info); +if (res < 0) { +return -1; +} +if (res == 1) { +return 0; +} +// times() failed, ignore failure +#endif +/* clock(). Python 3 requires clock() to build (see gh-66814) */ +return py_clock(state, tp, info); +#endif +} +static PyObject * +time_process_time(PyObject *module, PyObject *unused) +{ +time_module_state *state = get_time_state(module); +PyTime_t t; +if (py_process_time(state, &t, NULL) < 0) { +return NULL; +} +return _PyFloat_FromPyTime(t); +} +PyDoc_STRVAR(process_time_doc, +"process_time() -> float\n\ +\n\ +Process time for profiling: sum of the kernel and user-space CPU time."); +static PyObject * +time_process_time_ns(PyObject *module, PyObject *unused) +{ +time_module_state *state = get_time_state(module); +PyTime_t t; +if (py_process_time(state, &t, NULL) < 0) { +return NULL; +} +return PyLong_FromInt64(t); +} +PyDoc_STRVAR(process_time_ns_doc, +"process_time() -> int\n\ +\n\ +Process time for profiling as nanoseconds:\n\ +sum of the kernel and user-space CPU time."); +#if defined(MS_WINDOWS) +#define HAVE_THREAD_TIME +static int +_PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info) +{ +HANDLE thread; +FILETIME creation_time, exit_time, kernel_time, user_time; +ULARGE_INTEGER large; +PyTime_t ktime, utime; +BOOL ok; +thread = GetCurrentThread(); +ok = GetThreadTimes(thread, &creation_time, &exit_time, +&kernel_time, &user_time); +if (!ok) { +PyErr_SetFromWindowsErr(0); +return -1; +} +if (info) { +info->implementation = "GetThreadTimes()"; +info->resolution = 1e-7; +info->monotonic = 1; +info->adjustable = 0; +} +large.u.LowPart = kernel_time.dwLowDateTime; +large.u.HighPart = kernel_time.dwHighDateTime; +ktime = large.QuadPart; +large.u.LowPart = user_time.dwLowDateTime; +large.u.HighPart = user_time.dwHighDateTime; +utime = large.QuadPart; +/* ktime and utime have a resolution of 100 nanoseconds */ +*tp = (ktime + utime) * 100; +return 0; +} +#elif defined(_AIX) +#define HAVE_THREAD_TIME +static int +_PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info) +{ +/* bpo-40192: On AIX, thread_cputime() is preferred: it has nanosecond +resolution, whereas clock_gettime(CLOCK_THREAD_CPUTIME_ID) +has a resolution of 10 ms. */ +thread_cputime_t tc; +if (thread_cputime(-1, &tc) != 0) { +PyErr_SetFromErrno(PyExc_OSError); +return -1; +} +if (info) { +info->implementation = "thread_cputime()"; +info->monotonic = 1; +info->adjustable = 0; +info->resolution = 1e-9; +} +*tp = (tc.stime + tc.utime); +return 0; +} +#elif defined(__sun) && defined(__SVR4) +#define HAVE_THREAD_TIME +static int +_PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info) +{ +/* bpo-35455: On Solaris, CLOCK_THREAD_CPUTIME_ID clock is not always +available; use gethrvtime() to substitute this functionality. */ +if (info) { +info->implementation = "gethrvtime()"; +info->resolution = 1e-9; +info->monotonic = 1; +info->adjustable = 0; +} +*tp = gethrvtime(); +return 0; +} +/* CLOCK_THREAD_CPUTIME_ID is broken on NetBSD: the result of clock_gettime() +* includes the sleeping time, that defeats the purpose of the clock. +* Also, clock_getres() does not support it. +* https://github.com/python/cpython/issues/123978 +* https://gnats.netbsd.org/57512 +*/ +#elif defined(HAVE_CLOCK_GETTIME) && \ +defined(CLOCK_THREAD_CPUTIME_ID) && \ +!defined(__EMSCRIPTEN__) && !defined(__wasi__) && \ +!defined(__NetBSD__) +#define HAVE_THREAD_TIME +#if defined(__APPLE__) && _Py__has_attribute(availability) +static int +_PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info) +__attribute__((availability(macos, introduced=10.12))) +__attribute__((availability(ios, introduced=10.0))) +__attribute__((availability(tvos, introduced=10.0))) +__attribute__((availability(watchos, introduced=3.0))); +#endif +static int +_PyTime_GetThreadTimeWithInfo(PyTime_t *tp, _Py_clock_info_t *info) +{ +struct timespec ts; +const clockid_t clk_id = CLOCK_THREAD_CPUTIME_ID; +const char *function = "clock_gettime(CLOCK_THREAD_CPUTIME_ID)"; +if (clock_gettime(clk_id, &ts)) { +PyErr_SetFromErrno(PyExc_OSError); +return -1; +} +if (info) { +struct timespec res; +info->implementation = function; +info->monotonic = 1; +info->adjustable = 0; +if (clock_getres(clk_id, &res)) { +PyErr_SetFromErrno(PyExc_OSError); +return -1; +} +info->resolution = res.tv_sec + res.tv_nsec * 1e-9; +} +if (_PyTime_FromTimespec(tp, &ts) < 0) { +return -1; +} +return 0; +} +#endif +#ifdef HAVE_THREAD_TIME +#ifdef __APPLE__ +/* +* The clock_* functions will be removed from the module +* dict entirely when the C API is not available. +*/ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunguarded-availability" +#endif +static PyObject * +time_thread_time(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) { +return NULL; +} +return _PyFloat_FromPyTime(t); +} +PyDoc_STRVAR(thread_time_doc, +"thread_time() -> float\n\ +\n\ +Thread time for profiling: sum of the kernel and user-space CPU time."); +static PyObject * +time_thread_time_ns(PyObject *self, PyObject *unused) +{ +PyTime_t t; +if (_PyTime_GetThreadTimeWithInfo(&t, NULL) < 0) { +return NULL; +} +return PyLong_FromInt64(t); +} +PyDoc_STRVAR(thread_time_ns_doc, +"thread_time() -> int\n\ +\n\ +Thread time for profiling as nanoseconds:\n\ +sum of the kernel and user-space CPU time."); +#ifdef __APPLE__ +#pragma clang diagnostic pop +#endif +#endif +static PyObject * +time_get_clock_info(PyObject *module, PyObject *args) +{ +char *name; +_Py_clock_info_t info; +PyObject *obj = NULL, *dict, *ns; +PyTime_t t; +if (!PyArg_ParseTuple(args, "s:get_clock_info", &name)) { +return NULL; +} +#ifdef Py_DEBUG +info.implementation = NULL; +info.monotonic = -1; +info.adjustable = -1; +info.resolution = -1.0; +#else +info.implementation = ""; +info.monotonic = 0; +info.adjustable = 0; +info.resolution = 1.0; +#endif +if (strcmp(name, "time") == 0) { +if (_PyTime_TimeWithInfo(&t, &info) < 0) { +return NULL; +} +} +else if (strcmp(name, "monotonic") == 0) { +if (_PyTime_MonotonicWithInfo(&t, &info) < 0) { +return NULL; +} +} +else if (strcmp(name, "perf_counter") == 0) { +if (_PyTime_PerfCounterWithInfo(&t, &info) < 0) { +return NULL; +} +} +else if (strcmp(name, "process_time") == 0) { +time_module_state *state = get_time_state(module); +if (py_process_time(state, &t, &info) < 0) { +return NULL; +} +} +#ifdef HAVE_THREAD_TIME +else if (strcmp(name, "thread_time") == 0) { +#ifdef __APPLE__ +if (HAVE_CLOCK_GETTIME_RUNTIME) { +#endif +if (_PyTime_GetThreadTimeWithInfo(&t, &info) < 0) { +return NULL; +} +#ifdef __APPLE__ +} else { +PyErr_SetString(PyExc_ValueError, "unknown clock"); +return NULL; +} +#endif +} +#endif +else { +PyErr_SetString(PyExc_ValueError, "unknown clock"); +return NULL; +} +dict = PyDict_New(); +if (dict == NULL) { +return NULL; +} +assert(info.implementation != NULL); +obj = PyUnicode_FromString(info.implementation); +if (obj == NULL) { +goto error; +} +if (PyDict_SetItemString(dict, "implementation", obj) == -1) { +goto error; +} +Py_CLEAR(obj); +assert(info.monotonic != -1); +obj = PyBool_FromLong(info.monotonic); +if (obj == NULL) { +goto error; +} +if (PyDict_SetItemString(dict, "monotonic", obj) == -1) { +goto error; +} +Py_CLEAR(obj); +assert(info.adjustable != -1); +obj = PyBool_FromLong(info.adjustable); +if (obj == NULL) { +goto error; +} +if (PyDict_SetItemString(dict, "adjustable", obj) == -1) { +goto error; +} +Py_CLEAR(obj); +assert(info.resolution > 0.0); +assert(info.resolution <= 1.0); +obj = PyFloat_FromDouble(info.resolution); +if (obj == NULL) { +goto error; +} +if (PyDict_SetItemString(dict, "resolution", obj) == -1) { +goto error; +} +Py_CLEAR(obj); +ns = _PyNamespace_New(dict); +Py_DECREF(dict); +return ns; +error: +Py_DECREF(dict); +Py_XDECREF(obj); +return NULL; +} +PyDoc_STRVAR(get_clock_info_doc, +"get_clock_info(name: str) -> dict\n\ +\n\ +Get information of the specified clock."); +#ifndef HAVE_DECL_TZNAME +static void +get_zone(char *zone, int n, struct tm *p) +{ +#ifdef HAVE_STRUCT_TM_TM_ZONE +strncpy(zone, p->tm_zone ? p->tm_zone : " ", n); +#else +tzset(); +strftime(zone, n, "%Z", p); +#endif +} +static time_t +get_gmtoff(time_t t, struct tm *p) +{ +#ifdef HAVE_STRUCT_TM_TM_ZONE +return p->tm_gmtoff; +#else +return timegm(p) - t; +#endif +} +#endif // !HAVE_DECL_TZNAME +static int +init_timezone(PyObject *m) +{ +#define ADD_INT(NAME, VALUE) do { \ +if (PyModule_AddIntConstant(m, NAME, VALUE) < 0) { \ +return -1; \ +} \ +} while (0) +assert(!PyErr_Occurred()); +/* This code moved from PyInit_time wholesale to allow calling it from +time_tzset. In the future, some parts of it can be moved back +(for platforms that don't HAVE_WORKING_TZSET, when we know what they +are), and the extraneous calls to tzset(3) should be removed. +I haven't done this yet, as I don't want to change this code as +little as possible when introducing the time.tzset and time.tzsetwall +methods. This should simply be a method of doing the following once, +at the top of this function and removing the call to tzset() from +time_tzset(): +#ifdef HAVE_TZSET +tzset() +#endif +And I'm lazy and hate C so nyer. +*/ +#ifdef HAVE_DECL_TZNAME +PyObject *otz0, *otz1; +#if !defined(MS_WINDOWS) || defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) +tzset(); +#endif +ADD_INT("timezone", _Py_timezone); +#ifdef HAVE_ALTZONE +ADD_INT("altzone", altzone); +#else +ADD_INT("altzone", _Py_timezone-3600); +#endif +ADD_INT("daylight", _Py_daylight); +#ifdef MS_WINDOWS +TIME_ZONE_INFORMATION tzinfo = {0}; +GetTimeZoneInformation(&tzinfo); +otz0 = PyUnicode_FromWideChar(tzinfo.StandardName, -1); +if (otz0 == NULL) { +return -1; +} +otz1 = PyUnicode_FromWideChar(tzinfo.DaylightName, -1); +if (otz1 == NULL) { +Py_DECREF(otz0); +return -1; +} +#else +otz0 = PyUnicode_DecodeLocale(_Py_tzname[0], "surrogateescape"); +if (otz0 == NULL) { +return -1; +} +otz1 = PyUnicode_DecodeLocale(_Py_tzname[1], "surrogateescape"); +if (otz1 == NULL) { +Py_DECREF(otz0); +return -1; +} +#endif // MS_WINDOWS +if (PyModule_Add(m, "tzname", Py_BuildValue("(NN)", otz0, otz1)) < 0) { +return -1; +} +#else // !HAVE_DECL_TZNAME +static const time_t YEAR = (365 * 24 + 6) * 3600; +time_t t; +struct tm p; +time_t janzone_t, julyzone_t; +char janname[10], julyname[10]; +t = (time((time_t *)0) / YEAR) * YEAR; +_PyTime_localtime(t, &p); +get_zone(janname, 9, &p); +janzone_t = -get_gmtoff(t, &p); +janname[9] = '\0'; +t += YEAR/2; +_PyTime_localtime(t, &p); +get_zone(julyname, 9, &p); +julyzone_t = -get_gmtoff(t, &p); +julyname[9] = '\0'; +/* Sanity check, don't check for the validity of timezones. +In practice, it should be more in range -12 hours .. +14 hours. */ +#define MAX_TIMEZONE (48 * 3600) +if (janzone_t < -MAX_TIMEZONE || janzone_t > MAX_TIMEZONE +|| julyzone_t < -MAX_TIMEZONE || julyzone_t > MAX_TIMEZONE) +{ +PyErr_SetString(PyExc_RuntimeError, "invalid GMT offset"); +return -1; +} +int janzone = (int)janzone_t; +int julyzone = (int)julyzone_t; +PyObject *tzname_obj; +if (janzone < julyzone) { +/* DST is reversed in the southern hemisphere */ +ADD_INT("timezone", julyzone); +ADD_INT("altzone", janzone); +ADD_INT("daylight", janzone != julyzone); +tzname_obj = Py_BuildValue("(zz)", julyname, janname); +} else { +ADD_INT("timezone", janzone); +ADD_INT("altzone", julyzone); +ADD_INT("daylight", janzone != julyzone); +tzname_obj = Py_BuildValue("(zz)", janname, julyname); +} +if (PyModule_Add(m, "tzname", tzname_obj) < 0) { +return -1; +} +#endif // !HAVE_DECL_TZNAME +#undef ADD_INT +if (PyErr_Occurred()) { +return -1; +} +return 0; +} +// Include Argument Clinic code after defining converters such as +// time_clockid_converter(). +#include "clinic/timemodule.c.h" +static PyMethodDef time_methods[] = { +{"time", time_time, METH_NOARGS, time_doc}, +{"time_ns", time_time_ns, METH_NOARGS, time_ns_doc}, +#ifdef HAVE_CLOCK_GETTIME +TIME_CLOCK_GETTIME_METHODDEF +TIME_CLOCK_GETTIME_NS_METHODDEF +#endif +#ifdef HAVE_CLOCK_SETTIME +{"clock_settime", time_clock_settime, METH_VARARGS, clock_settime_doc}, +{"clock_settime_ns",time_clock_settime_ns, METH_VARARGS, clock_settime_ns_doc}, +#endif +#ifdef HAVE_CLOCK_GETRES +{"clock_getres", time_clock_getres, METH_VARARGS, clock_getres_doc}, +#endif +#ifdef HAVE_PTHREAD_GETCPUCLOCKID +{"pthread_getcpuclockid", time_pthread_getcpuclockid, METH_VARARGS, pthread_getcpuclockid_doc}, +#endif +{"sleep", time_sleep, METH_O, sleep_doc}, +{"gmtime", time_gmtime, METH_VARARGS, gmtime_doc}, +{"localtime", time_localtime, METH_VARARGS, localtime_doc}, +{"asctime", time_asctime, METH_VARARGS, asctime_doc}, +{"ctime", time_ctime, METH_VARARGS, ctime_doc}, +#ifdef HAVE_MKTIME +{"mktime", time_mktime, METH_O, mktime_doc}, +#endif +#ifdef HAVE_STRFTIME +{"strftime", time_strftime, METH_VARARGS, strftime_doc}, +#endif +{"strptime", time_strptime, METH_VARARGS, strptime_doc}, +#ifdef HAVE_WORKING_TZSET +{"tzset", time_tzset, METH_NOARGS, tzset_doc}, +#endif +{"monotonic", time_monotonic, METH_NOARGS, monotonic_doc}, +{"monotonic_ns", time_monotonic_ns, METH_NOARGS, monotonic_ns_doc}, +{"process_time", time_process_time, METH_NOARGS, process_time_doc}, +{"process_time_ns", time_process_time_ns, METH_NOARGS, process_time_ns_doc}, +#ifdef HAVE_THREAD_TIME +{"thread_time", time_thread_time, METH_NOARGS, thread_time_doc}, +{"thread_time_ns", time_thread_time_ns, METH_NOARGS, thread_time_ns_doc}, +#endif +{"perf_counter", time_perf_counter, METH_NOARGS, perf_counter_doc}, +{"perf_counter_ns", time_perf_counter_ns, METH_NOARGS, perf_counter_ns_doc}, +{"get_clock_info", time_get_clock_info, METH_VARARGS, get_clock_info_doc}, +{NULL, NULL} /* sentinel */ +}; +PyDoc_STRVAR(module_doc, +"This module provides various functions to manipulate time values.\n\ +\n\ +There are two standard representations of time. One is the number\n\ +of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\ +or a floating-point number (to represent fractions of seconds).\n\ +The epoch is the point where the time starts, the return value of time.gmtime(0).\n\ +It is January 1, 1970, 00:00:00 (UTC) on all platforms.\n\ +\n\ +The other representation is a tuple of 9 integers giving local time.\n\ +The tuple items are:\n\ +year (including century, e.g. 1998)\n\ +month (1-12)\n\ +day (1-31)\n\ +hours (0-23)\n\ +minutes (0-59)\n\ +seconds (0-59)\n\ +weekday (0-6, Monday is 0)\n\ +Julian day (day in the year, 1-366)\n\ +DST (Daylight Savings Time) flag (-1, 0 or 1)\n\ +If the DST flag is 0, the time is given in the regular time zone;\n\ +if it is 1, the time is given in the DST time zone;\n\ +if it is -1, mktime() should guess based on the date and time.\n"); +static int +time_exec(PyObject *module) +{ +time_module_state *state = get_time_state(module); +#if defined(__APPLE__) && defined(HAVE_CLOCK_GETTIME) +if (HAVE_CLOCK_GETTIME_RUNTIME) { +/* pass: ^^^ cannot use '!' here */ +} else { +PyObject* dct = PyModule_GetDict(module); +if (dct == NULL) { +return -1; +} +if (PyDict_PopString(dct, "clock_gettime", NULL) < 0) { +return -1; +} +if (PyDict_PopString(dct, "clock_gettime_ns", NULL) < 0) { +return -1; +} +if (PyDict_PopString(dct, "clock_settime", NULL) < 0) { +return -1; +} +if (PyDict_PopString(dct, "clock_settime_ns", NULL) < 0) { +return -1; +} +if (PyDict_PopString(dct, "clock_getres", NULL) < 0) { +return -1; +} +} +#endif +#if defined(__APPLE__) && defined(HAVE_THREAD_TIME) +if (HAVE_CLOCK_GETTIME_RUNTIME) { +/* pass: ^^^ cannot use '!' here */ +} else { +PyObject* dct = PyModule_GetDict(module); +if (PyDict_PopString(dct, "thread_time", NULL) < 0) { +return -1; +} +if (PyDict_PopString(dct, "thread_time_ns", NULL) < 0) { +return -1; +} +} +#endif +/* Set, or reset, module variables like time.timezone */ +if (init_timezone(module) < 0) { +return -1; +} +#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_SETTIME) || defined(HAVE_CLOCK_GETRES) +if (HAVE_CLOCK_GETTIME_RUNTIME) { +#ifdef CLOCK_REALTIME +if (PyModule_AddIntMacro(module, CLOCK_REALTIME) < 0) { +return -1; +} +#endif +#ifdef CLOCK_MONOTONIC +if (PyModule_AddIntMacro(module, CLOCK_MONOTONIC) < 0) { +return -1; +} +#endif +#ifdef CLOCK_MONOTONIC_RAW +if (PyModule_AddIntMacro(module, CLOCK_MONOTONIC_RAW) < 0) { +return -1; +} +#endif +#ifdef CLOCK_HIGHRES +if (PyModule_AddIntMacro(module, CLOCK_HIGHRES) < 0) { +return -1; +} +#endif +#ifdef CLOCK_PROCESS_CPUTIME_ID +if (PyModule_AddIntMacro(module, CLOCK_PROCESS_CPUTIME_ID) < 0) { +return -1; +} +#endif +#ifdef CLOCK_THREAD_CPUTIME_ID +if (PyModule_AddIntMacro(module, CLOCK_THREAD_CPUTIME_ID) < 0) { +return -1; +} +#endif +#ifdef CLOCK_PROF +if (PyModule_AddIntMacro(module, CLOCK_PROF) < 0) { +return -1; +} +#endif +#ifdef CLOCK_BOOTTIME +if (PyModule_AddIntMacro(module, CLOCK_BOOTTIME) < 0) { +return -1; +} +#endif +#ifdef CLOCK_TAI +if (PyModule_AddIntMacro(module, CLOCK_TAI) < 0) { +return -1; +} +#endif +#ifdef CLOCK_UPTIME +if (PyModule_AddIntMacro(module, CLOCK_UPTIME) < 0) { +return -1; +} +#endif +#ifdef CLOCK_UPTIME_RAW +if (PyModule_AddIntMacro(module, CLOCK_UPTIME_RAW) < 0) { +return -1; +} +#endif +#ifdef CLOCK_MONOTONIC_RAW_APPROX +if (PyModule_AddIntMacro(module, CLOCK_MONOTONIC_RAW_APPROX) < 0) { +return -1; +} +#endif +#ifdef CLOCK_UPTIME_RAW_APPROX +if (PyModule_AddIntMacro(module, CLOCK_UPTIME_RAW_APPROX) < 0) { +return -1; +} +#endif +} +#endif /* defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_SETTIME) || defined(HAVE_CLOCK_GETRES) */ +if (PyModule_AddIntConstant(module, "_STRUCT_TM_ITEMS", 11)) { +return -1; +} +// struct_time type +state->struct_time_type = PyStructSequence_NewType(&struct_time_type_desc); +if (state->struct_time_type == NULL) { +return -1; +} +if (PyModule_AddType(module, state->struct_time_type)) { +return -1; +} +#if defined(__linux__) && !defined(__GLIBC__) +struct tm tm; +const time_t zero = 0; +if (gmtime_r(&zero, &tm) != NULL) +utc_string = tm.tm_zone; +#endif +#if defined(MS_WINDOWS) +if (timer_flags == (DWORD)-1) { +DWORD test_flags = CREATE_WAITABLE_TIMER_HIGH_RESOLUTION; +HANDLE timer = CreateWaitableTimerExW(NULL, NULL, test_flags, +TIMER_ALL_ACCESS); +if (timer == NULL) { +// CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is not supported. +timer_flags = 0; +} +else { +// CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is supported. +timer_flags = CREATE_WAITABLE_TIMER_HIGH_RESOLUTION; +CloseHandle(timer); +} +} +#endif +// gh-115714: Don't use times() on WASI. +#if defined(HAVE_TIMES) && !defined(__wasi__) +long ticks_per_second; +if (_Py_GetTicksPerSecond(&ticks_per_second) < 0) { +PyErr_SetString(PyExc_RuntimeError, +"cannot read ticks_per_second"); +return -1; +} +if (_PyTimeFraction_Set(&state->times_base, SEC_TO_NS, +ticks_per_second) < 0) { +PyErr_Format(PyExc_OverflowError, "ticks_per_second is too large"); +return -1; +} +#endif +#ifdef HAVE_CLOCK +if (_PyTimeFraction_Set(&state->clock_base, SEC_TO_NS, +CLOCKS_PER_SEC) < 0) { +PyErr_Format(PyExc_OverflowError, "CLOCKS_PER_SEC is too large"); +return -1; +} +#endif +return 0; +} +static int +time_module_traverse(PyObject *module, visitproc visit, void *arg) +{ +time_module_state *state = get_time_state(module); +Py_VISIT(state->struct_time_type); +return 0; +} +static int +time_module_clear(PyObject *module) +{ +time_module_state *state = get_time_state(module); +Py_CLEAR(state->struct_time_type); +return 0; +} +static void +time_module_free(void *module) +{ +time_module_clear((PyObject *)module); +} +static struct PyModuleDef_Slot time_slots[] = { +{Py_mod_exec, time_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL} +}; +static struct PyModuleDef timemodule = { +PyModuleDef_HEAD_INIT, +.m_name = "time", +.m_doc = module_doc, +.m_size = sizeof(time_module_state), +.m_methods = time_methods, +.m_slots = time_slots, +.m_traverse = time_module_traverse, +.m_clear = time_module_clear, +.m_free = time_module_free, +}; +PyMODINIT_FUNC +PyInit_time(void) +{ +return PyModuleDef_Init(&timemodule); +} +// time.sleep() implementation. +// On error, raise an exception and return -1. +// On success, return 0. +static int +pysleep(PyTime_t timeout) +{ +assert(timeout >= 0); +#ifndef MS_WINDOWS +#ifdef HAVE_CLOCK_NANOSLEEP +struct timespec timeout_abs; +#elif defined(HAVE_NANOSLEEP) +struct timespec timeout_ts; +#else +struct timeval timeout_tv; +#endif +PyTime_t deadline, monotonic; +int err = 0; +if (PyTime_Monotonic(&monotonic) < 0) { +return -1; +} +deadline = monotonic + timeout; +#ifdef HAVE_CLOCK_NANOSLEEP +if (_PyTime_AsTimespec(deadline, &timeout_abs) < 0) { +return -1; +} +#endif +do { +#ifdef HAVE_CLOCK_NANOSLEEP +// use timeout_abs +#elif defined(HAVE_NANOSLEEP) +if (_PyTime_AsTimespec(timeout, &timeout_ts) < 0) { +return -1; +} +#else +if (_PyTime_AsTimeval(timeout, &timeout_tv, _PyTime_ROUND_CEILING) < 0) { +return -1; +} +#endif +int ret; +Py_BEGIN_ALLOW_THREADS +#ifdef HAVE_CLOCK_NANOSLEEP +ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &timeout_abs, NULL); +err = ret; +#elif defined(HAVE_NANOSLEEP) +ret = nanosleep(&timeout_ts, NULL); +err = errno; +#else +ret = select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &timeout_tv); +err = errno; +#endif +Py_END_ALLOW_THREADS +if (ret == 0) { +break; +} +if (err != EINTR) { +errno = err; +PyErr_SetFromErrno(PyExc_OSError); +return -1; +} +/* sleep was interrupted by SIGINT */ +if (PyErr_CheckSignals()) { +return -1; +} +#ifndef HAVE_CLOCK_NANOSLEEP +if (PyTime_Monotonic(&monotonic) < 0) { +return -1; +} +timeout = deadline - monotonic; +if (timeout < 0) { +break; +} +/* retry with the recomputed delay */ +#endif +} while (1); +return 0; +#else // MS_WINDOWS +PyTime_t timeout_100ns = _PyTime_As100Nanoseconds(timeout, +_PyTime_ROUND_CEILING); +// Maintain Windows Sleep() semantics for time.sleep(0) +if (timeout_100ns == 0) { +Py_BEGIN_ALLOW_THREADS +// A value of zero causes the thread to relinquish the remainder of its +// time slice to any other thread that is ready to run. If there are no +// other threads ready to run, the function returns immediately, and +// the thread continues execution. +Sleep(0); +Py_END_ALLOW_THREADS +return 0; +} +LARGE_INTEGER relative_timeout; +// No need to check for integer overflow, both types are signed +assert(sizeof(relative_timeout) == sizeof(timeout_100ns)); +// SetWaitableTimer(): a negative due time indicates relative time +relative_timeout.QuadPart = -timeout_100ns; +HANDLE timer = CreateWaitableTimerExW(NULL, NULL, timer_flags, +TIMER_ALL_ACCESS); +if (timer == NULL) { +PyErr_SetFromWindowsErr(0); +return -1; +} +if (!SetWaitableTimerEx(timer, &relative_timeout, +0, // no period; the timer is signaled once +NULL, NULL, // no completion routine +NULL, // no wake context; do not resume from suspend +0)) // no tolerable delay for timer coalescing +{ +PyErr_SetFromWindowsErr(0); +goto error; +} +// Only the main thread can be interrupted by SIGINT. +// Signal handlers are only executed in the main thread. +if (_PyOS_IsMainThread()) { +HANDLE sigint_event = _PyOS_SigintEvent(); +while (1) { +// Check for pending SIGINT signal before resetting the event +if (PyErr_CheckSignals()) { +goto error; +} +ResetEvent(sigint_event); +HANDLE events[] = {timer, sigint_event}; +DWORD rc; +Py_BEGIN_ALLOW_THREADS +rc = WaitForMultipleObjects(Py_ARRAY_LENGTH(events), events, +// bWaitAll +FALSE, +// No wait timeout +INFINITE); +Py_END_ALLOW_THREADS +if (rc == WAIT_FAILED) { +PyErr_SetFromWindowsErr(0); +goto error; +} +if (rc == WAIT_OBJECT_0) { +// Timer signaled: we are done +break; +} +assert(rc == (WAIT_OBJECT_0 + 1)); +// The sleep was interrupted by SIGINT: restart sleeping +} +} +else { +DWORD rc; +Py_BEGIN_ALLOW_THREADS +rc = WaitForSingleObject(timer, INFINITE); +Py_END_ALLOW_THREADS +if (rc == WAIT_FAILED) { +PyErr_SetFromWindowsErr(0); +goto error; +} +assert(rc == WAIT_OBJECT_0); +// Timer signaled: we are done +} +CloseHandle(timer); +return 0; +error: +CloseHandle(timer); +return -1; +#endif +} + +/* Declarations shared between the different POSIX-related modules */ +#ifndef Py_POSIXMODULE_H +#define Py_POSIXMODULE_H +#ifdef __cplusplus +extern "C" { +#endif +#ifdef HAVE_SYS_TYPES_H +# include // uid_t +#endif +#ifndef MS_WINDOWS +extern PyObject* _PyLong_FromUid(uid_t); +// Export for 'grp' shared extension +PyAPI_FUNC(PyObject*) _PyLong_FromGid(gid_t); +// Export for '_posixsubprocess' shared extension +PyAPI_FUNC(int) _Py_Uid_Converter(PyObject *, uid_t *); +// Export for 'grp' shared extension +PyAPI_FUNC(int) _Py_Gid_Converter(PyObject *, gid_t *); +#endif // !MS_WINDOWS +#if (defined(PYPTHREAD_SIGMASK) || defined(HAVE_SIGWAIT) \ +|| defined(HAVE_SIGWAITINFO) || defined(HAVE_SIGTIMEDWAIT)) +# define HAVE_SIGSET_T +#endif +extern int _Py_Sigset_Converter(PyObject *, void *); +#ifdef __cplusplus +} +#endif +#endif // !Py_POSIXMODULE_H + +/* MD5 module */ +/* This module provides an interface to the MD5 algorithm */ +/* See below for information about the original code this module was +based upon. Additional work performed by: +Andrew Kuchling (amk@amk.ca) +Greg Stein (gstein@lyra.org) +Trevor Perrin (trevp@trevp.net) +Bénédikt Tran (10796600+picnixz@users.noreply.github.com) +Copyright (C) 2005-2007 Gregory P. Smith (greg@krypto.org) +Licensed to PSF under a Contributor Agreement. +*/ +/* MD5 objects */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif +#include "Python.h" +#include "pycore_object.h" // _PyObject_VisitType() +#include "pycore_strhex.h" // _Py_strhex() +#include "hashlib.h" +#include "_hacl/Hacl_Hash_MD5.h" +/* The MD5 block size and message digest sizes, in bytes */ +#define MD5_BLOCKSIZE 64 +#define MD5_DIGESTSIZE 16 +// --- Module objects --------------------------------------------------------- +typedef struct { +HASHLIB_OBJECT_HEAD +Hacl_Hash_MD5_state_t *hash_state; +} MD5object; +#define _MD5object_CAST(op) ((MD5object *)(op)) +// --- Module state ----------------------------------------------------------- +typedef struct { +PyTypeObject* md5_type; +} MD5State; +static inline MD5State* +md5_get_state(PyObject *module) +{ +void *state = PyModule_GetState(module); +assert(state != NULL); +return (MD5State *)state; +} +// --- Module clinic configuration -------------------------------------------- +/*[clinic input] +module _md5 +class MD5Type "MD5object *" "&PyType_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=6e5261719957a912]*/ +#include "clinic/md5module.c.h" +// --- MD5 object interface --------------------------------------------------- +static MD5object * +newMD5object(MD5State * st) +{ +MD5object *md5 = PyObject_GC_New(MD5object, st->md5_type); +if (!md5) { +return NULL; +} +HASHLIB_INIT_MUTEX(md5); +PyObject_GC_Track(md5); +return md5; +} +/* Internal methods for a hash object */ +static void +MD5_dealloc(PyObject *op) +{ +MD5object *ptr = _MD5object_CAST(op); +Hacl_Hash_MD5_free(ptr->hash_state); +PyTypeObject *tp = Py_TYPE(op); +PyObject_GC_UnTrack(ptr); +PyObject_GC_Del(ptr); +Py_DECREF(tp); +} +/* External methods for a hash object */ +/*[clinic input] +MD5Type.copy +cls: defining_class +Return a copy of the hash object. +[clinic start generated code]*/ +static PyObject * +MD5Type_copy_impl(MD5object *self, PyTypeObject *cls) +/*[clinic end generated code: output=bf055e08244bf5ee input=d89087dcfb2a8620]*/ +{ +MD5State *st = PyType_GetModuleState(cls); +MD5object *newobj; +if ((newobj = newMD5object(st)) == NULL) { +return NULL; +} +HASHLIB_ACQUIRE_LOCK(self); +newobj->hash_state = Hacl_Hash_MD5_copy(self->hash_state); +HASHLIB_RELEASE_LOCK(self); +if (newobj->hash_state == NULL) { +Py_DECREF(newobj); +return PyErr_NoMemory(); +} +return (PyObject *)newobj; +} +/*[clinic input] +MD5Type.digest +Return the digest value as a bytes object. +[clinic start generated code]*/ +static PyObject * +MD5Type_digest_impl(MD5object *self) +/*[clinic end generated code: output=eb691dc4190a07ec input=bc0c4397c2994be6]*/ +{ +uint8_t digest[MD5_DIGESTSIZE]; +HASHLIB_ACQUIRE_LOCK(self); +Hacl_Hash_MD5_digest(self->hash_state, digest); +HASHLIB_RELEASE_LOCK(self); +return PyBytes_FromStringAndSize((const char *)digest, MD5_DIGESTSIZE); +} +/*[clinic input] +MD5Type.hexdigest +Return the digest value as a string of hexadecimal digits. +[clinic start generated code]*/ +static PyObject * +MD5Type_hexdigest_impl(MD5object *self) +/*[clinic end generated code: output=17badced1f3ac932 input=b60b19de644798dd]*/ +{ +uint8_t digest[MD5_DIGESTSIZE]; +HASHLIB_ACQUIRE_LOCK(self); +Hacl_Hash_MD5_digest(self->hash_state, digest); +HASHLIB_RELEASE_LOCK(self); +return _Py_strhex((const char *)digest, MD5_DIGESTSIZE); +} +static void +update(Hacl_Hash_MD5_state_t *state, uint8_t *buf, Py_ssize_t len) +{ +/* +* Note: we explicitly ignore the error code on the basis that it would +* take more than 1 billion years to overflow the maximum admissible length +* for MD5 (2^61 - 1). +*/ +assert(len >= 0); +#if PY_SSIZE_T_MAX > UINT32_MAX +while (len > UINT32_MAX) { +(void)Hacl_Hash_MD5_update(state, buf, UINT32_MAX); +len -= UINT32_MAX; +buf += UINT32_MAX; +} +#endif +/* cast to uint32_t is now safe */ +(void)Hacl_Hash_MD5_update(state, buf, (uint32_t)len); +} +/*[clinic input] +MD5Type.update +obj: object +/ +Update this hash object's state with the provided string. +[clinic start generated code]*/ +static PyObject * +MD5Type_update_impl(MD5object *self, PyObject *obj) +/*[clinic end generated code: output=b0fed9a7ce7ad253 input=6e1efcd9ecf17032]*/ +{ +Py_buffer buf; +GET_BUFFER_VIEW_OR_ERROUT(obj, &buf); +HASHLIB_EXTERNAL_INSTRUCTIONS_LOCKED( +self, buf.len, +update(self->hash_state, buf.buf, buf.len) +); +PyBuffer_Release(&buf); +Py_RETURN_NONE; +} +static PyMethodDef MD5_methods[] = { +MD5TYPE_COPY_METHODDEF +MD5TYPE_DIGEST_METHODDEF +MD5TYPE_HEXDIGEST_METHODDEF +MD5TYPE_UPDATE_METHODDEF +{NULL, NULL} /* sentinel */ +}; +static PyObject * +MD5_get_block_size(PyObject *Py_UNUSED(self), void *Py_UNUSED(closure)) +{ +return PyLong_FromLong(MD5_BLOCKSIZE); +} +static PyObject * +MD5_get_name(PyObject *Py_UNUSED(self), void *Py_UNUSED(closure)) +{ +return PyUnicode_FromStringAndSize("md5", 3); +} +static PyObject * +md5_get_digest_size(PyObject *Py_UNUSED(self), void *Py_UNUSED(closure)) +{ +return PyLong_FromLong(MD5_DIGESTSIZE); +} +static PyGetSetDef MD5_getseters[] = { +{"block_size", MD5_get_block_size, NULL, NULL, NULL}, +{"name", MD5_get_name, NULL, NULL, NULL}, +{"digest_size", md5_get_digest_size, NULL, NULL, NULL}, +{NULL} /* Sentinel */ +}; +static PyType_Slot md5_type_slots[] = { +{Py_tp_dealloc, MD5_dealloc}, +{Py_tp_methods, MD5_methods}, +{Py_tp_getset, MD5_getseters}, +{Py_tp_traverse, _PyObject_VisitType}, +{0,0} +}; +static PyType_Spec md5_type_spec = { +.name = "_md5.md5", +.basicsize = sizeof(MD5object), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | +Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC), +.slots = md5_type_slots +}; +/* The single module-level function: new() */ +/*[clinic input] +_md5.md5 +data: object(c_default="NULL") = b'' +* +usedforsecurity: bool = True +string as string_obj: object(c_default="NULL") = None +Return a new MD5 hash object; optionally initialized with a string. +[clinic start generated code]*/ +static PyObject * +_md5_md5_impl(PyObject *module, PyObject *data, int usedforsecurity, +PyObject *string_obj) +/*[clinic end generated code: output=d45e187d3d16f3a8 input=7ea5c5366dbb44bf]*/ +{ +PyObject *string; +if (_Py_hashlib_data_argument(&string, data, string_obj) < 0) { +return NULL; +} +MD5object *new; +Py_buffer buf; +if (string) { +GET_BUFFER_VIEW_OR_ERROUT(string, &buf); +} +MD5State *st = md5_get_state(module); +if ((new = newMD5object(st)) == NULL) { +if (string) { +PyBuffer_Release(&buf); +} +return NULL; +} +new->hash_state = Hacl_Hash_MD5_malloc(); +if (new->hash_state == NULL) { +Py_DECREF(new); +if (string) { +PyBuffer_Release(&buf); +} +return PyErr_NoMemory(); +} +if (string) { +/* Do not use self->mutex here as this is the constructor +* where it is not yet possible to have concurrent access. */ +HASHLIB_EXTERNAL_INSTRUCTIONS_UNLOCKED( +buf.len, +update(new->hash_state, buf.buf, buf.len) +); +PyBuffer_Release(&buf); +} +return (PyObject *)new; +} +/* List of functions exported by this module */ +static struct PyMethodDef MD5_functions[] = { +_MD5_MD5_METHODDEF +{NULL, NULL} /* Sentinel */ +}; +static int +_md5_traverse(PyObject *module, visitproc visit, void *arg) +{ +MD5State *state = md5_get_state(module); +Py_VISIT(state->md5_type); +return 0; +} +static int +_md5_clear(PyObject *module) +{ +MD5State *state = md5_get_state(module); +Py_CLEAR(state->md5_type); +return 0; +} +static void +_md5_free(void *module) +{ +_md5_clear((PyObject *)module); +} +/* Initialize this module. */ +static int +md5_exec(PyObject *m) +{ +MD5State *st = md5_get_state(m); +st->md5_type = (PyTypeObject *)PyType_FromModuleAndSpec( +m, &md5_type_spec, NULL); +if (PyModule_AddObjectRef(m, "MD5Type", (PyObject *)st->md5_type) < 0) { +return -1; +} +if (PyModule_AddIntConstant(m, "_GIL_MINSIZE", HASHLIB_GIL_MINSIZE) < 0) { +return -1; +} +return 0; +} +static PyModuleDef_Slot _md5_slots[] = { +{Py_mod_exec, md5_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL} +}; +static struct PyModuleDef _md5module = { +PyModuleDef_HEAD_INIT, +.m_name = "_md5", +.m_size = sizeof(MD5State), +.m_methods = MD5_functions, +.m_slots = _md5_slots, +.m_traverse = _md5_traverse, +.m_clear = _md5_clear, +.m_free = _md5_free, +}; +PyMODINIT_FUNC +PyInit__md5(void) +{ +return PyModuleDef_Init(&_md5module); +} + +/* stat.h interface +* +* The module defines all S_IF*, S_I*, UF_*, SF_* and ST_* constants to +* sensible default values as well as defines S_IS*() macros in order to keep +* backward compatibility with the old stat.py module. +* +* New constants and macros such as S_IFDOOR / S_ISDOOR() are always defined +* as int 0. +* +* NOTE: POSIX only defines the values of the S_I* permission bits. +* +*/ +// Need limited C API version 3.13 for PyModule_Add() on Windows +#include "pyconfig.h" // Py_GIL_DISABLED +#ifndef Py_GIL_DISABLED +# define Py_LIMITED_API 0x030d0000 +#endif +#include "Python.h" +#ifdef HAVE_SYS_TYPES_H +#include +#endif /* HAVE_SYS_TYPES_H */ +#ifdef HAVE_SYS_STAT_H +#include +#endif /* HAVE_SYS_STAT_H */ +#ifdef MS_WINDOWS +#include +typedef unsigned short mode_t; +/* FILE_ATTRIBUTE_INTEGRITY_STREAM and FILE_ATTRIBUTE_NO_SCRUB_DATA +are not present in VC2010, so define them manually */ +#ifndef FILE_ATTRIBUTE_INTEGRITY_STREAM +# define FILE_ATTRIBUTE_INTEGRITY_STREAM 0x8000 +#endif +#ifndef FILE_ATTRIBUTE_NO_SCRUB_DATA +# define FILE_ATTRIBUTE_NO_SCRUB_DATA 0x20000 +#endif +#ifndef IO_REPARSE_TAG_APPEXECLINK +# define IO_REPARSE_TAG_APPEXECLINK 0x8000001BL +#endif +#endif /* MS_WINDOWS */ +/* From Python's stat.py */ +#ifndef S_IMODE +# define S_IMODE 07777 +#endif +/* S_IFXXX constants (file types) +* +* Only the names are defined by POSIX but not their value. All common file +* types seems to have the same numeric value on all platforms, though. +* +* fileutils.h guarantees S_IFMT, S_IFDIR, S_IFCHR, S_IFREG and S_IFLNK +*/ +#ifndef S_IFBLK +# define S_IFBLK 0060000 +#endif +#ifndef S_IFIFO +# define S_IFIFO 0010000 +#endif +#ifndef S_IFSOCK +# define S_IFSOCK 0140000 +#endif +#ifndef S_IFDOOR +# define S_IFDOOR 0 +#endif +#ifndef S_IFPORT +# define S_IFPORT 0 +#endif +#ifndef S_IFWHT +# define S_IFWHT 0 +#endif +/* S_ISXXX() +* fileutils.h defines S_ISDIR(), S_ISREG() and S_ISCHR() +*/ +#ifndef S_ISBLK +# define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK) +#endif +#ifndef S_ISFIFO +# define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO) +#endif +#ifndef S_ISLNK +# define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK) +#endif +#ifndef S_ISSOCK +# define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK) +#endif +#ifndef S_ISDOOR +# define S_ISDOOR(mode) 0 +#endif +#ifndef S_ISPORT +# define S_ISPORT(mode) 0 +#endif +#ifndef S_ISWHT +# define S_ISWHT(mode) 0 +#endif +/* S_I* file permission +* +* The permission bit value are defined by POSIX standards. +*/ +#ifndef S_ISUID +# define S_ISUID 04000 +#endif +#ifndef S_ISGID +# define S_ISGID 02000 +#endif +/* what is S_ENFMT? */ +#ifndef S_ENFMT +# define S_ENFMT S_ISGID +#endif +#ifndef S_ISVTX +# define S_ISVTX 01000 +#endif +#ifndef S_IREAD +# define S_IREAD 00400 +#endif +#ifndef S_IWRITE +# define S_IWRITE 00200 +#endif +#ifndef S_IEXEC +# define S_IEXEC 00100 +#endif +#ifndef S_IRWXU +# define S_IRWXU 00700 +#endif +#ifndef S_IRUSR +# define S_IRUSR 00400 +#endif +#ifndef S_IWUSR +# define S_IWUSR 00200 +#endif +#ifndef S_IXUSR +# define S_IXUSR 00100 +#endif +#ifndef S_IRWXG +# define S_IRWXG 00070 +#endif +#ifndef S_IRGRP +# define S_IRGRP 00040 +#endif +#ifndef S_IWGRP +# define S_IWGRP 00020 +#endif +#ifndef S_IXGRP +# define S_IXGRP 00010 +#endif +#ifndef S_IRWXO +# define S_IRWXO 00007 +#endif +#ifndef S_IROTH +# define S_IROTH 00004 +#endif +#ifndef S_IWOTH +# define S_IWOTH 00002 +#endif +#ifndef S_IXOTH +# define S_IXOTH 00001 +#endif +/* Names for file flags */ +#ifndef UF_SETTABLE +# define UF_SETTABLE 0x0000ffff +#endif +#ifndef UF_NODUMP +# define UF_NODUMP 0x00000001 +#endif +#ifndef UF_IMMUTABLE +# define UF_IMMUTABLE 0x00000002 +#endif +#ifndef UF_APPEND +# define UF_APPEND 0x00000004 +#endif +#ifndef UF_OPAQUE +# define UF_OPAQUE 0x00000008 +#endif +#ifndef UF_NOUNLINK +# define UF_NOUNLINK 0x00000010 +#endif +#ifndef UF_COMPRESSED +# define UF_COMPRESSED 0x00000020 +#endif +#ifndef UF_TRACKED +# define UF_TRACKED 0x00000040 +#endif +#ifndef UF_DATAVAULT +# define UF_DATAVAULT 0x00000080 +#endif +#ifndef UF_HIDDEN +# define UF_HIDDEN 0x00008000 +#endif +#ifndef SF_SETTABLE +# define SF_SETTABLE 0xffff0000 +#endif +#ifndef SF_ARCHIVED +# define SF_ARCHIVED 0x00010000 +#endif +#ifndef SF_IMMUTABLE +# define SF_IMMUTABLE 0x00020000 +#endif +#ifndef SF_APPEND +# define SF_APPEND 0x00040000 +#endif +#ifndef SF_NOUNLINK +# define SF_NOUNLINK 0x00100000 +#endif +#ifndef SF_SNAPSHOT +# define SF_SNAPSHOT 0x00200000 +#endif +#ifndef SF_FIRMLINK +# define SF_FIRMLINK 0x00800000 +#endif +#ifndef SF_DATALESS +# define SF_DATALESS 0x40000000 +#endif +#if defined(__APPLE__) && !defined(SF_SUPPORTED) +/* On older macOS versions the definition of SF_SUPPORTED is different +* from that on newer versions. +* +* Provide a consistent experience by redefining. +* +* None of bit bits set in the actual SF_SUPPORTED but not in this +* definition are defined on these versions of macOS. +*/ +# undef SF_SETTABLE +# define SF_SUPPORTED 0x009f0000 +# define SF_SETTABLE 0x3fff0000 +# define SF_SYNTHETIC 0xc0000000 +#endif +static mode_t +_PyLong_AsMode_t(PyObject *op) +{ +unsigned long value; +mode_t mode; +if (PyLong_Check(op)) { +value = PyLong_AsUnsignedLong(op); +} +else { +op = PyNumber_Index(op); +if (op == NULL) { +return (mode_t)-1; +} +value = PyLong_AsUnsignedLong(op); +Py_DECREF(op); +} +if ((value == (unsigned long)-1) && PyErr_Occurred()) { +return (mode_t)-1; +} +mode = (mode_t)value; +if ((unsigned long)mode != value) { +PyErr_SetString(PyExc_OverflowError, "mode out of range"); +return (mode_t)-1; +} +return mode; +} +#define stat_S_ISFUNC(isfunc, doc) \ +static PyObject * \ +stat_ ##isfunc (PyObject *self, PyObject *omode) \ +{ \ +mode_t mode = _PyLong_AsMode_t(omode); \ +if ((mode == (mode_t)-1) && PyErr_Occurred()) \ +return NULL; \ +return PyBool_FromLong(isfunc(mode)); \ +} \ +PyDoc_STRVAR(stat_ ## isfunc ## _doc, doc) +stat_S_ISFUNC(S_ISDIR, +"S_ISDIR(mode) -> bool\n\n" +"Return True if mode is from a directory."); +stat_S_ISFUNC(S_ISCHR, +"S_ISCHR(mode) -> bool\n\n" +"Return True if mode is from a character special device file."); +stat_S_ISFUNC(S_ISBLK, +"S_ISBLK(mode) -> bool\n\n" +"Return True if mode is from a block special device file."); +stat_S_ISFUNC(S_ISREG, +"S_ISREG(mode) -> bool\n\n" +"Return True if mode is from a regular file."); +stat_S_ISFUNC(S_ISFIFO, +"S_ISFIFO(mode) -> bool\n\n" +"Return True if mode is from a FIFO (named pipe)."); +stat_S_ISFUNC(S_ISLNK, +"S_ISLNK(mode) -> bool\n\n" +"Return True if mode is from a symbolic link."); +stat_S_ISFUNC(S_ISSOCK, +"S_ISSOCK(mode) -> bool\n\n" +"Return True if mode is from a socket."); +stat_S_ISFUNC(S_ISDOOR, +"S_ISDOOR(mode) -> bool\n\n" +"Return True if mode is from a door."); +stat_S_ISFUNC(S_ISPORT, +"S_ISPORT(mode) -> bool\n\n" +"Return True if mode is from an event port."); +stat_S_ISFUNC(S_ISWHT, +"S_ISWHT(mode) -> bool\n\n" +"Return True if mode is from a whiteout."); +PyDoc_STRVAR(stat_S_IMODE_doc, +"Return the portion of the file's mode that can be set by os.chmod()."); +static PyObject * +stat_S_IMODE(PyObject *self, PyObject *omode) +{ +mode_t mode = _PyLong_AsMode_t(omode); +if ((mode == (mode_t)-1) && PyErr_Occurred()) +return NULL; +return PyLong_FromUnsignedLong(mode & S_IMODE); +} +PyDoc_STRVAR(stat_S_IFMT_doc, +"Return the portion of the file's mode that describes the file type."); +static PyObject * +stat_S_IFMT(PyObject *self, PyObject *omode) +{ +mode_t mode = _PyLong_AsMode_t(omode); +if ((mode == (mode_t)-1) && PyErr_Occurred()) +return NULL; +return PyLong_FromUnsignedLong(mode & S_IFMT); +} +/* file type chars according to +http://en.wikibooks.org/wiki/C_Programming/POSIX_Reference/sys/stat.h */ +static char +filetype(mode_t mode) +{ +/* common cases first */ +if (S_ISREG(mode)) return '-'; +if (S_ISDIR(mode)) return 'd'; +if (S_ISLNK(mode)) return 'l'; +/* special files */ +if (S_ISBLK(mode)) return 'b'; +if (S_ISCHR(mode)) return 'c'; +if (S_ISFIFO(mode)) return 'p'; +if (S_ISSOCK(mode)) return 's'; +/* non-standard types */ +if (S_ISDOOR(mode)) return 'D'; +if (S_ISPORT(mode)) return 'P'; +if (S_ISWHT(mode)) return 'w'; +/* unknown */ +return '?'; +} +static void +fileperm(mode_t mode, char *buf) +{ +buf[0] = mode & S_IRUSR ? 'r' : '-'; +buf[1] = mode & S_IWUSR ? 'w' : '-'; +if (mode & S_ISUID) { +buf[2] = mode & S_IXUSR ? 's' : 'S'; +} else { +buf[2] = mode & S_IXUSR ? 'x' : '-'; +} +buf[3] = mode & S_IRGRP ? 'r' : '-'; +buf[4] = mode & S_IWGRP ? 'w' : '-'; +if (mode & S_ISGID) { +buf[5] = mode & S_IXGRP ? 's' : 'S'; +} else { +buf[5] = mode & S_IXGRP ? 'x' : '-'; +} +buf[6] = mode & S_IROTH ? 'r' : '-'; +buf[7] = mode & S_IWOTH ? 'w' : '-'; +if (mode & S_ISVTX) { +buf[8] = mode & S_IXOTH ? 't' : 'T'; +} else { +buf[8] = mode & S_IXOTH ? 'x' : '-'; +} +} +PyDoc_STRVAR(stat_filemode_doc, +"Convert a file's mode to a string of the form '-rwxrwxrwx'"); +static PyObject * +stat_filemode(PyObject *self, PyObject *omode) +{ +char buf[10]; +mode_t mode; +mode = _PyLong_AsMode_t(omode); +if ((mode == (mode_t)-1) && PyErr_Occurred()) +return NULL; +buf[0] = filetype(mode); +fileperm(mode, &buf[1]); +return PyUnicode_FromStringAndSize(buf, 10); +} +static PyMethodDef stat_methods[] = { +{"S_ISDIR", stat_S_ISDIR, METH_O, stat_S_ISDIR_doc}, +{"S_ISCHR", stat_S_ISCHR, METH_O, stat_S_ISCHR_doc}, +{"S_ISBLK", stat_S_ISBLK, METH_O, stat_S_ISBLK_doc}, +{"S_ISREG", stat_S_ISREG, METH_O, stat_S_ISREG_doc}, +{"S_ISFIFO", stat_S_ISFIFO, METH_O, stat_S_ISFIFO_doc}, +{"S_ISLNK", stat_S_ISLNK, METH_O, stat_S_ISLNK_doc}, +{"S_ISSOCK", stat_S_ISSOCK, METH_O, stat_S_ISSOCK_doc}, +{"S_ISDOOR", stat_S_ISDOOR, METH_O, stat_S_ISDOOR_doc}, +{"S_ISPORT", stat_S_ISPORT, METH_O, stat_S_ISPORT_doc}, +{"S_ISWHT", stat_S_ISWHT, METH_O, stat_S_ISWHT_doc}, +{"S_IMODE", stat_S_IMODE, METH_O, stat_S_IMODE_doc}, +{"S_IFMT", stat_S_IFMT, METH_O, stat_S_IFMT_doc}, +{"filemode", stat_filemode, METH_O, stat_filemode_doc}, +{NULL, NULL} /* sentinel */ +}; +PyDoc_STRVAR(module_doc, +"S_IFMT_: file type bits\n\ +S_IFDIR: directory\n\ +S_IFCHR: character device\n\ +S_IFBLK: block device\n\ +S_IFREG: regular file\n\ +S_IFIFO: fifo (named pipe)\n\ +S_IFLNK: symbolic link\n\ +S_IFSOCK: socket file\n\ +S_IFDOOR: door\n\ +S_IFPORT: event port\n\ +S_IFWHT: whiteout\n\ +\n" +"S_ISUID: set UID bit\n\ +S_ISGID: set GID bit\n\ +S_ENFMT: file locking enforcement\n\ +S_ISVTX: sticky bit\n\ +S_IREAD: Unix V7 synonym for S_IRUSR\n\ +S_IWRITE: Unix V7 synonym for S_IWUSR\n\ +S_IEXEC: Unix V7 synonym for S_IXUSR\n\ +S_IRWXU: mask for owner permissions\n\ +S_IRUSR: read by owner\n\ +S_IWUSR: write by owner\n\ +S_IXUSR: execute by owner\n\ +S_IRWXG: mask for group permissions\n\ +S_IRGRP: read by group\n\ +S_IWGRP: write by group\n\ +S_IXGRP: execute by group\n\ +S_IRWXO: mask for others (not in group) permissions\n\ +S_IROTH: read by others\n\ +S_IWOTH: write by others\n\ +S_IXOTH: execute by others\n\ +\n" +"UF_SETTABLE: mask of owner changeable flags\n\ +UF_NODUMP: do not dump file\n\ +UF_IMMUTABLE: file may not be changed\n\ +UF_APPEND: file may only be appended to\n\ +UF_OPAQUE: directory is opaque when viewed through a union stack\n\ +UF_NOUNLINK: file may not be renamed or deleted\n\ +UF_COMPRESSED: macOS: file is hfs-compressed\n\ +UF_TRACKED: used for dealing with document IDs\n\ +UF_DATAVAULT: entitlement required for reading and writing\n\ +UF_HIDDEN: macOS: file should not be displayed\n\ +SF_SETTABLE: mask of super user changeable flags\n\ +SF_ARCHIVED: file may be archived\n\ +SF_IMMUTABLE: file may not be changed\n\ +SF_APPEND: file may only be appended to\n\ +SF_RESTRICTED: entitlement required for writing\n\ +SF_NOUNLINK: file may not be renamed or deleted\n\ +SF_SNAPSHOT: file is a snapshot file\n\ +SF_FIRMLINK: file is a firmlink\n\ +SF_DATALESS: file is a dataless object\n\ +\n\ +On macOS:\n\ +SF_SUPPORTED: mask of super user supported flags\n\ +SF_SYNTHETIC: mask of read-only synthetic flags\n\ +\n" +"ST_MODE\n\ +ST_INO\n\ +ST_DEV\n\ +ST_NLINK\n\ +ST_UID\n\ +ST_GID\n\ +ST_SIZE\n\ +ST_ATIME\n\ +ST_MTIME\n\ +ST_CTIME\n\ +\n" +"FILE_ATTRIBUTE_*: Windows file attribute constants\n\ +(only present on Windows)\n\ +"); +static int +stat_exec(PyObject *module) +{ +#define ADD_INT_MACRO(module, macro) \ +do { \ +if (PyModule_AddIntConstant(module, #macro, macro) < 0) { \ +return -1; \ +} \ +} while (0) +ADD_INT_MACRO(module, S_IFDIR); +ADD_INT_MACRO(module, S_IFCHR); +ADD_INT_MACRO(module, S_IFBLK); +ADD_INT_MACRO(module, S_IFREG); +ADD_INT_MACRO(module, S_IFIFO); +ADD_INT_MACRO(module, S_IFLNK); +ADD_INT_MACRO(module, S_IFSOCK); +ADD_INT_MACRO(module, S_IFDOOR); +ADD_INT_MACRO(module, S_IFPORT); +ADD_INT_MACRO(module, S_IFWHT); +ADD_INT_MACRO(module, S_ISUID); +ADD_INT_MACRO(module, S_ISGID); +ADD_INT_MACRO(module, S_ISVTX); +ADD_INT_MACRO(module, S_ENFMT); +ADD_INT_MACRO(module, S_IREAD); +ADD_INT_MACRO(module, S_IWRITE); +ADD_INT_MACRO(module, S_IEXEC); +ADD_INT_MACRO(module, S_IRWXU); +ADD_INT_MACRO(module, S_IRUSR); +ADD_INT_MACRO(module, S_IWUSR); +ADD_INT_MACRO(module, S_IXUSR); +ADD_INT_MACRO(module, S_IRWXG); +ADD_INT_MACRO(module, S_IRGRP); +ADD_INT_MACRO(module, S_IWGRP); +ADD_INT_MACRO(module, S_IXGRP); +ADD_INT_MACRO(module, S_IRWXO); +ADD_INT_MACRO(module, S_IROTH); +ADD_INT_MACRO(module, S_IWOTH); +ADD_INT_MACRO(module, S_IXOTH); +ADD_INT_MACRO(module, UF_SETTABLE); +ADD_INT_MACRO(module, UF_NODUMP); +ADD_INT_MACRO(module, UF_IMMUTABLE); +ADD_INT_MACRO(module, UF_APPEND); +ADD_INT_MACRO(module, UF_OPAQUE); +ADD_INT_MACRO(module, UF_NOUNLINK); +ADD_INT_MACRO(module, UF_COMPRESSED); +ADD_INT_MACRO(module, UF_TRACKED); +ADD_INT_MACRO(module, UF_DATAVAULT); +ADD_INT_MACRO(module, UF_HIDDEN); +ADD_INT_MACRO(module, SF_SETTABLE); +ADD_INT_MACRO(module, SF_ARCHIVED); +ADD_INT_MACRO(module, SF_IMMUTABLE); +ADD_INT_MACRO(module, SF_APPEND); +ADD_INT_MACRO(module, SF_NOUNLINK); +ADD_INT_MACRO(module, SF_SNAPSHOT); +ADD_INT_MACRO(module, SF_FIRMLINK); +ADD_INT_MACRO(module, SF_DATALESS); +#ifdef SF_SUPPORTED +ADD_INT_MACRO(module, SF_SUPPORTED); +#endif +#ifdef SF_SYNTHETIC +ADD_INT_MACRO(module, SF_SYNTHETIC); +#endif +const char* st_constants[] = { +"ST_MODE", +"ST_INO", +"ST_DEV", +"ST_NLINK", +"ST_UID", +"ST_GID", +"ST_SIZE", +"ST_ATIME", +"ST_MTIME", +"ST_CTIME" +}; +for (int i = 0; i < (int)Py_ARRAY_LENGTH(st_constants); i++) { +if (PyModule_AddIntConstant(module, st_constants[i], i) < 0) { +return -1; +} +} +#ifdef MS_WINDOWS +ADD_INT_MACRO(module, FILE_ATTRIBUTE_ARCHIVE); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_COMPRESSED); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_DEVICE); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_DIRECTORY); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_ENCRYPTED); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_HIDDEN); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_INTEGRITY_STREAM); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_NORMAL); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_NO_SCRUB_DATA); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_OFFLINE); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_READONLY); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_REPARSE_POINT); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_SPARSE_FILE); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_SYSTEM); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_TEMPORARY); +ADD_INT_MACRO(module, FILE_ATTRIBUTE_VIRTUAL); +if (PyModule_Add(module, "IO_REPARSE_TAG_SYMLINK", +PyLong_FromUnsignedLong(IO_REPARSE_TAG_SYMLINK)) < 0) { +return -1; +} +if (PyModule_Add(module, "IO_REPARSE_TAG_MOUNT_POINT", +PyLong_FromUnsignedLong(IO_REPARSE_TAG_MOUNT_POINT)) < 0) { +return -1; +} +if (PyModule_Add(module, "IO_REPARSE_TAG_APPEXECLINK", +PyLong_FromUnsignedLong(IO_REPARSE_TAG_APPEXECLINK)) < 0) { +return -1; +} +#endif +return 0; +} +static PyModuleDef_Slot stat_slots[] = { +{Py_mod_exec, stat_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL} +}; +static struct PyModuleDef statmodule = { +PyModuleDef_HEAD_INIT, +.m_name = "_stat", +.m_doc = module_doc, +.m_size = 0, +.m_methods = stat_methods, +.m_slots = stat_slots, +}; +PyMODINIT_FUNC +PyInit__stat(void) +{ +return PyModuleDef_Init(&statmodule); +} + +/* C implementation of the datetime module */ +/* bpo-35081: Defining this prevents including the C API capsule; +* internal versions of the Py*_Check macros which do not require +* the capsule are defined below */ +#define _PY_DATETIME_IMPL +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif +#include "Python.h" +#include "pycore_long.h" // _PyLong_GetOne() +#include "pycore_object.h" // _PyObject_Init() +#include "pycore_time.h" // _PyTime_ObjectToTime_t() +#include "pycore_unicodeobject.h" // _PyUnicode_Copy() +#include "pycore_initconfig.h" // _PyStatus_OK() +#include "pycore_pyatomic_ft_wrappers.h" +#include "datetime.h" +#include +#ifdef MS_WINDOWS +# include /* struct timeval */ +#endif +/* forward declarations */ +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; +/* The module has a fixed number of static objects, due to being exposed +* through the datetime C-API. There are five types exposed directly, +* one type exposed indirectly, and one singleton constant (UTC). +* +* Each of these objects is hidden behind a macro in the same way as +* the per-module objects stored in module state. The macros for the +* static objects don't need to be passed a state, but the consistency +* of doing so is more clear. We use a dedicated noop macro, NO_STATE, +* to make the special case obvious. +* +* The casting macros perform a simple fast pointer cast without +* checking the runtime type. In the future, we may decide whether +* to include that check and whether to provide a fast pointer cast +* macro for pointers known to be of correct time. +*/ +#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_CAST(op) ((PyDateTime_Date *)(op)) +#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_CAST(op) ((PyDateTime_DateTime *)(op)) +#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_CAST(op) ((PyDateTime_Time *)(op)) +#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_CAST(op) ((PyDateTime_Delta *)(op)) +#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_CAST(op) ((PyDateTime_TZInfo *)(op)) +#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_CAST(op) ((PyDateTime_TimeZone *)(op)) +#define PyTimezone_Check(op) PyObject_TypeCheck(op, TIMEZONE_TYPE(NO_STATE)) +#define PyIsoCalendarDate_CAST(op) ((PyDateTime_IsoCalendarDate *)(op)) +#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) +{ +PyObject *mod = NULL; +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) { +if (ref != Py_None) { +(void)PyWeakref_GetRef(ref, &mod); +if (mod == Py_None) { +Py_CLEAR(mod); +} +Py_DECREF(ref); +} +} +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); +if (mod == NULL) { +assert(!PyErr_Occurred()); +if (PyErr_Occurred()) { +return NULL; +} +/* The static types can outlive the module, +* so we must re-import 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 && ref != Py_None) { +PyObject *current = NULL; +int rc = PyWeakref_GetRef(ref, ¤t); +/* 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_FormatUnraisable("Exception ignored while clearing _datetime module"); +finally: +PyErr_SetRaisedException(exc); +} +/* We require that C int be at least 32 bits, and use int virtually +* everywhere. In just a few cases we use a temp long, where a Python +* API returns a C long. In such cases, we have to ensure that the +* final result fits in a C int (this can be an issue on 64-bit boxes). +*/ +#if SIZEOF_INT < 4 +# error "_datetime.c requires that C int have at least 32 bits" +#endif +#define MINYEAR 1 +#define MAXYEAR 9999 +#define MAXORDINAL 3652059 /* date(9999,12,31).toordinal() */ +/* Nine decimal digits is easy to communicate, and leaves enough room +* so that two delta days can be added w/o fear of overflowing a signed +* 32-bit int, and with plenty of room left over to absorb any possible +* carries from adding seconds. +*/ +#define MAX_DELTA_DAYS 999999999 +/* Rename the long macros in datetime.h to more reasonable short names. */ +#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 +/* Date accessors for date and datetime. */ +#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)) +/* Date/Time accessors for datetime. */ +#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)) +/* Time accessors for time. */ +#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)) +/* Delta accessors for timedelta. */ +#define GET_TD_DAYS(o) (PyDelta_CAST(o)->days) +#define GET_TD_SECONDS(o) (PyDelta_CAST(o)->seconds) +#define GET_TD_MICROSECONDS(o) (PyDelta_CAST(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 +/* M is a char or int claiming to be a valid month. The macro is equivalent +* to the two-sided Python test +* 1 <= M <= 12 +*/ +#define MONTH_IS_SANE(M) ((unsigned int)(M) - 1 < 12) +static int check_tzinfo_subclass(PyObject *p); +/*[clinic input] +module datetime +class datetime.datetime "PyDateTime_DateTime *" "get_datetime_state()->datetime_type" +class datetime.date "PyDateTime_Date *" "get_datetime_state()->date_type" +class datetime.time "PyDateTime_Time *" "get_datetime_state()->time_type" +class datetime.IsoCalendarDate "PyDateTime_IsoCalendarDate *" "get_datetime_state()->isocalendar_date_type" +class datetime.timedelta "PyDateTime_Delta *" "&PyDateTime_DeltaType" +class datetime.timezone "PyDateTime_TimeZone *" "&PyDateTime_TimeZoneType" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c54b9adf60082f0d]*/ +#include "clinic/_datetimemodule.c.h" +/* --------------------------------------------------------------------------- +* Math utilities. +*/ +/* k = i+j overflows iff k differs in sign from both inputs, +* iff k^i has sign bit set and k^j has sign bit set, +* iff (k^i)&(k^j) has sign bit set. +*/ +#define SIGNED_ADD_OVERFLOWED(RESULT, I, J) \ +((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0) +/* Compute Python divmod(x, y), returning the quotient and storing the +* remainder into *r. The quotient is the floor of x/y, and that's +* the real point of this. C will probably truncate instead (C99 +* requires truncation; C89 left it implementation-defined). +* Simplification: we *require* that y > 0 here. That's appropriate +* for all the uses made of it. This simplifies the code and makes +* the overflow case impossible (divmod(LONG_MIN, -1) is the only +* overflow case). +*/ +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; +} +/* Nearest integer to m / n for integers m and n. Half-integer results +* are rounded to even. +*/ +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; +} +/* --------------------------------------------------------------------------- +* General calendrical helper functions +*/ +/* For each month ordinal in 1..12, the number of days in that month, +* and the number of days before that month in the same year. These +* are correct for non-leap years only. +*/ +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 +}; +/* year -> 1 if leap year, else 0. */ +static int +is_leap(int year) +{ +/* Cast year to unsigned. The result is the same either way, but +* C can generate faster code for unsigned mod than for signed +* mod (especially for % 4 -- a good compiler should just grab +* the last 2 bits when the LHS is unsigned). +*/ +const unsigned int ayear = (unsigned int)year; +return ayear % 4 == 0 && (ayear % 100 != 0 || ayear % 400 == 0); +} +/* year, month -> number of days in that month in that year */ +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]; +} +/* year, month -> number of days in year preceding first day of 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; +} +/* year -> number of days before January 1st of year. Remember that we +* start with year 1, so days_before_year(1) == 0. +*/ +static int +days_before_year(int year) +{ +int y = year - 1; +/* This is incorrect if year <= 0; we really want the floor +* here. But so long as MINYEAR is 1, the smallest year this +* can see is 1. +*/ +assert (year >= 1); +return y*365 + y/4 - y/100 + y/400; +} +/* Number of days in 4, 100, and 400 year cycles. That these have +* the correct values is asserted in the module init function. +*/ +#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 */ +/* ordinal -> year, month, day, considering 01-Jan-0001 as day 1. */ +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 +* leap years repeats exactly every 400 years. The basic strategy is +* to find the closest 400-year boundary at or before ordinal, then +* work with the offset from that boundary to ordinal. Life is much +* clearer if we subtract 1 from ordinal first -- then the values +* of ordinal at 400-year boundaries are exactly those divisible +* by DI400Y: +* +* D M Y n n-1 +* -- --- ---- ---------- ---------------- +* 31 Dec -400 -DI400Y -DI400Y -1 +* 1 Jan -399 -DI400Y +1 -DI400Y 400-year boundary +* ... +* 30 Dec 000 -1 -2 +* 31 Dec 000 0 -1 +* 1 Jan 001 1 0 400-year boundary +* 2 Jan 001 2 1 +* 3 Jan 001 3 2 +* ... +* 31 Dec 400 DI400Y DI400Y -1 +* 1 Jan 401 DI400Y +1 DI400Y 400-year boundary +*/ +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 +* year, to the desired date. Now compute how many 100-year cycles +* precede n. +* Note that it's possible for n100 to equal 4! In that case 4 full +* 100-year cycles precede the desired day, which implies the +* desired day is December 31 at the end of a 400-year cycle. +*/ +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 +* meaning that the desired day is December 31 at the end of the +* 4-year cycle. +*/ +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 +* find the month via an estimate that's either exact or one too +* large. +*/ +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; +} +/* year, month, day -> ordinal, considering 01-Jan-0001 as day 1. */ +static int +ymd_to_ord(int year, int month, int day) +{ +return days_before_year(year) + days_before_month(year, month) + day; +} +/* Day of week, where Monday==0, ..., Sunday==6. 1/1/1 was a Monday. */ +static int +weekday(int year, int month, int day) +{ +return (ymd_to_ord(year, month, day) + 6) % 7; +} +/* Ordinal of the Monday starting week 1 of the ISO year. Week 1 is the +* first calendar week containing a Thursday. +*/ +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; +} +/* --------------------------------------------------------------------------- +* Range checkers. +*/ +/* Check that -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS. If so, return 0. +* If not, raise OverflowError and return -1. +*/ +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; +} +/* Check that date arguments are in range. Return 0 if they are. If they +* aren't, raise ValueError and return -1. +*/ +static int +check_date_args(int year, int month, int day) +{ +if (year < MINYEAR || year > MAXYEAR) { +PyErr_Format(PyExc_ValueError, +"year must be in %d..%d, not %d", MINYEAR, MAXYEAR, year); +return -1; +} +if (month < 1 || month > 12) { +PyErr_Format(PyExc_ValueError, +"month must be in 1..12, not %d", month); +return -1; +} +int dim = days_in_month(year, month); +if (day < 1 || day > dim) { +PyErr_Format(PyExc_ValueError, +"day %i must be in range 1..%d for month %i in year %i", +day, dim, month, year); +return -1; +} +return 0; +} +/* Check that time arguments are in range. Return 0 if they are. If they +* aren't, raise ValueError and return -1. +*/ +static int +check_time_args(int h, int m, int s, int us, int fold) +{ +if (h < 0 || h > 23) { +PyErr_Format(PyExc_ValueError, "hour must be in 0..23, not %i", h); +return -1; +} +if (m < 0 || m > 59) { +PyErr_Format(PyExc_ValueError, "minute must be in 0..59, not %i", m); +return -1; +} +if (s < 0 || s > 59) { +PyErr_Format(PyExc_ValueError, "second must be in 0..59, not %i", s); +return -1; +} +if (us < 0 || us > 999999) { +PyErr_Format(PyExc_ValueError, +"microsecond must be in 0..999999, not %i", us); +return -1; +} +if (fold != 0 && fold != 1) { +PyErr_Format(PyExc_ValueError, +"fold must be either 0 or 1, not %i", fold); +return -1; +} +return 0; +} +/* --------------------------------------------------------------------------- +* Normalization utilities. +*/ +/* One step of a mixed-radix conversion. A "hi" unit is equivalent to +* factor "lo" units. factor must be > 0. If *lo is less than 0, or +* at least factor, enough of *lo is converted into "hi" units so that +* 0 <= *lo < factor. The input values must be such that int overflow +* is impossible. +*/ +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); +} +/* Fiddle days (d), seconds (s), and microseconds (us) so that +* 0 <= *s < 24*3600 +* 0 <= *us < 1000000 +* The input values must be such that the internals don't overflow. +* The way this routine is used, we don't get close. +*/ +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 +* |original s| + |original us|/1000000 now. +*/ +} +if (*s < 0 || *s >= 24*3600) { +normalize_pair(d, s, 24*3600); +/* |d| can't be bigger than about +* |original d| + +* (|original s| + |original us|/1000000) / (24*3600) now. +*/ +} +assert(0 <= *s && *s < 24*3600); +assert(0 <= *us && *us < 1000000); +} +/* Fiddle years (y), months (m), and days (d) so that +* 1 <= *m <= 12 +* 1 <= *d <= days_in_month(*y, *m) +* The input values must be such that the internals don't overflow. +* The way this routine is used, we don't get close. +*/ +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 +* date/datetime object. Therefore it is always in [1, 12] range. +*/ +assert(1 <= *m && *m <= 12); +/* Now only day can be out of bounds (year may also be out of bounds +* for a datetime object, but we don't care about that here). +* If day is out of bounds, what to do is arguable, but at least the +* method here is principled and explainable. +*/ +dim = days_in_month(*y, *m); +if (*d < 1 || *d > dim) { +/* Move day-1 days from the first of the month. First try to +* get off cheap if we're only one day out of range +* (adjustments for timezone alone can't be worse than that). +*/ +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; +} +/* Fiddle out-of-bounds months and days so that the result makes some kind +* of sense. The parameters are both inputs and outputs. Returns < 0 on +* failure, where failure means the adjusted year is out of bounds. +*/ +static int +normalize_date(int *year, int *month, int *day) +{ +return normalize_y_m_d(year, month, day); +} +/* Force all the datetime fields into range. The parameters are both +* inputs and outputs. Returns < 0 on error. +*/ +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); +} +/* --------------------------------------------------------------------------- +* Basic object allocation: tp_alloc implementations. These allocate +* Python objects of the right size and type, and do the Python object- +* initialization bit. If there's not enough memory, they return NULL after +* setting MemoryError. All data members remain uninitialized trash. +* +* We abuse the tp_alloc "nitems" argument to communicate whether a tzinfo +* member is needed. This is ugly, imprecise, and possibly insecure. +* tp_basicsize for the time and datetime types is set to the size of the +* struct that has room for the tzinfo member, so subclasses in Python will +* allocate enough space for a tzinfo member whether or not one is actually +* needed. That's the "ugly and imprecise" parts. The "possibly insecure" +* part is that PyType_GenericAlloc() (which subclasses in Python end up +* using) just happens today to effectively ignore the nitems argument +* when tp_itemsize is 0, which it is for these type objects. If that +* changes, perhaps the callers of tp_alloc slots in this file should +* be changed to force a 0 nitems argument unless the type being allocated +* is a base type implemented in this file (so that tp_alloc is time_alloc +* or datetime_alloc below, which know about the nitems abuse). +*/ +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; +} +/* --------------------------------------------------------------------------- +* Helpers for setting object fields. These work on pointers to the +* appropriate base class. +*/ +/* For date and datetime. */ +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); +} +/* --------------------------------------------------------------------------- +* String parsing utilities and helper functions +*/ +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() +* +* Return codes: +* 0: Success +* -1: Failed to parse date component +* -2: Inconsistent date separator usage +* -3: Failed to parse ISO week. +* -4: Failed to parse ISO day. +* -5, -6, -7: Failure in iso_to_ymd +*/ +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}; +// This is initialized to satisfy an erroneous compiler warning. +unsigned char has_separator = 1; +// Parse [HH[:?MM[:?SS]]] +for (size_t i = 0; i < 3; ++i) { +p = parse_digits(p, vals[i], 2); +if (NULL == p) { +return -3; +} +char c = *(p++); +if (i == 0) { +has_separator = (c == ':'); +} +if (p >= p_end) { +return c != '\0'; +} +else if (has_separator && (c == ':')) { +if (i == 2) { +return -4; // Malformed microsecond separator +} +continue; +} +else if (c == '.' || c == ',') { +if (i < 2) { +return -3; // Decimal mark on hour or minute +} +break; +} else if (!has_separator) { +--p; +} else { +return -4; // Malformed time separator +} +} +// Parse fractional components +size_t len_remains = p_end - p; +size_t to_parse = len_remains; +if (len_remains >= 6) { +to_parse = 6; +} +p = parse_digits(p, microsecond, to_parse); +if (NULL == p) { +return -3; +} +static int correction[] = { +100000, 10000, 1000, 100, 10 +}; +if (to_parse < 6) { +*microsecond *= correction[to_parse-1]; +} +while (is_digit(*p)){ +++p; // skip truncated digits +} +// Return 1 if it's not the end of the string +return *p != '\0'; +} +static int +parse_isoformat_time(const char *dtstr, size_t dtlen, int *hour, int *minute, +int *second, int *microsecond, int *tzoffset, +int *tzmicrosecond) +{ +// Parse the time portion of a datetime.isoformat() string +// +// Return codes: +// 0: Success (no tzoffset) +// 1: Success (with tzoffset) +// -3: Failed to parse time component +// -4: Failed to parse time separator +// -5: Malformed timezone string +// -6: Timezone fields are not in range +const char *p = dtstr; +const char *p_end = dtstr + dtlen; +const char *tzinfo_pos = p; +do { +if (*tzinfo_pos == 'Z' || *tzinfo_pos == '+' || *tzinfo_pos == '-') { +break; +} +} while (++tzinfo_pos < p_end); +int rv = parse_hh_mm_ss_ff(dtstr, tzinfo_pos, hour, minute, second, +microsecond); +if (rv < 0) { +return rv; +} +else if (tzinfo_pos == p_end) { +// We know that there's no time zone, so if there's stuff at the +// end of the string it's an error. +if (rv == 1) { +return -5; +} +else { +return 0; +} +} +// Special case UTC / Zulu time. +if (*tzinfo_pos == 'Z') { +*tzoffset = 0; +*tzmicrosecond = 0; +if (*(tzinfo_pos + 1) != '\0') { +return -5; +} else { +return 1; +} +} +int tzsign = (*tzinfo_pos == '-') ? -1 : 1; +tzinfo_pos++; +int tzhour = 0, tzminute = 0, tzsecond = 0; +rv = parse_hh_mm_ss_ff(tzinfo_pos, p_end, &tzhour, &tzminute, &tzsecond, +tzmicrosecond); +// Check if timezone fields are in range +if (check_time_args(tzhour, tzminute, tzsecond, *tzmicrosecond, 0) < 0) { +return -6; +} +*tzoffset = tzsign * ((tzhour * 3600) + (tzminute * 60) + tzsecond); +*tzmicrosecond *= tzsign; +return rv ? -5 : 1; +} +/* --------------------------------------------------------------------------- +* Create various objects, mostly without range checking. +*/ +/* Create a date instance with no range checking. */ +static PyObject * +new_date_ex(int year, int month, int day, PyTypeObject *type) +{ +PyDateTime_Date *self; +if (check_date_args(year, month, day) < 0) { +return NULL; +} +self = (PyDateTime_Date *)(type->tp_alloc(type, 0)); +if (self != NULL) +set_date_fields(self, year, month, day); +return (PyObject *)self; +} +#define new_date(year, month, day) \ +new_date_ex(year, month, day, DATE_TYPE(NO_STATE)) +// Forward declaration +static PyObject * +new_datetime_ex(int, int, int, int, int, int, int, PyObject *, PyTypeObject *); +/* Create date instance with no range checking, or call subclass constructor */ +static PyObject * +new_date_subclass_ex(int year, int month, int day, PyTypeObject *cls) +{ +PyObject *result; +// We have "fast path" constructors for two subclasses: date and datetime +if (cls == DATE_TYPE(NO_STATE)) { +result = new_date_ex(year, month, day, cls); +} +else if (cls == DATETIME_TYPE(NO_STATE)) { +result = new_datetime_ex(year, month, day, 0, 0, 0, 0, Py_None, cls); +} +else { +result = PyObject_CallFunction((PyObject *)cls, "iii", year, month, day); +} +return result; +} +/* Create a datetime instance with no range checking. */ +static PyObject * +new_datetime_ex2(int year, int month, int day, int hour, int minute, +int second, int usecond, PyObject *tzinfo, int fold, PyTypeObject *type) +{ +PyDateTime_DateTime *self; +char aware = tzinfo != Py_None; +if (check_date_args(year, month, day) < 0) { +return NULL; +} +if (check_time_args(hour, minute, second, usecond, fold) < 0) { +return NULL; +} +if (check_tzinfo_subclass(tzinfo) < 0) { +return NULL; +} +self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware)); +if (self != NULL) { +self->hastzinfo = aware; +set_date_fields((PyDateTime_Date *)self, year, month, day); +DATE_SET_HOUR(self, hour); +DATE_SET_MINUTE(self, minute); +DATE_SET_SECOND(self, second); +DATE_SET_MICROSECOND(self, usecond); +if (aware) { +self->tzinfo = Py_NewRef(tzinfo); +} +DATE_SET_FOLD(self, fold); +} +return (PyObject *)self; +} +static PyObject * +new_datetime_ex(int year, int month, int day, int hour, int minute, +int second, int usecond, PyObject *tzinfo, PyTypeObject *type) +{ +return new_datetime_ex2(year, month, day, hour, minute, second, usecond, +tzinfo, 0, type); +} +#define new_datetime(y, m, d, hh, mm, ss, us, tzinfo, fold) \ +new_datetime_ex2(y, m, d, hh, mm, ss, us, tzinfo, fold, DATETIME_TYPE(NO_STATE)) +static PyObject * +call_subclass_fold(PyTypeObject *cls, int fold, const char *format, ...) +{ +PyObject *kwargs = NULL, *res = NULL; +va_list va; +va_start(va, format); +PyObject *args = Py_VaBuildValue(format, va); +va_end(va); +if (args == NULL) { +return NULL; +} +if (fold) { +kwargs = PyDict_New(); +if (kwargs == NULL) { +goto Done; +} +PyObject *obj = PyLong_FromLong(fold); +if (obj == NULL) { +goto Done; +} +int err = PyDict_SetItemString(kwargs, "fold", obj); +Py_DECREF(obj); +if (err < 0) { +goto Done; +} +} +res = PyObject_Call((PyObject *)cls, args, kwargs); +Done: +Py_DECREF(args); +Py_XDECREF(kwargs); +return res; +} +static PyObject * +new_datetime_subclass_fold_ex(int year, int month, int day, int hour, int minute, +int second, int usecond, PyObject *tzinfo, +int fold, PyTypeObject *cls) +{ +PyObject* dt; +if (cls == DATETIME_TYPE(NO_STATE)) { +// Use the fast path constructor +dt = new_datetime(year, month, day, hour, minute, second, usecond, +tzinfo, fold); +} +else { +// Subclass +dt = call_subclass_fold(cls, fold, "iiiiiiiO", year, month, day, +hour, minute, second, usecond, tzinfo); +} +return dt; +} +static PyObject * +new_datetime_subclass_ex(int year, int month, int day, int hour, int minute, +int second, int usecond, PyObject *tzinfo, +PyTypeObject *cls) { +return new_datetime_subclass_fold_ex(year, month, day, hour, minute, +second, usecond, tzinfo, 0, +cls); +} +/* Create a time instance with no range checking. */ +static PyObject * +new_time_ex2(int hour, int minute, int second, int usecond, +PyObject *tzinfo, int fold, PyTypeObject *type) +{ +PyDateTime_Time *self; +char aware = tzinfo != Py_None; +if (check_time_args(hour, minute, second, usecond, fold) < 0) { +return NULL; +} +if (check_tzinfo_subclass(tzinfo) < 0) { +return NULL; +} +self = (PyDateTime_Time *) (type->tp_alloc(type, aware)); +if (self != NULL) { +self->hastzinfo = aware; +self->hashcode = -1; +TIME_SET_HOUR(self, hour); +TIME_SET_MINUTE(self, minute); +TIME_SET_SECOND(self, second); +TIME_SET_MICROSECOND(self, usecond); +if (aware) { +self->tzinfo = Py_NewRef(tzinfo); +} +TIME_SET_FOLD(self, fold); +} +return (PyObject *)self; +} +static PyObject * +new_time_ex(int hour, int minute, int second, int usecond, +PyObject *tzinfo, PyTypeObject *type) +{ +return new_time_ex2(hour, minute, second, usecond, tzinfo, 0, type); +} +#define new_time(hh, mm, ss, us, tzinfo, fold) \ +new_time_ex2(hh, mm, ss, us, tzinfo, fold, TIME_TYPE(NO_STATE)) +static PyObject * +new_time_subclass_fold_ex(int hour, int minute, int second, int usecond, +PyObject *tzinfo, int fold, PyTypeObject *cls) +{ +PyObject *t; +if (cls == TIME_TYPE(NO_STATE)) { +// Use the fast path constructor +t = new_time(hour, minute, second, usecond, tzinfo, fold); +} +else { +// Subclass +t = call_subclass_fold(cls, fold, "iiiiO", hour, minute, second, +usecond, tzinfo); +} +return t; +} +static PyDateTime_Delta * look_up_delta(int, int, int, PyTypeObject *); +/* Create a timedelta instance. Normalize the members iff normalize is +* true. Passing false is a speed optimization, if you know for sure +* that seconds and microseconds are already in their proper ranges. In any +* case, raises OverflowError and returns NULL if the normalized days is out +* of range. +*/ +static PyObject * +new_delta_ex(int days, int seconds, int microseconds, int normalize, +PyTypeObject *type) +{ +PyDateTime_Delta *self; +if (normalize) +normalize_d_s_us(&days, &seconds, µseconds); +assert(0 <= seconds && seconds < 24*3600); +assert(0 <= microseconds && microseconds < 1000000); +if (check_delta_day_range(days) < 0) +return NULL; +self = look_up_delta(days, seconds, microseconds, type); +if (self != NULL) { +return (PyObject *)self; +} +assert(!PyErr_Occurred()); +self = (PyDateTime_Delta *) (type->tp_alloc(type, 0)); +if (self != NULL) { +self->hashcode = -1; +SET_TD_DAYS(self, days); +SET_TD_SECONDS(self, seconds); +SET_TD_MICROSECONDS(self, microseconds); +} +return (PyObject *) self; +} +#define new_delta(d, s, us, normalize) \ +new_delta_ex(d, s, us, normalize, DELTA_TYPE(NO_STATE)) +typedef struct +{ +PyObject_HEAD +PyObject *offset; +PyObject *name; +} PyDateTime_TimeZone; +static PyDateTime_TimeZone * look_up_timezone(PyObject *offset, PyObject *name); +/* Create new timezone instance checking offset range. This +function does not check the name argument. Caller must assure +that offset is a timedelta instance and name is either NULL +or a unicode object. */ +static PyObject * +create_timezone(PyObject *offset, PyObject *name) +{ +PyDateTime_TimeZone *self; +PyTypeObject *type = TIMEZONE_TYPE(NO_STATE); +assert(offset != NULL); +assert(PyDelta_Check(offset)); +assert(name == NULL || PyUnicode_Check(name)); +self = look_up_timezone(offset, name); +if (self != NULL) { +return (PyObject *)self; +} +assert(!PyErr_Occurred()); +self = (PyDateTime_TimeZone *)(type->tp_alloc(type, 0)); +if (self == NULL) { +return NULL; +} +self->offset = Py_NewRef(offset); +self->name = Py_XNewRef(name); +return (PyObject *)self; +} +static int delta_bool(PyObject *op); +static PyDateTime_TimeZone utc_timezone; +static PyObject * +new_timezone(PyObject *offset, PyObject *name) +{ +assert(offset != NULL); +assert(PyDelta_Check(offset)); +assert(name == NULL || PyUnicode_Check(name)); +if (name == NULL && delta_bool(offset) == 0) { +return Py_NewRef(CONST_UTC(NO_STATE)); +} +if ((GET_TD_DAYS(offset) == -1 && +GET_TD_SECONDS(offset) == 0 && +GET_TD_MICROSECONDS(offset) < 1) || +GET_TD_DAYS(offset) < -1 || GET_TD_DAYS(offset) >= 1) { +PyErr_Format(PyExc_ValueError, "offset must be a timedelta" +" strictly between -timedelta(hours=24) and" +" timedelta(hours=24), not %R", offset); +return NULL; +} +return create_timezone(offset, name); +} +/* --------------------------------------------------------------------------- +* tzinfo helpers. +*/ +/* Ensure that p is None or of a tzinfo subclass. Return 0 if OK; if not +* raise TypeError and return -1. +*/ +static int +check_tzinfo_subclass(PyObject *p) +{ +if (p == Py_None || PyTZInfo_Check(p)) +return 0; +PyErr_Format(PyExc_TypeError, +"tzinfo argument must be None or of a tzinfo subclass, " +"not type '%s'", +Py_TYPE(p)->tp_name); +return -1; +} +/* If self has a tzinfo member, return a BORROWED reference to it. Else +* return NULL, which is NOT AN ERROR. There are no error returns here, +* and the caller must not decref the result. +*/ +static PyObject * +get_tzinfo_member(PyObject *self) +{ +PyObject *tzinfo = NULL; +if (PyDateTime_Check(self) && HASTZINFO(self)) +tzinfo = ((PyDateTime_DateTime *)self)->tzinfo; +else if (PyTime_Check(self) && HASTZINFO(self)) +tzinfo = ((PyDateTime_Time *)self)->tzinfo; +return tzinfo; +} +/* Call getattr(tzinfo, name)(tzinfoarg), and check the result. tzinfo must +* be an instance of the tzinfo class. If the method returns None, this +* returns None. If the method doesn't return None or timedelta, TypeError is +* raised and this returns NULL. If it returns a timedelta and the value is +* out of range or isn't a whole number of minutes, ValueError is raised and +* this returns NULL. Else result is returned. +*/ +static PyObject * +call_tzinfo_method(PyObject *tzinfo, const char *name, PyObject *tzinfoarg) +{ +PyObject *offset; +assert(tzinfo != NULL); +assert(PyTZInfo_Check(tzinfo) || tzinfo == Py_None); +assert(tzinfoarg != NULL); +if (tzinfo == Py_None) +Py_RETURN_NONE; +offset = PyObject_CallMethod(tzinfo, name, "O", tzinfoarg); +if (offset == Py_None || offset == NULL) +return offset; +if (PyDelta_Check(offset)) { +if ((GET_TD_DAYS(offset) == -1 && +GET_TD_SECONDS(offset) == 0 && +GET_TD_MICROSECONDS(offset) < 1) || +GET_TD_DAYS(offset) < -1 || GET_TD_DAYS(offset) >= 1) { +PyErr_Format(PyExc_ValueError, "offset must be a timedelta" +" strictly between -timedelta(hours=24) and" +" timedelta(hours=24), not %R", offset); +Py_DECREF(offset); +return NULL; +} +} +else { +PyErr_Format(PyExc_TypeError, +"tzinfo.%s() must return None or " +"timedelta, not '%.200s'", +name, Py_TYPE(offset)->tp_name); +Py_DECREF(offset); +return NULL; +} +return offset; +} +/* Call tzinfo.utcoffset(tzinfoarg), and extract an integer from the +* result. tzinfo must be an instance of the tzinfo class. If utcoffset() +* returns None, call_utcoffset returns 0 and sets *none to 1. If uctoffset() +* doesn't return None or timedelta, TypeError is raised and this returns -1. +* If utcoffset() returns an out of range timedelta, +* ValueError is raised and this returns -1. Else *none is +* set to 0 and the offset is returned (as timedelta, positive east of UTC). +*/ +static PyObject * +call_utcoffset(PyObject *tzinfo, PyObject *tzinfoarg) +{ +return call_tzinfo_method(tzinfo, "utcoffset", tzinfoarg); +} +/* Call tzinfo.dst(tzinfoarg), and extract an integer from the +* result. tzinfo must be an instance of the tzinfo class. If dst() +* returns None, call_dst returns 0 and sets *none to 1. If dst() +* doesn't return None or timedelta, TypeError is raised and this +* returns -1. If dst() returns an invalid timedelta for a UTC offset, +* ValueError is raised and this returns -1. Else *none is set to 0 and +* the offset is returned (as timedelta, positive east of UTC). +*/ +static PyObject * +call_dst(PyObject *tzinfo, PyObject *tzinfoarg) +{ +return call_tzinfo_method(tzinfo, "dst", tzinfoarg); +} +/* Call tzinfo.tzname(tzinfoarg), and return the result. tzinfo must be +* an instance of the tzinfo class or None. If tzinfo isn't None, and +* tzname() doesn't return None or a string, TypeError is raised and this +* returns NULL. If the result is a string, we ensure it is a Unicode +* string. +*/ +static PyObject * +call_tzname(PyObject *tzinfo, PyObject *tzinfoarg) +{ +PyObject *result; +assert(tzinfo != NULL); +assert(check_tzinfo_subclass(tzinfo) >= 0); +assert(tzinfoarg != NULL); +if (tzinfo == Py_None) +Py_RETURN_NONE; +result = PyObject_CallMethodOneArg(tzinfo, &_Py_ID(tzname), tzinfoarg); +if (result == NULL || result == Py_None) +return result; +if (!PyUnicode_Check(result)) { +PyErr_Format(PyExc_TypeError, "tzinfo.tzname() must " +"return None or a string, not '%s'", +Py_TYPE(result)->tp_name); +Py_SETREF(result, NULL); +} +return result; +} +/* repr is like "someclass(arg1, arg2)". If tzinfo isn't None, +* stuff +* ", tzinfo=" + repr(tzinfo) +* before the closing ")". +*/ +static PyObject * +append_keyword_tzinfo(PyObject *repr, PyObject *tzinfo) +{ +PyObject *temp; +assert(PyUnicode_Check(repr)); +assert(tzinfo); +if (tzinfo == Py_None) +return repr; +/* Get rid of the trailing ')'. */ +assert(PyUnicode_READ_CHAR(repr, PyUnicode_GET_LENGTH(repr)-1) == ')'); +temp = PyUnicode_Substring(repr, 0, PyUnicode_GET_LENGTH(repr) - 1); +Py_DECREF(repr); +if (temp == NULL) +return NULL; +repr = PyUnicode_FromFormat("%U, tzinfo=%R)", temp, tzinfo); +Py_DECREF(temp); +return repr; +} +/* repr is like "someclass(arg1, arg2)". If fold isn't 0, +* stuff +* ", fold=" + repr(tzinfo) +* before the closing ")". +*/ +static PyObject * +append_keyword_fold(PyObject *repr, int fold) +{ +PyObject *temp; +assert(PyUnicode_Check(repr)); +if (fold == 0) +return repr; +/* Get rid of the trailing ')'. */ +assert(PyUnicode_READ_CHAR(repr, PyUnicode_GET_LENGTH(repr)-1) == ')'); +temp = PyUnicode_Substring(repr, 0, PyUnicode_GET_LENGTH(repr) - 1); +Py_DECREF(repr); +if (temp == NULL) +return NULL; +repr = PyUnicode_FromFormat("%U, fold=%d)", temp, fold); +Py_DECREF(temp); +return repr; +} +static inline PyObject * +tzinfo_from_isoformat_results(int rv, int tzoffset, int tz_useconds) +{ +PyObject *tzinfo; +if (rv == 1) { +// Create a timezone from offset in seconds (0 returns UTC) +if (tzoffset == 0) { +return Py_NewRef(CONST_UTC(NO_STATE)); +} +PyObject *delta = new_delta(0, tzoffset, tz_useconds, 1); +if (delta == NULL) { +return NULL; +} +tzinfo = new_timezone(delta, NULL); +Py_DECREF(delta); +} +else { +tzinfo = Py_NewRef(Py_None); +} +return tzinfo; +} +/* --------------------------------------------------------------------------- +* String format helpers. +*/ +static PyObject * +format_ctime(PyObject *date, int hours, int minutes, int seconds) +{ +static const char * const DayNames[] = { +"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" +}; +static const char * const MonthNames[] = { +"Jan", "Feb", "Mar", "Apr", "May", "Jun", +"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; +int wday = weekday(GET_YEAR(date), GET_MONTH(date), GET_DAY(date)); +return PyUnicode_FromFormat("%s %s %2d %02d:%02d:%02d %04d", +DayNames[wday], MonthNames[GET_MONTH(date)-1], +GET_DAY(date), hours, minutes, seconds, +GET_YEAR(date)); +} +static PyObject *delta_negative(PyObject *op); +/* Add formatted UTC offset string to buf. buf has no more than +* buflen bytes remaining. The UTC offset is gotten by calling +* tzinfo.uctoffset(tzinfoarg). If that returns None, \0 is stored into +* *buf, and that's all. Else the returned value is checked for sanity (an +* integer in range), and if that's OK it's converted to an hours & minutes +* string of the form +* sign HH sep MM [sep SS [. UUUUUU]] +* Returns 0 if everything is OK. If the return value from utcoffset() is +* bogus, an appropriate exception is set and -1 is returned. +*/ +static int +format_utcoffset(char *buf, size_t buflen, const char *sep, +PyObject *tzinfo, PyObject *tzinfoarg) +{ +PyObject *offset; +int hours, minutes, seconds, microseconds; +char sign; +assert(buflen >= 1); +offset = call_utcoffset(tzinfo, tzinfoarg); +if (offset == NULL) +return -1; +if (offset == Py_None) { +Py_DECREF(offset); +*buf = '\0'; +return 0; +} +/* Offset is normalized, so it is negative if days < 0 */ +if (GET_TD_DAYS(offset) < 0) { +sign = '-'; +Py_SETREF(offset, delta_negative(offset)); +if (offset == NULL) +return -1; +} +else { +sign = '+'; +} +/* Offset is not negative here. */ +microseconds = GET_TD_MICROSECONDS(offset); +seconds = GET_TD_SECONDS(offset); +Py_DECREF(offset); +minutes = divmod(seconds, 60, &seconds); +hours = divmod(minutes, 60, &minutes); +if (microseconds) { +PyOS_snprintf(buf, buflen, "%c%02d%s%02d%s%02d.%06d", sign, +hours, sep, minutes, sep, seconds, microseconds); +return 0; +} +if (seconds) { +PyOS_snprintf(buf, buflen, "%c%02d%s%02d%s%02d", sign, hours, +sep, minutes, sep, seconds); +return 0; +} +PyOS_snprintf(buf, buflen, "%c%02d%s%02d", sign, hours, sep, minutes); +return 0; +} +/* Check whether year with century should be normalized for strftime. */ +inline static int +normalize_century(void) +{ +static int cache = -1; +if (cache < 0) { +char year[5]; +struct tm date = { +.tm_year = -1801, +.tm_mon = 0, +.tm_mday = 1 +}; +cache = (strftime(year, sizeof(year), "%Y", &date) && +strcmp(year, "0099") != 0); +} +return cache; +} +static PyObject * +make_somezreplacement(PyObject *object, char *sep, PyObject *tzinfoarg) +{ +char buf[100]; +PyObject *tzinfo = get_tzinfo_member(object); +if (tzinfo == Py_None || tzinfo == NULL) { +return PyUnicode_FromStringAndSize(NULL, 0); +} +assert(tzinfoarg != NULL); +if (format_utcoffset(buf, +sizeof(buf), +sep, +tzinfo, +tzinfoarg) < 0) +return NULL; +return PyUnicode_FromString(buf); +} +static PyObject * +make_Zreplacement(PyObject *object, PyObject *tzinfoarg) +{ +PyObject *temp; +PyObject *tzinfo = get_tzinfo_member(object); +PyObject *Zreplacement = Py_GetConstant(Py_CONSTANT_EMPTY_STR); +if (Zreplacement == NULL) +return NULL; +if (tzinfo == Py_None || tzinfo == NULL) +return Zreplacement; +assert(tzinfoarg != NULL); +temp = call_tzname(tzinfo, tzinfoarg); +if (temp == NULL) +goto Error; +if (temp == Py_None) { +Py_DECREF(temp); +return Zreplacement; +} +assert(PyUnicode_Check(temp)); +/* Since the tzname is getting stuffed into the +* format, we have to double any % signs so that +* strftime doesn't treat them as format codes. +*/ +Py_DECREF(Zreplacement); +Zreplacement = PyObject_CallMethod(temp, "replace", "ss", "%", "%%"); +Py_DECREF(temp); +if (Zreplacement == NULL) +return NULL; +if (!PyUnicode_Check(Zreplacement)) { +PyErr_SetString(PyExc_TypeError, +"tzname.replace() did not return a string"); +goto Error; +} +return Zreplacement; +Error: +Py_DECREF(Zreplacement); +return NULL; +} +static PyObject * +make_freplacement(PyObject *object) +{ +char freplacement[64]; +if (PyTime_Check(object)) +sprintf(freplacement, "%06d", TIME_GET_MICROSECOND(object)); +else if (PyDateTime_Check(object)) +sprintf(freplacement, "%06d", DATE_GET_MICROSECOND(object)); +else +sprintf(freplacement, "%06d", 0); +return PyUnicode_FromString(freplacement); +} +/* I sure don't want to reproduce the strftime code from the time module, +* so this imports the module and calls it. All the hair is due to +* giving special meanings to the %z, %:z, %Z and %f format codes via a +* preprocessing step on the format string. +* tzinfoarg is the argument to pass to the object's tzinfo method, if +* needed. +*/ +static PyObject * +wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple, +PyObject *tzinfoarg) +{ +PyObject *result = NULL; /* guilty until proved innocent */ +PyObject *zreplacement = NULL; /* py string, replacement for %z */ +PyObject *colonzreplacement = NULL; /* py string, replacement for %:z */ +PyObject *Zreplacement = NULL; /* py string, replacement for %Z */ +PyObject *freplacement = NULL; /* py string, replacement for %f */ +assert(object && format && timetuple); +assert(PyUnicode_Check(format)); +PyObject *strftime = PyImport_ImportModuleAttrString("time", "strftime"); +if (strftime == NULL) { +return NULL; +} +/* Scan the input format, looking for %z/%Z/%f escapes, building +* a new format. Since computing the replacements for those codes +* is expensive, don't unless they're actually used. +*/ +PyUnicodeWriter *writer = PyUnicodeWriter_Create(0); +if (writer == NULL) { +goto Error; +} +Py_ssize_t flen = PyUnicode_GET_LENGTH(format); +Py_ssize_t i = 0; +Py_ssize_t start = 0; +Py_ssize_t end = 0; +while (i != flen) { +i = PyUnicode_FindChar(format, '%', i, flen, 1); +if (i < 0) { +assert(!PyErr_Occurred()); +break; +} +end = i; +i++; +if (i == flen) { +break; +} +Py_UCS4 ch = PyUnicode_READ_CHAR(format, i); +i++; +/* A % has been seen and ch is the character after it. */ +PyObject *replacement = NULL; +if (ch == 'z') { +/* %z -> +HHMM */ +if (zreplacement == NULL) { +zreplacement = make_somezreplacement(object, "", tzinfoarg); +if (zreplacement == NULL) +goto Error; +} +replacement = zreplacement; +} +else if (ch == ':' && i < flen && PyUnicode_READ_CHAR(format, i) == 'z') { +/* %:z -> +HH:MM */ +i++; +if (colonzreplacement == NULL) { +colonzreplacement = make_somezreplacement(object, ":", tzinfoarg); +if (colonzreplacement == NULL) +goto Error; +} +replacement = colonzreplacement; +} +else if (ch == 'Z') { +/* format tzname */ +if (Zreplacement == NULL) { +Zreplacement = make_Zreplacement(object, +tzinfoarg); +if (Zreplacement == NULL) +goto Error; +} +replacement = Zreplacement; +} +else if (ch == 'f') { +/* format microseconds */ +if (freplacement == NULL) { +freplacement = make_freplacement(object); +if (freplacement == NULL) +goto Error; +} +replacement = freplacement; +} +else if (normalize_century() +&& (ch == 'Y' || ch == 'G' || ch == 'F' || ch == 'C')) +{ +/* 0-pad year with century as necessary */ +PyObject *item = PySequence_GetItem(timetuple, 0); +if (item == NULL) { +goto Error; +} +long year_long = PyLong_AsLong(item); +Py_DECREF(item); +if (year_long == -1 && PyErr_Occurred()) { +goto Error; +} +/* Note that datetime(1000, 1, 1).strftime('%G') == '1000' so year +1000 for %G can go on the fast path. */ +if (year_long >= 1000) { +continue; +} +if (ch == 'G') { +PyObject *year_str = PyObject_CallFunction(strftime, "sO", +"%G", timetuple); +if (year_str == NULL) { +goto Error; +} +PyObject *year = PyNumber_Long(year_str); +Py_DECREF(year_str); +if (year == NULL) { +goto Error; +} +year_long = PyLong_AsLong(year); +Py_DECREF(year); +if (year_long == -1 && PyErr_Occurred()) { +goto Error; +} +} +/* Buffer of maximum size of formatted year permitted by long. +* +6 to accommodate dashes, 2-digit month and day for %F. */ +char buf[SIZEOF_LONG * 5 / 2 + 2 + 6]; +Py_ssize_t n = PyOS_snprintf(buf, sizeof(buf), +ch == 'F' ? "%04ld-%%m-%%d" : +"%04ld", year_long); +if (ch == 'C') { +n -= 2; +} +if (PyUnicodeWriter_WriteSubstring(writer, format, start, end) < 0) { +goto Error; +} +start = i; +if (PyUnicodeWriter_WriteUTF8(writer, buf, n) < 0) { +goto Error; +} +continue; +} +else { +/* percent followed by something else */ +continue; +} +assert(replacement != NULL); +assert(PyUnicode_Check(replacement)); +if (PyUnicodeWriter_WriteSubstring(writer, format, start, end) < 0) { +goto Error; +} +start = i; +if (PyUnicodeWriter_WriteStr(writer, replacement) < 0) { +goto Error; +} +} /* end while() */ +PyObject *newformat; +if (start == 0) { +PyUnicodeWriter_Discard(writer); +newformat = Py_NewRef(format); +} +else { +if (PyUnicodeWriter_WriteSubstring(writer, format, start, flen) < 0) { +goto Error; +} +newformat = PyUnicodeWriter_Finish(writer); +if (newformat == NULL) { +goto Done; +} +} +result = PyObject_CallFunctionObjArgs(strftime, +newformat, timetuple, NULL); +Py_DECREF(newformat); +Done: +Py_XDECREF(freplacement); +Py_XDECREF(zreplacement); +Py_XDECREF(colonzreplacement); +Py_XDECREF(Zreplacement); +Py_XDECREF(strftime); +return result; +Error: +PyUnicodeWriter_Discard(writer); +goto Done; +} +/* --------------------------------------------------------------------------- +* Wrap functions from the time module. These aren't directly available +* from C. Perhaps they should be. +*/ +/* Call time.time() and return its result (a Python float). */ +static PyObject * +time_time(void) +{ +PyObject *result = NULL; +PyObject *time = PyImport_ImportModuleAttrString("time", "time"); +if (time != NULL) { +result = PyObject_CallNoArgs(time); +Py_DECREF(time); +} +return result; +} +/* Build a time.struct_time. The weekday and day number are automatically +* computed from the y,m,d args. +*/ +static PyObject * +build_struct_time(int y, int m, int d, int hh, int mm, int ss, int dstflag) +{ +PyObject *struct_time; +PyObject *result; +struct_time = PyImport_ImportModuleAttrString("time", "struct_time"); +if (struct_time == NULL) { +return NULL; +} +result = PyObject_CallFunction(struct_time, "((iiiiiiiii))", +y, m, d, +hh, mm, ss, +weekday(y, m, d), +days_before_month(y, m) + d, +dstflag); +Py_DECREF(struct_time); +return result; +} +/* --------------------------------------------------------------------------- +* Miscellaneous helpers. +*/ +/* The comparisons here all most naturally compute a cmp()-like result. +* This little helper turns that into a bool result for rich comparisons. +*/ +static PyObject * +diff_to_bool(int diff, int op) +{ +Py_RETURN_RICHCOMPARE(diff, 0, op); +} +/* --------------------------------------------------------------------------- +* Class implementations. +*/ +/* +* PyDateTime_Delta implementation. +*/ +/* Convert a timedelta to a number of us, +* (24*3600*self.days + self.seconds)*1000000 + self.microseconds +* as a Python int. +* Doing mixed-radix arithmetic by hand instead is excruciating in C, +* due to ubiquitous overflow possibilities. +*/ +static PyObject * +delta_to_microseconds(PyDateTime_Delta *self) +{ +PyObject *x1 = NULL; +PyObject *x2 = NULL; +PyObject *x3 = NULL; +PyObject *result = NULL; +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +x1 = PyLong_FromLong(GET_TD_DAYS(self)); +if (x1 == NULL) +goto Done; +x2 = PyNumber_Multiply(x1, CONST_SEC_PER_DAY(st)); /* days in seconds */ +if (x2 == NULL) +goto Done; +Py_SETREF(x1, NULL); +/* x2 has days in seconds */ +x1 = PyLong_FromLong(GET_TD_SECONDS(self)); /* seconds */ +if (x1 == NULL) +goto Done; +x3 = PyNumber_Add(x1, x2); /* days and seconds in seconds */ +if (x3 == NULL) +goto Done; +Py_DECREF(x1); +Py_DECREF(x2); +/* x1 = */ x2 = NULL; +/* x3 has days+seconds in seconds */ +x1 = PyNumber_Multiply(x3, CONST_US_PER_SECOND(st)); /* us */ +if (x1 == NULL) +goto Done; +Py_SETREF(x3, NULL); +/* x1 has days+seconds in us */ +x2 = PyLong_FromLong(GET_TD_MICROSECONDS(self)); +if (x2 == NULL) +goto Done; +result = PyNumber_Add(x1, x2); +assert(result == NULL || PyLong_CheckExact(result)); +Done: +Py_XDECREF(x1); +Py_XDECREF(x2); +Py_XDECREF(x3); +RELEASE_CURRENT_STATE(st, current_mod); +return result; +} +static PyObject * +checked_divmod(PyObject *a, PyObject *b) +{ +PyObject *result = PyNumber_Divmod(a, b); +if (result != NULL) { +if (!PyTuple_Check(result)) { +PyErr_Format(PyExc_TypeError, +"divmod() returned non-tuple (type %.200s)", +Py_TYPE(result)->tp_name); +Py_DECREF(result); +return NULL; +} +if (PyTuple_GET_SIZE(result) != 2) { +PyErr_Format(PyExc_TypeError, +"divmod() returned a tuple of size %zd", +PyTuple_GET_SIZE(result)); +Py_DECREF(result); +return NULL; +} +} +return result; +} +/* Convert a number of us (as a Python int) to a timedelta. +*/ +static PyObject * +microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type) +{ +int us; +int s; +int d; +PyObject *tuple = NULL; +PyObject *num = NULL; +PyObject *result = NULL; +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +tuple = checked_divmod(pyus, CONST_US_PER_SECOND(st)); +if (tuple == NULL) { +goto Done; +} +num = PyTuple_GET_ITEM(tuple, 1); /* us */ +us = PyLong_AsInt(num); +num = NULL; +if (us == -1 && PyErr_Occurred()) { +goto Done; +} +if (!(0 <= us && us < 1000000)) { +goto BadDivmod; +} +num = Py_NewRef(PyTuple_GET_ITEM(tuple, 0)); /* leftover seconds */ +Py_DECREF(tuple); +tuple = checked_divmod(num, CONST_SEC_PER_DAY(st)); +if (tuple == NULL) +goto Done; +Py_DECREF(num); +num = PyTuple_GET_ITEM(tuple, 1); /* seconds */ +s = PyLong_AsInt(num); +num = NULL; +if (s == -1 && PyErr_Occurred()) { +goto Done; +} +if (!(0 <= s && s < 24*3600)) { +goto BadDivmod; +} +num = Py_NewRef(PyTuple_GET_ITEM(tuple, 0)); /* leftover days */ +d = PyLong_AsInt(num); +if (d == -1 && PyErr_Occurred()) { +goto Done; +} +result = new_delta_ex(d, s, us, 0, type); +Done: +Py_XDECREF(tuple); +Py_XDECREF(num); +RELEASE_CURRENT_STATE(st, current_mod); +return result; +BadDivmod: +PyErr_SetString(PyExc_TypeError, +"divmod() returned a value out of range"); +goto Done; +} +#define microseconds_to_delta(pymicros) \ +microseconds_to_delta_ex(pymicros, DELTA_TYPE(NO_STATE)) +static PyObject * +multiply_int_timedelta(PyObject *intobj, PyDateTime_Delta *delta) +{ +PyObject *pyus_in; +PyObject *pyus_out; +PyObject *result; +pyus_in = delta_to_microseconds(delta); +if (pyus_in == NULL) +return NULL; +pyus_out = PyNumber_Multiply(intobj, pyus_in); +Py_DECREF(pyus_in); +if (pyus_out == NULL) +return NULL; +result = microseconds_to_delta(pyus_out); +Py_DECREF(pyus_out); +return result; +} +static PyObject * +get_float_as_integer_ratio(PyObject *floatobj) +{ +PyObject *ratio; +assert(floatobj && PyFloat_Check(floatobj)); +ratio = PyObject_CallMethodNoArgs(floatobj, &_Py_ID(as_integer_ratio)); +if (ratio == NULL) { +return NULL; +} +if (!PyTuple_Check(ratio)) { +PyErr_Format(PyExc_TypeError, +"unexpected return type from as_integer_ratio(): " +"expected tuple, not '%.200s'", +Py_TYPE(ratio)->tp_name); +Py_DECREF(ratio); +return NULL; +} +if (PyTuple_Size(ratio) != 2) { +PyErr_SetString(PyExc_ValueError, +"as_integer_ratio() must return a 2-tuple"); +Py_DECREF(ratio); +return NULL; +} +return ratio; +} +/* op is 0 for multiplication, 1 for division */ +static PyObject * +multiply_truedivide_timedelta_float(PyDateTime_Delta *delta, PyObject *floatobj, int op) +{ +PyObject *result = NULL; +PyObject *pyus_in = NULL, *temp, *pyus_out; +PyObject *ratio = NULL; +pyus_in = delta_to_microseconds(delta); +if (pyus_in == NULL) +return NULL; +ratio = get_float_as_integer_ratio(floatobj); +if (ratio == NULL) { +goto error; +} +temp = PyNumber_Multiply(pyus_in, PyTuple_GET_ITEM(ratio, op)); +Py_SETREF(pyus_in, NULL); +if (temp == NULL) +goto error; +pyus_out = divide_nearest(temp, PyTuple_GET_ITEM(ratio, !op)); +Py_DECREF(temp); +if (pyus_out == NULL) +goto error; +result = microseconds_to_delta(pyus_out); +Py_DECREF(pyus_out); +error: +Py_XDECREF(pyus_in); +Py_XDECREF(ratio); +return result; +} +static PyObject * +divide_timedelta_int(PyDateTime_Delta *delta, PyObject *intobj) +{ +PyObject *pyus_in; +PyObject *pyus_out; +PyObject *result; +pyus_in = delta_to_microseconds(delta); +if (pyus_in == NULL) +return NULL; +pyus_out = PyNumber_FloorDivide(pyus_in, intobj); +Py_DECREF(pyus_in); +if (pyus_out == NULL) +return NULL; +result = microseconds_to_delta(pyus_out); +Py_DECREF(pyus_out); +return result; +} +static PyObject * +divide_timedelta_timedelta(PyDateTime_Delta *left, PyDateTime_Delta *right) +{ +PyObject *pyus_left; +PyObject *pyus_right; +PyObject *result; +pyus_left = delta_to_microseconds(left); +if (pyus_left == NULL) +return NULL; +pyus_right = delta_to_microseconds(right); +if (pyus_right == NULL) { +Py_DECREF(pyus_left); +return NULL; +} +result = PyNumber_FloorDivide(pyus_left, pyus_right); +Py_DECREF(pyus_left); +Py_DECREF(pyus_right); +return result; +} +static PyObject * +truedivide_timedelta_timedelta(PyDateTime_Delta *left, PyDateTime_Delta *right) +{ +PyObject *pyus_left; +PyObject *pyus_right; +PyObject *result; +pyus_left = delta_to_microseconds(left); +if (pyus_left == NULL) +return NULL; +pyus_right = delta_to_microseconds(right); +if (pyus_right == NULL) { +Py_DECREF(pyus_left); +return NULL; +} +result = PyNumber_TrueDivide(pyus_left, pyus_right); +Py_DECREF(pyus_left); +Py_DECREF(pyus_right); +return result; +} +static PyObject * +truedivide_timedelta_int(PyDateTime_Delta *delta, PyObject *i) +{ +PyObject *result; +PyObject *pyus_in, *pyus_out; +pyus_in = delta_to_microseconds(delta); +if (pyus_in == NULL) +return NULL; +pyus_out = divide_nearest(pyus_in, i); +Py_DECREF(pyus_in); +if (pyus_out == NULL) +return NULL; +result = microseconds_to_delta(pyus_out); +Py_DECREF(pyus_out); +return result; +} +static PyObject * +delta_add(PyObject *left, PyObject *right) +{ +PyObject *result = Py_NotImplemented; +if (PyDelta_Check(left) && PyDelta_Check(right)) { +/* delta + delta */ +/* The C-level additions can't overflow because of the +* invariant bounds. +*/ +int days = GET_TD_DAYS(left) + GET_TD_DAYS(right); +int seconds = GET_TD_SECONDS(left) + GET_TD_SECONDS(right); +int microseconds = GET_TD_MICROSECONDS(left) + +GET_TD_MICROSECONDS(right); +result = new_delta(days, seconds, microseconds, 1); +} +if (result == Py_NotImplemented) +Py_INCREF(result); +return result; +} +static PyObject * +delta_negative(PyObject *self) +{ +return new_delta(-GET_TD_DAYS(self), +-GET_TD_SECONDS(self), +-GET_TD_MICROSECONDS(self), +1); +} +static PyObject * +delta_positive(PyObject *self) +{ +/* Could optimize this (by returning self) if this isn't a +* subclass -- but who uses unary + ? Approximately nobody. +*/ +return new_delta(GET_TD_DAYS(self), +GET_TD_SECONDS(self), +GET_TD_MICROSECONDS(self), +0); +} +static PyObject * +delta_abs(PyObject *self) +{ +PyObject *result; +assert(GET_TD_MICROSECONDS(self) >= 0); +assert(GET_TD_SECONDS(self) >= 0); +if (GET_TD_DAYS(self) < 0) +result = delta_negative(self); +else +result = delta_positive(self); +return result; +} +static PyObject * +delta_subtract(PyObject *left, PyObject *right) +{ +PyObject *result = Py_NotImplemented; +if (PyDelta_Check(left) && PyDelta_Check(right)) { +/* delta - delta */ +/* The C-level additions can't overflow because of the +* invariant bounds. +*/ +int days = GET_TD_DAYS(left) - GET_TD_DAYS(right); +int seconds = GET_TD_SECONDS(left) - GET_TD_SECONDS(right); +int microseconds = GET_TD_MICROSECONDS(left) - +GET_TD_MICROSECONDS(right); +result = new_delta(days, seconds, microseconds, 1); +} +if (result == Py_NotImplemented) +Py_INCREF(result); +return result; +} +static int +delta_cmp(PyObject *self, PyObject *other) +{ +int diff = GET_TD_DAYS(self) - GET_TD_DAYS(other); +if (diff == 0) { +diff = GET_TD_SECONDS(self) - GET_TD_SECONDS(other); +if (diff == 0) +diff = GET_TD_MICROSECONDS(self) - +GET_TD_MICROSECONDS(other); +} +return diff; +} +static PyObject * +delta_richcompare(PyObject *self, PyObject *other, int op) +{ +if (PyDelta_Check(other)) { +int diff = delta_cmp(self, other); +return diff_to_bool(diff, op); +} +else { +Py_RETURN_NOTIMPLEMENTED; +} +} +static PyObject *delta_getstate(PyDateTime_Delta *self); +static Py_hash_t +delta_hash(PyObject *op) +{ +PyDateTime_Delta *self = PyDelta_CAST(op); +Py_hash_t hash = FT_ATOMIC_LOAD_SSIZE_RELAXED(self->hashcode); +if (hash == -1) { +PyObject *temp = delta_getstate(self); +if (temp != NULL) { +hash = PyObject_Hash(temp); +FT_ATOMIC_STORE_SSIZE_RELAXED(self->hashcode, hash); +Py_DECREF(temp); +} +} +return hash; +} +static PyObject * +delta_multiply(PyObject *left, PyObject *right) +{ +PyObject *result = Py_NotImplemented; +if (PyDelta_Check(left)) { +/* delta * ??? */ +if (PyLong_Check(right)) +result = multiply_int_timedelta(right, +(PyDateTime_Delta *) left); +else if (PyFloat_Check(right)) +result = multiply_truedivide_timedelta_float( +(PyDateTime_Delta *) left, right, 0); +} +else if (PyLong_Check(left)) +result = multiply_int_timedelta(left, +(PyDateTime_Delta *) right); +else if (PyFloat_Check(left)) +result = multiply_truedivide_timedelta_float( +(PyDateTime_Delta *) right, left, 0); +if (result == Py_NotImplemented) +Py_INCREF(result); +return result; +} +static PyObject * +delta_divide(PyObject *left, PyObject *right) +{ +PyObject *result = Py_NotImplemented; +if (PyDelta_Check(left)) { +/* delta * ??? */ +if (PyLong_Check(right)) +result = divide_timedelta_int( +(PyDateTime_Delta *)left, +right); +else if (PyDelta_Check(right)) +result = divide_timedelta_timedelta( +(PyDateTime_Delta *)left, +(PyDateTime_Delta *)right); +} +if (result == Py_NotImplemented) +Py_INCREF(result); +return result; +} +static PyObject * +delta_truedivide(PyObject *left, PyObject *right) +{ +PyObject *result = Py_NotImplemented; +if (PyDelta_Check(left)) { +if (PyDelta_Check(right)) +result = truedivide_timedelta_timedelta( +(PyDateTime_Delta *)left, +(PyDateTime_Delta *)right); +else if (PyFloat_Check(right)) +result = multiply_truedivide_timedelta_float( +(PyDateTime_Delta *)left, right, 1); +else if (PyLong_Check(right)) +result = truedivide_timedelta_int( +(PyDateTime_Delta *)left, right); +} +if (result == Py_NotImplemented) +Py_INCREF(result); +return result; +} +static PyObject * +delta_remainder(PyObject *left, PyObject *right) +{ +PyObject *pyus_left; +PyObject *pyus_right; +PyObject *pyus_remainder; +PyObject *remainder; +if (!PyDelta_Check(left) || !PyDelta_Check(right)) +Py_RETURN_NOTIMPLEMENTED; +pyus_left = delta_to_microseconds((PyDateTime_Delta *)left); +if (pyus_left == NULL) +return NULL; +pyus_right = delta_to_microseconds((PyDateTime_Delta *)right); +if (pyus_right == NULL) { +Py_DECREF(pyus_left); +return NULL; +} +pyus_remainder = PyNumber_Remainder(pyus_left, pyus_right); +Py_DECREF(pyus_left); +Py_DECREF(pyus_right); +if (pyus_remainder == NULL) +return NULL; +remainder = microseconds_to_delta(pyus_remainder); +Py_DECREF(pyus_remainder); +if (remainder == NULL) +return NULL; +return remainder; +} +static PyObject * +delta_divmod(PyObject *left, PyObject *right) +{ +PyObject *pyus_left; +PyObject *pyus_right; +PyObject *divmod; +PyObject *delta; +PyObject *result; +if (!PyDelta_Check(left) || !PyDelta_Check(right)) +Py_RETURN_NOTIMPLEMENTED; +pyus_left = delta_to_microseconds((PyDateTime_Delta *)left); +if (pyus_left == NULL) +return NULL; +pyus_right = delta_to_microseconds((PyDateTime_Delta *)right); +if (pyus_right == NULL) { +Py_DECREF(pyus_left); +return NULL; +} +divmod = checked_divmod(pyus_left, pyus_right); +Py_DECREF(pyus_left); +Py_DECREF(pyus_right); +if (divmod == NULL) +return NULL; +delta = microseconds_to_delta(PyTuple_GET_ITEM(divmod, 1)); +if (delta == NULL) { +Py_DECREF(divmod); +return NULL; +} +result = PyTuple_Pack(2, PyTuple_GET_ITEM(divmod, 0), delta); +Py_DECREF(delta); +Py_DECREF(divmod); +return result; +} +/* Fold in the value of the tag ("seconds", "weeks", etc) component of a +* timedelta constructor. sofar is the # of microseconds accounted for +* so far, and there are factor microseconds per current unit, the number +* of which is given by num. num * factor is added to sofar in a +* numerically careful way, and that's the result. Any fractional +* microseconds left over (this can happen if num is a float type) are +* added into *leftover. +* Note that there are many ways this can give an error (NULL) return. +*/ +static PyObject * +accum(const char* tag, PyObject *sofar, PyObject *num, PyObject *factor, +double *leftover) +{ +PyObject *prod; +PyObject *sum; +assert(num != NULL); +if (PyLong_Check(num)) { +prod = PyNumber_Multiply(num, factor); +if (prod == NULL) +return NULL; +sum = PyNumber_Add(sofar, prod); +Py_DECREF(prod); +return sum; +} +if (PyFloat_Check(num)) { +double dnum; +double fracpart; +double intpart; +PyObject *x; +PyObject *y; +/* The Plan: decompose num into an integer part and a +* fractional part, num = intpart + fracpart. +* Then num * factor == +* intpart * factor + fracpart * factor +* and the LHS can be computed exactly in long arithmetic. +* The RHS is again broken into an int part and frac part. +* and the frac part is added into *leftover. +*/ +dnum = PyFloat_AsDouble(num); +if (dnum == -1.0 && PyErr_Occurred()) +return NULL; +fracpart = modf(dnum, &intpart); +x = PyLong_FromDouble(intpart); +if (x == NULL) +return NULL; +prod = PyNumber_Multiply(x, factor); +Py_DECREF(x); +if (prod == NULL) +return NULL; +sum = PyNumber_Add(sofar, prod); +Py_DECREF(prod); +if (sum == NULL) +return NULL; +if (fracpart == 0.0) +return sum; +/* So far we've lost no information. Dealing with the +* fractional part requires float arithmetic, and may +* lose a little info. +*/ +assert(PyLong_CheckExact(factor)); +dnum = PyLong_AsDouble(factor); +dnum *= fracpart; +fracpart = modf(dnum, &intpart); +x = PyLong_FromDouble(intpart); +if (x == NULL) { +Py_DECREF(sum); +return NULL; +} +y = PyNumber_Add(sum, x); +Py_DECREF(sum); +Py_DECREF(x); +*leftover += fracpart; +return y; +} +PyErr_Format(PyExc_TypeError, +"unsupported type for timedelta %s component: %s", +tag, Py_TYPE(num)->tp_name); +return NULL; +} +/*[clinic input] +@classmethod +datetime.timedelta.__new__ as delta_new +days: object(c_default="NULL") = 0 +seconds: object(c_default="NULL") = 0 +microseconds: object(c_default="NULL") = 0 +milliseconds: object(c_default="NULL") = 0 +minutes: object(c_default="NULL") = 0 +hours: object(c_default="NULL") = 0 +weeks: object(c_default="NULL") = 0 +Difference between two datetime values. +All arguments are optional and default to 0. +Arguments may be integers or floats, and may be positive or negative. +[clinic start generated code]*/ +static PyObject * +delta_new_impl(PyTypeObject *type, PyObject *days, PyObject *seconds, +PyObject *microseconds, PyObject *milliseconds, +PyObject *minutes, PyObject *hours, PyObject *weeks) +/*[clinic end generated code: output=61d7e02a92a97700 input=e8cd54819295d34b]*/ +{ +PyObject *self = NULL; +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +PyObject *x = NULL; /* running sum of microseconds */ +PyObject *y = NULL; /* temp sum of microseconds */ +double leftover_us = 0.0; +x = PyLong_FromLong(0); +if (x == NULL) +goto Done; +#define CLEANUP \ +Py_DECREF(x); \ +x = y; \ +if (x == NULL) \ +goto Done +if (microseconds) { +y = accum("microseconds", x, microseconds, _PyLong_GetOne(), &leftover_us); +CLEANUP; +} +if (milliseconds) { +y = accum("milliseconds", x, milliseconds, CONST_US_PER_MS(st), &leftover_us); +CLEANUP; +} +if (seconds) { +y = accum("seconds", x, seconds, CONST_US_PER_SECOND(st), &leftover_us); +CLEANUP; +} +if (minutes) { +y = accum("minutes", x, minutes, CONST_US_PER_MINUTE(st), &leftover_us); +CLEANUP; +} +if (hours) { +y = accum("hours", x, hours, CONST_US_PER_HOUR(st), &leftover_us); +CLEANUP; +} +if (days) { +y = accum("days", x, days, CONST_US_PER_DAY(st), &leftover_us); +CLEANUP; +} +if (weeks) { +y = accum("weeks", x, weeks, CONST_US_PER_WEEK(st), &leftover_us); +CLEANUP; +} +if (leftover_us) { +/* Round to nearest whole # of us, and add into x. */ +double whole_us = round(leftover_us); +int x_is_odd; +PyObject *temp; +if (fabs(whole_us - leftover_us) == 0.5) { +/* We're exactly halfway between two integers. In order +* to do round-half-to-even, we must determine whether x +* is odd. Note that x is odd when it's last bit is 1. The +* code below uses bitwise and operation to check the last +* bit. */ +temp = PyNumber_And(x, _PyLong_GetOne()); /* temp <- x & 1 */ +if (temp == NULL) { +Py_DECREF(x); +goto Done; +} +x_is_odd = PyObject_IsTrue(temp); +Py_DECREF(temp); +if (x_is_odd == -1) { +Py_DECREF(x); +goto Done; +} +whole_us = 2.0 * round((leftover_us + x_is_odd) * 0.5) - x_is_odd; +} +temp = PyLong_FromLong((long)whole_us); +if (temp == NULL) { +Py_DECREF(x); +goto Done; +} +y = PyNumber_Add(x, temp); +Py_DECREF(temp); +CLEANUP; +} +self = microseconds_to_delta_ex(x, type); +Py_DECREF(x); +Done: +RELEASE_CURRENT_STATE(st, current_mod); +return self; +#undef CLEANUP +} +static int +delta_bool(PyObject *self) +{ +return (GET_TD_DAYS(self) != 0 +|| GET_TD_SECONDS(self) != 0 +|| GET_TD_MICROSECONDS(self) != 0); +} +static PyObject * +delta_repr(PyObject *self) +{ +PyObject *args = Py_GetConstant(Py_CONSTANT_EMPTY_STR); +if (args == NULL) { +return NULL; +} +const char *sep = ""; +if (GET_TD_DAYS(self) != 0) { +Py_SETREF(args, PyUnicode_FromFormat("days=%d", GET_TD_DAYS(self))); +if (args == NULL) { +return NULL; +} +sep = ", "; +} +if (GET_TD_SECONDS(self) != 0) { +Py_SETREF(args, PyUnicode_FromFormat("%U%sseconds=%d", args, sep, +GET_TD_SECONDS(self))); +if (args == NULL) { +return NULL; +} +sep = ", "; +} +if (GET_TD_MICROSECONDS(self) != 0) { +Py_SETREF(args, PyUnicode_FromFormat("%U%smicroseconds=%d", args, sep, +GET_TD_MICROSECONDS(self))); +if (args == NULL) { +return NULL; +} +} +if (PyUnicode_GET_LENGTH(args) == 0) { +Py_SETREF(args, PyUnicode_FromString("0")); +if (args == NULL) { +return NULL; +} +} +PyObject *repr = PyUnicode_FromFormat("%s(%S)", Py_TYPE(self)->tp_name, +args); +Py_DECREF(args); +return repr; +} +static PyObject * +delta_str(PyObject *self) +{ +int us = GET_TD_MICROSECONDS(self); +int seconds = GET_TD_SECONDS(self); +int minutes = divmod(seconds, 60, &seconds); +int hours = divmod(minutes, 60, &minutes); +int days = GET_TD_DAYS(self); +if (days) { +if (us) +return PyUnicode_FromFormat("%d day%s, %d:%02d:%02d.%06d", +days, (days == 1 || days == -1) ? "" : "s", +hours, minutes, seconds, us); +else +return PyUnicode_FromFormat("%d day%s, %d:%02d:%02d", +days, (days == 1 || days == -1) ? "" : "s", +hours, minutes, seconds); +} else { +if (us) +return PyUnicode_FromFormat("%d:%02d:%02d.%06d", +hours, minutes, seconds, us); +else +return PyUnicode_FromFormat("%d:%02d:%02d", +hours, minutes, seconds); +} +} +/* Pickle support, a simple use of __reduce__. */ +/* __getstate__ isn't exposed */ +static PyObject * +delta_getstate(PyDateTime_Delta *self) +{ +return Py_BuildValue("iii", GET_TD_DAYS(self), +GET_TD_SECONDS(self), +GET_TD_MICROSECONDS(self)); +} +static PyObject * +delta_total_seconds(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyObject *total_seconds; +PyObject *total_microseconds; +total_microseconds = delta_to_microseconds(PyDelta_CAST(op)); +if (total_microseconds == NULL) +return NULL; +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +total_seconds = PyNumber_TrueDivide(total_microseconds, CONST_US_PER_SECOND(st)); +RELEASE_CURRENT_STATE(st, current_mod); +Py_DECREF(total_microseconds); +return total_seconds; +} +static PyObject * +delta_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_Delta *self = PyDelta_CAST(op); +return Py_BuildValue("ON", Py_TYPE(self), delta_getstate(self)); +} +#define OFFSET(field) offsetof(PyDateTime_Delta, field) +static PyMemberDef delta_members[] = { +{"days", Py_T_INT, OFFSET(days), Py_READONLY, +PyDoc_STR("Number of days.")}, +{"seconds", Py_T_INT, OFFSET(seconds), Py_READONLY, +PyDoc_STR("Number of seconds (>= 0 and less than 1 day).")}, +{"microseconds", Py_T_INT, OFFSET(microseconds), Py_READONLY, +PyDoc_STR("Number of microseconds (>= 0 and less than 1 second).")}, +{NULL} +}; +static PyMethodDef delta_methods[] = { +{"total_seconds", delta_total_seconds, METH_NOARGS, +PyDoc_STR("Total seconds in the duration.")}, +{"__reduce__", delta_reduce, METH_NOARGS, +PyDoc_STR("__reduce__() -> (cls, state)")}, +{NULL, NULL}, +}; +static PyNumberMethods delta_as_number = { +delta_add, /* nb_add */ +delta_subtract, /* nb_subtract */ +delta_multiply, /* nb_multiply */ +delta_remainder, /* nb_remainder */ +delta_divmod, /* nb_divmod */ +0, /* nb_power */ +delta_negative, /* nb_negative */ +delta_positive, /* nb_positive */ +delta_abs, /* nb_absolute */ +delta_bool, /* nb_bool */ +0, /*nb_invert*/ +0, /*nb_lshift*/ +0, /*nb_rshift*/ +0, /*nb_and*/ +0, /*nb_xor*/ +0, /*nb_or*/ +0, /*nb_int*/ +0, /*nb_reserved*/ +0, /*nb_float*/ +0, /*nb_inplace_add*/ +0, /*nb_inplace_subtract*/ +0, /*nb_inplace_multiply*/ +0, /*nb_inplace_remainder*/ +0, /*nb_inplace_power*/ +0, /*nb_inplace_lshift*/ +0, /*nb_inplace_rshift*/ +0, /*nb_inplace_and*/ +0, /*nb_inplace_xor*/ +0, /*nb_inplace_or*/ +delta_divide, /* nb_floor_divide */ +delta_truedivide, /* nb_true_divide */ +0, /* nb_inplace_floor_divide */ +0, /* nb_inplace_true_divide */ +}; +static PyTypeObject PyDateTime_DeltaType = { +PyVarObject_HEAD_INIT(NULL, 0) +"datetime.timedelta", /* tp_name */ +sizeof(PyDateTime_Delta), /* tp_basicsize */ +0, /* tp_itemsize */ +0, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +delta_repr, /* tp_repr */ +&delta_as_number, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +delta_hash, /* tp_hash */ +0, /* tp_call */ +delta_str, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ +delta_new__doc__, /* tp_doc */ +0, /* tp_traverse */ +0, /* tp_clear */ +delta_richcompare, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +delta_methods, /* tp_methods */ +delta_members, /* tp_members */ +0, /* tp_getset */ +0, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +0, /* tp_alloc */ +delta_new, /* tp_new */ +0, /* tp_free */ +}; +// XXX Can we make this const? +static PyDateTime_Delta zero_delta = { +PyObject_HEAD_INIT(&PyDateTime_DeltaType) +/* Letting this be set lazily is a benign race. */ +.hashcode = -1, +}; +static PyDateTime_Delta * +look_up_delta(int days, int seconds, int microseconds, PyTypeObject *type) +{ +if (days == 0 && seconds == 0 && microseconds == 0 +&& type == Py_TYPE(&zero_delta)) +{ +return &zero_delta; +} +return NULL; +} +/* +* PyDateTime_Date implementation. +*/ +/* Accessor properties. */ +static PyObject * +date_year(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Date *self = PyDate_CAST(op); +return PyLong_FromLong(GET_YEAR(self)); +} +static PyObject * +date_month(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Date *self = PyDate_CAST(op); +return PyLong_FromLong(GET_MONTH(self)); +} +static PyObject * +date_day(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Date *self = PyDate_CAST(op); +return PyLong_FromLong(GET_DAY(self)); +} +static PyGetSetDef date_getset[] = { +{"year", date_year}, +{"month", date_month}, +{"day", date_day}, +{NULL} +}; +/* Constructors. */ +static PyObject * +date_from_pickle(PyTypeObject *type, PyObject *state) +{ +PyDateTime_Date *me; +me = (PyDateTime_Date *) (type->tp_alloc(type, 0)); +if (me != NULL) { +const char *pdata = PyBytes_AS_STRING(state); +memcpy(me->data, pdata, _PyDateTime_DATE_DATASIZE); +me->hashcode = -1; +} +return (PyObject *)me; +} +static PyObject * +date_new(PyTypeObject *type, PyObject *args, PyObject *kw) +{ +/* Check for invocation from pickle with __getstate__ state */ +if (PyTuple_GET_SIZE(args) == 1) { +PyObject *state = PyTuple_GET_ITEM(args, 0); +if (PyBytes_Check(state)) { +if (PyBytes_GET_SIZE(state) == _PyDateTime_DATE_DATASIZE && +MONTH_IS_SANE(PyBytes_AS_STRING(state)[2])) +{ +return date_from_pickle(type, state); +} +} +else if (PyUnicode_Check(state)) { +if (PyUnicode_GET_LENGTH(state) == _PyDateTime_DATE_DATASIZE && +MONTH_IS_SANE(PyUnicode_READ_CHAR(state, 2))) +{ +state = PyUnicode_AsLatin1String(state); +if (state == NULL) { +if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { +/* More informative error message. */ +PyErr_SetString(PyExc_ValueError, +"Failed to encode latin1 string when unpickling " +"a date object. " +"pickle.load(data, encoding='latin1') is assumed."); +} +return NULL; +} +PyObject *self = date_from_pickle(type, state); +Py_DECREF(state); +return self; +} +} +} +return datetime_date(type, args, kw); +} +/*[clinic input] +@classmethod +datetime.date.__new__ +year: int +month: int +day: int +Concrete date type. +[clinic start generated code]*/ +static PyObject * +datetime_date_impl(PyTypeObject *type, int year, int month, int day) +/*[clinic end generated code: output=6654caa3dea7d518 input=fd1bac0658690455]*/ +{ +return new_date_ex(year, month, day, type); +} +static PyObject * +date_fromtimestamp(PyTypeObject *cls, PyObject *obj) +{ +struct tm tm; +time_t t; +if (_PyTime_ObjectToTime_t(obj, &t, _PyTime_ROUND_FLOOR) == -1) +return NULL; +if (_PyTime_localtime(t, &tm) != 0) +return NULL; +return new_date_subclass_ex(tm.tm_year + 1900, +tm.tm_mon + 1, +tm.tm_mday, +cls); +} +/* Return new date from current time. +* We say this is equivalent to fromtimestamp(time.time()), and the +* only way to be sure of that is to *call* time.time(). That's not +* generally the same as calling C's time. +*/ +/*[clinic input] +@classmethod +datetime.date.today +Current date or datetime. +Equivalent to fromtimestamp(time.time()). +[clinic start generated code]*/ +static PyObject * +datetime_date_today_impl(PyTypeObject *type) +/*[clinic end generated code: output=d5474697df6b251c input=21688afa289c0a06]*/ +{ +/* Use C implementation to boost performance for date type */ +if (type == &PyDateTime_DateType) { +struct tm tm; +time_t t; +time(&t); +if (_PyTime_localtime(t, &tm) != 0) { +return NULL; +} +return new_date_ex(tm.tm_year + 1900, +tm.tm_mon + 1, +tm.tm_mday, +type); +} +PyObject *time = time_time(); +if (time == NULL) { +return NULL; +} +/* Note well: since today() is a class method, it may not call +* date.fromtimestamp, e.g., it may call datetime.fromtimestamp. +*/ +PyObject *result = PyObject_CallMethodOneArg((PyObject*)type, &_Py_ID(fromtimestamp), time); +Py_DECREF(time); +return result; +} +/*[clinic input] +@permit_long_docstring_body +@classmethod +datetime.date.fromtimestamp +timestamp: object +/ +Create a date from a POSIX timestamp. +The timestamp is a number, e.g. created via time.time(), that is interpreted +as local time. +[clinic start generated code]*/ +static PyObject * +datetime_date_fromtimestamp_impl(PyTypeObject *type, PyObject *timestamp) +/*[clinic end generated code: output=59def4e32c028fb6 input=55ff6940f0a8339f]*/ +{ +return date_fromtimestamp(type, timestamp); +} +/* bpo-36025: This is a wrapper for API compatibility with the public C API, +* which expects a function that takes an *args tuple, whereas the argument +* clinic generates code that takes METH_O. +*/ +static PyObject * +datetime_date_fromtimestamp_capi(PyObject *cls, PyObject *args) +{ +PyObject *timestamp; +PyObject *result = NULL; +if (PyArg_UnpackTuple(args, "fromtimestamp", 1, 1, ×tamp)) { +result = date_fromtimestamp((PyTypeObject *)cls, timestamp); +} +return result; +} +/*[clinic input] +@classmethod +datetime.date.fromordinal +ordinal: int +/ +Construct a date from a proleptic Gregorian ordinal. +January 1 of year 1 is day 1. Only the year, month and day are +non-zero in the result. +[clinic start generated code]*/ +static PyObject * +datetime_date_fromordinal_impl(PyTypeObject *type, int ordinal) +/*[clinic end generated code: output=ea5cc69d86614a6b input=a3a4eedf582f145e]*/ +{ +int year; +int month; +int day; +if (ordinal < 1) { +PyErr_SetString(PyExc_ValueError, "ordinal must be >= 1"); +return NULL; +} +ord_to_ymd(ordinal, &year, &month, &day); +return new_date_subclass_ex(year, month, day, type); +} +/*[clinic input] +@classmethod +datetime.date.fromisoformat +string: unicode +/ +Construct a date from a string in ISO 8601 format. +[clinic start generated code]*/ +static PyObject * +datetime_date_fromisoformat_impl(PyTypeObject *type, PyObject *string) +/*[clinic end generated code: output=8b9f9324904fca02 input=73c64216c10bcc8e]*/ +{ +Py_ssize_t len; +const char *dt_ptr = PyUnicode_AsUTF8AndSize(string, &len); +if (dt_ptr == NULL) { +goto invalid_string_error; +} +int year = 0, month = 0, day = 0; +int rv; +if (len == 7 || len == 8 || len == 10) { +rv = parse_isoformat_date(dt_ptr, len, &year, &month, &day); +} +else { +rv = -1; +} +if (rv < 0) { +goto invalid_string_error; +} +return new_date_subclass_ex(year, month, day, type); +invalid_string_error: +PyErr_Format(PyExc_ValueError, "Invalid isoformat string: %R", string); +return NULL; +} +/*[clinic input] +@classmethod +datetime.date.fromisocalendar +year: int +week: int +day: int +Construct a date from the ISO year, week number and weekday. +This is the inverse of the date.isocalendar() function. +[clinic start generated code]*/ +static PyObject * +datetime_date_fromisocalendar_impl(PyTypeObject *type, int year, int week, +int day) +/*[clinic end generated code: output=7b26e15115d24df6 input=fbb05b53d6fb51d8]*/ +{ +int month; +int rv = iso_to_ymd(year, week, day, &year, &month, &day); +if (rv == -4) { +PyErr_Format(PyExc_ValueError, +"year must be in %d..%d, not %d", MINYEAR, MAXYEAR, year); +return NULL; +} +if (rv == -2) { +PyErr_Format(PyExc_ValueError, "Invalid week: %d", week); +return NULL; +} +if (rv == -3) { +PyErr_Format(PyExc_ValueError, "Invalid weekday: %d (range is [1, 7])", +day); +return NULL; +} +return new_date_subclass_ex(year, month, day, type); +} +/*[clinic input] +@classmethod +datetime.date.strptime +string: unicode +format: unicode +/ +Parse string according to the given date format (like time.strptime()). +For a list of supported format codes, see the documentation: +https://docs.python.org/3/library/datetime.html#format-codes +[clinic start generated code]*/ +static PyObject * +datetime_date_strptime_impl(PyTypeObject *type, PyObject *string, +PyObject *format) +/*[clinic end generated code: output=454d473bee2d5161 input=31d57bb789433e99]*/ +{ +PyObject *result; +PyObject *module = PyImport_Import(&_Py_ID(_strptime)); +if (module == NULL) { +return NULL; +} +result = PyObject_CallMethodObjArgs(module, +&_Py_ID(_strptime_datetime_date), +(PyObject *)type, string, format, NULL); +Py_DECREF(module); +return result; +} +/* +* Date arithmetic. +*/ +/* date + timedelta -> date. If arg negate is true, subtract the timedelta +* instead. +*/ +static PyObject * +add_date_timedelta(PyDateTime_Date *date, PyDateTime_Delta *delta, int negate) +{ +PyObject *result = NULL; +int year = GET_YEAR(date); +int month = GET_MONTH(date); +int deltadays = GET_TD_DAYS(delta); +/* C-level overflow is impossible because |deltadays| < 1e9. */ +int day = GET_DAY(date) + (negate ? -deltadays : deltadays); +if (normalize_date(&year, &month, &day) >= 0) +result = new_date_subclass_ex(year, month, day, Py_TYPE(date)); +return result; +} +static PyObject * +date_add(PyObject *left, PyObject *right) +{ +if (PyDateTime_Check(left) || PyDateTime_Check(right)) +Py_RETURN_NOTIMPLEMENTED; +if (PyDate_Check(left)) { +/* date + ??? */ +if (PyDelta_Check(right)) +/* date + delta */ +return add_date_timedelta((PyDateTime_Date *) left, +(PyDateTime_Delta *) right, +0); +} +else { +/* ??? + date +* 'right' must be one of us, or we wouldn't have been called +*/ +if (PyDelta_Check(left)) +/* delta + date */ +return add_date_timedelta((PyDateTime_Date *) right, +(PyDateTime_Delta *) left, +0); +} +Py_RETURN_NOTIMPLEMENTED; +} +static PyObject * +date_subtract(PyObject *left, PyObject *right) +{ +if (PyDateTime_Check(left) || PyDateTime_Check(right)) +Py_RETURN_NOTIMPLEMENTED; +if (PyDate_Check(left)) { +if (PyDate_Check(right)) { +/* date - date */ +int left_ord = ymd_to_ord(GET_YEAR(left), +GET_MONTH(left), +GET_DAY(left)); +int right_ord = ymd_to_ord(GET_YEAR(right), +GET_MONTH(right), +GET_DAY(right)); +return new_delta(left_ord - right_ord, 0, 0, 0); +} +if (PyDelta_Check(right)) { +/* date - delta */ +return add_date_timedelta((PyDateTime_Date *) left, +(PyDateTime_Delta *) right, +1); +} +} +Py_RETURN_NOTIMPLEMENTED; +} +/* Various ways to turn a date into a string. */ +static PyObject * +date_repr(PyObject *op) +{ +PyDateTime_Date *self = PyDate_CAST(op); +return PyUnicode_FromFormat("%s(%d, %d, %d)", +Py_TYPE(self)->tp_name, +GET_YEAR(self), GET_MONTH(self), GET_DAY(self)); +} +static PyObject * +date_isoformat(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_Date *self = PyDate_CAST(op); +return PyUnicode_FromFormat("%04d-%02d-%02d", +GET_YEAR(self), GET_MONTH(self), GET_DAY(self)); +} +/* str() calls the appropriate isoformat() method. */ +static PyObject * +date_str(PyObject *self) +{ +return PyObject_CallMethodNoArgs(self, &_Py_ID(isoformat)); +} +static PyObject * +date_ctime(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +return format_ctime(self, 0, 0, 0); +} +/*[clinic input] +datetime.date.strftime +self: self(type="PyObject *") +format: unicode +Format using strftime(). +Example: "%d/%m/%Y, %H:%M:%S". +For a list of supported format codes, see the documentation: +https://docs.python.org/3/library/datetime.html#format-codes +[clinic start generated code]*/ +static PyObject * +datetime_date_strftime_impl(PyObject *self, PyObject *format) +/*[clinic end generated code: output=6529b70095e16778 input=b6fd4a2ded27b557]*/ +{ +/* This method can be inherited, and needs to call the +* timetuple() method appropriate to self's class. +*/ +PyObject *result; +PyObject *tuple; +tuple = PyObject_CallMethodNoArgs(self, &_Py_ID(timetuple)); +if (tuple == NULL) +return NULL; +result = wrap_strftime(self, format, tuple, self); +Py_DECREF(tuple); +return result; +} +/*[clinic input] +datetime.date.__format__ +self: self(type="PyObject *") +format: unicode +/ +Formats self with strftime. +[clinic start generated code]*/ +static PyObject * +datetime_date___format___impl(PyObject *self, PyObject *format) +/*[clinic end generated code: output=efa0223d000a93b7 input=e417a7c84e1abaf9]*/ +{ +/* if the format is zero length, return str(self) */ +if (PyUnicode_GetLength(format) == 0) +return PyObject_Str(self); +return PyObject_CallMethodOneArg(self, &_Py_ID(strftime), format); +} +/* ISO methods. */ +static PyObject * +date_isoweekday(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self)); +return PyLong_FromLong(dow + 1); +} +PyDoc_STRVAR(iso_calendar_date__doc__, +"The result of date.isocalendar() or datetime.isocalendar()\n\n\ +This object may be accessed either as a tuple of\n\ +((year, week, weekday)\n\ +or via the object attributes as named in the above tuple."); +typedef struct { +PyTupleObject tuple; +} PyDateTime_IsoCalendarDate; +static PyObject * +iso_calendar_date_repr(PyObject *self) +{ +PyObject *year = PyTuple_GetItem(self, 0); +if (year == NULL) { +return NULL; +} +PyObject *week = PyTuple_GetItem(self, 1); +if (week == NULL) { +return NULL; +} +PyObject *weekday = PyTuple_GetItem(self, 2); +if (weekday == NULL) { +return NULL; +} +return PyUnicode_FromFormat("%.200s(year=%S, week=%S, weekday=%S)", +Py_TYPE(self)->tp_name, year, week, weekday); +} +static PyObject * +iso_calendar_date_reduce(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ +// Construct the tuple that this reduces to +PyObject *reduce_tuple = Py_BuildValue( +"O((OOO))", &PyTuple_Type, +PyTuple_GET_ITEM(self, 0), +PyTuple_GET_ITEM(self, 1), +PyTuple_GET_ITEM(self, 2) +); +return reduce_tuple; +} +static PyObject * +iso_calendar_date_year(PyObject *self, void *Py_UNUSED(closure)) +{ +PyObject *year = PyTuple_GetItem(self, 0); +if (year == NULL) { +return NULL; +} +return Py_NewRef(year); +} +static PyObject * +iso_calendar_date_week(PyObject *self, void *Py_UNUSED(closure)) +{ +PyObject *week = PyTuple_GetItem(self, 1); +if (week == NULL) { +return NULL; +} +return Py_NewRef(week); +} +static PyObject * +iso_calendar_date_weekday(PyObject *self, void *Py_UNUSED(closure)) +{ +PyObject *weekday = PyTuple_GetItem(self, 2); +if (weekday == NULL) { +return NULL; +} +return Py_NewRef(weekday); +} +static PyGetSetDef iso_calendar_date_getset[] = { +{"year", iso_calendar_date_year}, +{"week", iso_calendar_date_week}, +{"weekday", iso_calendar_date_weekday}, +{NULL} +}; +static PyMethodDef iso_calendar_date_methods[] = { +{"__reduce__", iso_calendar_date_reduce, METH_NOARGS, +PyDoc_STR("__reduce__() -> (cls, state)")}, +{NULL, NULL}, +}; +static int +iso_calendar_date_traverse(PyObject *self, visitproc visit, void *arg) +{ +Py_VISIT(Py_TYPE(self)); +return PyTuple_Type.tp_traverse(self, visit, arg); +} +static void +iso_calendar_date_dealloc(PyObject *self) +{ +PyTypeObject *tp = Py_TYPE(self); +PyTuple_Type.tp_dealloc(self); // delegate GC-untrack as well +Py_DECREF(tp); +} +static PyType_Slot isocal_slots[] = { +{Py_tp_repr, iso_calendar_date_repr}, +{Py_tp_doc, (void *)iso_calendar_date__doc__}, +{Py_tp_methods, iso_calendar_date_methods}, +{Py_tp_getset, iso_calendar_date_getset}, +{Py_tp_new, iso_calendar_date_new}, +{Py_tp_dealloc, iso_calendar_date_dealloc}, +{Py_tp_traverse, iso_calendar_date_traverse}, +{0, NULL}, +}; +static PyType_Spec isocal_spec = { +.name = "datetime.IsoCalendarDate", +.basicsize = sizeof(PyDateTime_IsoCalendarDate), +.flags = (Py_TPFLAGS_DEFAULT | +Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = isocal_slots, +}; +/*[clinic input] +@classmethod +datetime.IsoCalendarDate.__new__ as iso_calendar_date_new +year: int +week: int +weekday: int +[clinic start generated code]*/ +static PyObject * +iso_calendar_date_new_impl(PyTypeObject *type, int year, int week, +int weekday) +/*[clinic end generated code: output=383d33d8dc7183a2 input=4f2c663c9d19c4ee]*/ +{ +PyDateTime_IsoCalendarDate *self; +self = (PyDateTime_IsoCalendarDate *) type->tp_alloc(type, 3); +if (self == NULL) { +return NULL; +} +PyTuple_SET_ITEM(self, 0, PyLong_FromLong(year)); +PyTuple_SET_ITEM(self, 1, PyLong_FromLong(week)); +PyTuple_SET_ITEM(self, 2, PyLong_FromLong(weekday)); +return (PyObject *)self; +} +static PyObject * +date_isocalendar(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +int year = GET_YEAR(self); +int week1_monday = iso_week1_monday(year); +int today = ymd_to_ord(year, GET_MONTH(self), GET_DAY(self)); +int week; +int day; +week = divmod(today - week1_monday, 7, &day); +if (week < 0) { +--year; +week1_monday = iso_week1_monday(year); +week = divmod(today - week1_monday, 7, &day); +} +else if (week >= 52 && today >= iso_week1_monday(year + 1)) { +++year; +week = 0; +} +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +PyObject *v = iso_calendar_date_new_impl(ISOCALENDAR_DATE_TYPE(st), +year, week + 1, day + 1); +RELEASE_CURRENT_STATE(st, current_mod); +if (v == NULL) { +return NULL; +} +return v; +} +/* Miscellaneous methods. */ +static PyObject * +date_richcompare(PyObject *self, PyObject *other, int op) +{ +/* Since DateTime is a subclass of Date, if the other object is +* a DateTime, it would compute an equality testing or an ordering +* based on the date part alone, and we don't want that. +* So return NotImplemented here in that case. +* If a subclass wants to change this, it's up to the subclass to do so. +* The behavior is the same as if Date and DateTime were independent +* classes. +*/ +if (PyDate_Check(other) && !PyDateTime_Check(other)) { +int diff = memcmp(((PyDateTime_Date *)self)->data, +((PyDateTime_Date *)other)->data, +_PyDateTime_DATE_DATASIZE); +return diff_to_bool(diff, op); +} +else +Py_RETURN_NOTIMPLEMENTED; +} +static PyObject * +date_timetuple(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +return build_struct_time(GET_YEAR(self), +GET_MONTH(self), +GET_DAY(self), +0, 0, 0, -1); +} +/*[clinic input] +datetime.date.replace +year: int(c_default="GET_YEAR(self)") = unchanged +month: int(c_default="GET_MONTH(self)") = unchanged +day: int(c_default="GET_DAY(self)") = unchanged +Return date with new specified fields. +[clinic start generated code]*/ +static PyObject * +datetime_date_replace_impl(PyDateTime_Date *self, int year, int month, +int day) +/*[clinic end generated code: output=2a9430d1e6318aeb input=0d1f02685b3e90f6]*/ +{ +return new_date_subclass_ex(year, month, day, Py_TYPE(self)); +} +static Py_hash_t +generic_hash(unsigned char *data, int len) +{ +return Py_HashBuffer(data, len); +} +static PyObject *date_getstate(PyDateTime_Date *self); +static Py_hash_t +date_hash(PyObject *op) +{ +PyDateTime_Date *self = PyDate_CAST(op); +Py_hash_t hash = FT_ATOMIC_LOAD_SSIZE_RELAXED(self->hashcode); +if (hash == -1) { +hash = generic_hash( +(unsigned char *)self->data, _PyDateTime_DATE_DATASIZE); +FT_ATOMIC_STORE_SSIZE_RELAXED(self->hashcode, hash); +} +return hash; +} +static PyObject * +date_toordinal(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +return PyLong_FromLong(ymd_to_ord(GET_YEAR(self), GET_MONTH(self), +GET_DAY(self))); +} +static PyObject * +date_weekday(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self)); +return PyLong_FromLong(dow); +} +/* Pickle support, a simple use of __reduce__. */ +/* __getstate__ isn't exposed */ +static PyObject * +date_getstate(PyDateTime_Date *self) +{ +PyObject* field; +field = PyBytes_FromStringAndSize((char*)self->data, +_PyDateTime_DATE_DATASIZE); +return Py_BuildValue("(N)", field); +} +static PyObject * +date_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_Date *self = PyDate_CAST(op); +return Py_BuildValue("(ON)", Py_TYPE(self), date_getstate(self)); +} +static PyMethodDef date_methods[] = { +/* Class methods: */ +DATETIME_DATE_FROMTIMESTAMP_METHODDEF +DATETIME_DATE_FROMORDINAL_METHODDEF +DATETIME_DATE_FROMISOFORMAT_METHODDEF +DATETIME_DATE_FROMISOCALENDAR_METHODDEF +DATETIME_DATE_STRPTIME_METHODDEF +DATETIME_DATE_TODAY_METHODDEF +/* Instance methods: */ +{"ctime", date_ctime, METH_NOARGS, +PyDoc_STR("Return ctime() style string.")}, +DATETIME_DATE_STRFTIME_METHODDEF +DATETIME_DATE___FORMAT___METHODDEF +{"timetuple", date_timetuple, METH_NOARGS, +PyDoc_STR("Return time tuple, compatible with time.localtime().")}, +{"isocalendar", date_isocalendar, METH_NOARGS, +PyDoc_STR("Return a named tuple containing ISO year, week number, and " +"weekday.")}, +{"isoformat", date_isoformat, METH_NOARGS, +PyDoc_STR("Return string in ISO 8601 format, YYYY-MM-DD.")}, +{"isoweekday", date_isoweekday, METH_NOARGS, +PyDoc_STR("Return the day of the week represented by the date.\n" +"Monday == 1 ... Sunday == 7")}, +{"toordinal", date_toordinal, METH_NOARGS, +PyDoc_STR("Return proleptic Gregorian ordinal. January 1 of year " +"1 is day 1.")}, +{"weekday", date_weekday, METH_NOARGS, +PyDoc_STR("Return the day of the week represented by the date.\n" +"Monday == 0 ... Sunday == 6")}, +DATETIME_DATE_REPLACE_METHODDEF +{"__replace__", _PyCFunction_CAST(datetime_date_replace), METH_FASTCALL | METH_KEYWORDS, +PyDoc_STR("__replace__($self, /, **changes)\n--\n\nThe same as replace().")}, +{"__reduce__", date_reduce, METH_NOARGS, +PyDoc_STR("__reduce__() -> (cls, state)")}, +{NULL, NULL} +}; +static PyNumberMethods date_as_number = { +date_add, /* nb_add */ +date_subtract, /* nb_subtract */ +0, /* nb_multiply */ +0, /* nb_remainder */ +0, /* nb_divmod */ +0, /* nb_power */ +0, /* nb_negative */ +0, /* nb_positive */ +0, /* nb_absolute */ +0, /* nb_bool */ +}; +static PyTypeObject PyDateTime_DateType = { +PyVarObject_HEAD_INIT(NULL, 0) +"datetime.date", /* tp_name */ +sizeof(PyDateTime_Date), /* tp_basicsize */ +0, /* tp_itemsize */ +0, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +date_repr, /* tp_repr */ +&date_as_number, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +date_hash, /* tp_hash */ +0, /* tp_call */ +date_str, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ +datetime_date__doc__, /* tp_doc */ +0, /* tp_traverse */ +0, /* tp_clear */ +date_richcompare, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +date_methods, /* tp_methods */ +0, /* tp_members */ +date_getset, /* tp_getset */ +0, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +0, /* tp_alloc */ +date_new, /* tp_new */ +0, /* tp_free */ +}; +/* +* PyDateTime_TZInfo implementation. +*/ +/* This is a pure abstract base class, so doesn't do anything beyond +* raising NotImplemented exceptions. Real tzinfo classes need +* to derive from this. This is mostly for clarity, and for efficiency in +* datetime and time constructors (their tzinfo arguments need to +* be subclasses of this tzinfo class, which is easy and quick to check). +* +* Note: For reasons having to do with pickling of subclasses, we have +* to allow tzinfo objects to be instantiated. This wasn't an issue +* in the Python implementation (__init__() could raise NotImplementedError +* there without ill effect), but doing so in the C implementation hit a +* brick wall. +*/ +static PyObject * +tzinfo_nogo(const char* methodname) +{ +PyErr_Format(PyExc_NotImplementedError, +"a tzinfo subclass must implement %s()", +methodname); +return NULL; +} +/* Methods. A subclass must implement these. */ +static PyObject * +tzinfo_tzname(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(dt)) +{ +return tzinfo_nogo("tzname"); +} +static PyObject * +tzinfo_utcoffset(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(dt)) +{ +return tzinfo_nogo("utcoffset"); +} +static PyObject * +tzinfo_dst(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(dt)) +{ +return tzinfo_nogo("dst"); +} +static PyObject *add_datetime_timedelta(PyDateTime_DateTime *date, +PyDateTime_Delta *delta, +int factor); +static PyObject *datetime_utcoffset(PyObject *self, PyObject *); +static PyObject *datetime_dst(PyObject *self, PyObject *); +static PyObject * +tzinfo_fromutc(PyObject *self, PyObject *dt) +{ +PyObject *result = NULL; +PyObject *off = NULL, *dst = NULL; +PyDateTime_Delta *delta = NULL; +if (!PyDateTime_Check(dt)) { +PyErr_SetString(PyExc_TypeError, +"fromutc: argument must be a datetime"); +return NULL; +} +if (GET_DT_TZINFO(dt) != self) { +PyErr_SetString(PyExc_ValueError, "fromutc: dt.tzinfo " +"is not self"); +return NULL; +} +off = datetime_utcoffset(dt, NULL); +if (off == NULL) +return NULL; +if (off == Py_None) { +PyErr_SetString(PyExc_ValueError, "fromutc: non-None " +"utcoffset() result required"); +goto Fail; +} +dst = datetime_dst(dt, NULL); +if (dst == NULL) +goto Fail; +if (dst == Py_None) { +PyErr_SetString(PyExc_ValueError, "fromutc: non-None " +"dst() result required"); +goto Fail; +} +delta = (PyDateTime_Delta *)delta_subtract(off, dst); +if (delta == NULL) +goto Fail; +result = add_datetime_timedelta((PyDateTime_DateTime *)dt, delta, 1); +if (result == NULL) +goto Fail; +Py_DECREF(dst); +dst = call_dst(GET_DT_TZINFO(dt), result); +if (dst == NULL) +goto Fail; +if (dst == Py_None) +goto Inconsistent; +if (delta_bool(dst) != 0) { +Py_SETREF(result, add_datetime_timedelta((PyDateTime_DateTime *)result, +(PyDateTime_Delta *)dst, 1)); +if (result == NULL) +goto Fail; +} +Py_DECREF(delta); +Py_DECREF(dst); +Py_DECREF(off); +return result; +Inconsistent: +PyErr_SetString(PyExc_ValueError, "fromutc: tz.dst() gave " +"inconsistent results; cannot convert"); +/* fall through to failure */ +Fail: +Py_XDECREF(off); +Py_XDECREF(dst); +Py_XDECREF(delta); +Py_XDECREF(result); +return NULL; +} +/* +* Pickle support. This is solely so that tzinfo subclasses can use +* pickling -- tzinfo itself is supposed to be uninstantiable. +*/ +static PyObject * +tzinfo_reduce(PyObject *self, PyObject *Py_UNUSED(dummy)) +{ +PyObject *args, *state; +PyObject *getinitargs; +if (PyObject_GetOptionalAttr(self, &_Py_ID(__getinitargs__), &getinitargs) < 0) { +return NULL; +} +if (getinitargs != NULL) { +args = PyObject_CallNoArgs(getinitargs); +Py_DECREF(getinitargs); +} +else { +args = PyTuple_New(0); +} +if (args == NULL) { +return NULL; +} +state = _PyObject_GetState(self); +if (state == NULL) { +Py_DECREF(args); +return NULL; +} +return Py_BuildValue("(ONN)", Py_TYPE(self), args, state); +} +static PyMethodDef tzinfo_methods[] = { +{"tzname", tzinfo_tzname, METH_O, +PyDoc_STR("datetime -> string name of time zone.")}, +{"utcoffset", tzinfo_utcoffset, METH_O, +PyDoc_STR("datetime -> timedelta showing offset from UTC, negative " +"values indicating West of UTC")}, +{"dst", tzinfo_dst, METH_O, +PyDoc_STR("datetime -> DST offset as timedelta positive east of UTC.")}, +{"fromutc", tzinfo_fromutc, METH_O, +PyDoc_STR("datetime in UTC -> datetime in local time.")}, +{"__reduce__", tzinfo_reduce, METH_NOARGS, +PyDoc_STR("-> (cls, state)")}, +{NULL, NULL} +}; +static const char tzinfo_doc[] = +PyDoc_STR("Abstract base class for time zone info objects.\n\n" +"Subclasses must override the tzname(), utcoffset() and dst() methods."); +static PyTypeObject PyDateTime_TZInfoType = { +PyVarObject_HEAD_INIT(NULL, 0) +"datetime.tzinfo", /* tp_name */ +sizeof(PyDateTime_TZInfo), /* tp_basicsize */ +0, /* tp_itemsize */ +0, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +0, /* tp_repr */ +0, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +0, /* tp_hash */ +0, /* tp_call */ +0, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ +tzinfo_doc, /* tp_doc */ +0, /* tp_traverse */ +0, /* tp_clear */ +0, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +tzinfo_methods, /* tp_methods */ +0, /* tp_members */ +0, /* tp_getset */ +0, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +0, /* tp_alloc */ +PyType_GenericNew, /* tp_new */ +0, /* tp_free */ +}; +/*[clinic input] +@classmethod +datetime.timezone.__new__ as timezone_new +offset: object(subclass_of="DELTA_TYPE(NO_STATE)") +name: unicode = NULL +Fixed offset from UTC implementation of tzinfo. +[clinic start generated code]*/ +static PyObject * +timezone_new_impl(PyTypeObject *type, PyObject *offset, PyObject *name) +/*[clinic end generated code: output=41a2dda500424187 input=d51255afe60382cd]*/ +{ +return new_timezone(offset, name); +} +static void +timezone_dealloc(PyObject *op) +{ +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +Py_CLEAR(self->offset); +Py_CLEAR(self->name); +Py_TYPE(self)->tp_free(self); +} +static PyObject * +timezone_richcompare(PyObject *self, PyObject *other, int op) +{ +if (op != Py_EQ && op != Py_NE) +Py_RETURN_NOTIMPLEMENTED; +if (!PyTimezone_Check(other)) { +Py_RETURN_NOTIMPLEMENTED; +} +PyDateTime_TimeZone *lhs = PyTimeZone_CAST(self); +PyDateTime_TimeZone *rhs = PyTimeZone_CAST(other); +return delta_richcompare(lhs->offset, rhs->offset, op); +} +static Py_hash_t +timezone_hash(PyObject *op) +{ +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +return delta_hash(self->offset); +} +/* Check argument type passed to tzname, utcoffset, or dst methods. +Returns 0 for good argument. Returns -1 and sets exception info +otherwise. +*/ +static int +_timezone_check_argument(PyObject *dt, const char *meth) +{ +if (dt == Py_None || PyDateTime_Check(dt)) +return 0; +PyErr_Format(PyExc_TypeError, "%s(dt) argument must be a datetime instance" +" or None, not %.200s", meth, Py_TYPE(dt)->tp_name); +return -1; +} +static PyObject * +timezone_repr(PyObject *op) +{ +/* Note that although timezone is not subclassable, it is convenient +to use Py_TYPE(self)->tp_name here. */ +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +const char *type_name = Py_TYPE(self)->tp_name; +if (op == CONST_UTC(NO_STATE)) { +return PyUnicode_FromFormat("%s.utc", type_name); +} +if (self->name == NULL) +return PyUnicode_FromFormat("%s(%R)", type_name, self->offset); +return PyUnicode_FromFormat("%s(%R, %R)", type_name, self->offset, +self->name); +} +static PyObject * +timezone_str(PyObject *op) +{ +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +int hours, minutes, seconds, microseconds; +PyObject *offset; +char sign; +if (self->name != NULL) { +return Py_NewRef(self->name); +} +if ((PyObject *)self == CONST_UTC(NO_STATE) || +(GET_TD_DAYS(self->offset) == 0 && +GET_TD_SECONDS(self->offset) == 0 && +GET_TD_MICROSECONDS(self->offset) == 0)) +{ +return PyUnicode_FromString("UTC"); +} +/* Offset is normalized, so it is negative if days < 0 */ +if (GET_TD_DAYS(self->offset) < 0) { +sign = '-'; +offset = delta_negative(self->offset); +if (offset == NULL) +return NULL; +} +else { +sign = '+'; +offset = Py_NewRef(self->offset); +} +/* Offset is not negative here. */ +microseconds = GET_TD_MICROSECONDS(offset); +seconds = GET_TD_SECONDS(offset); +Py_DECREF(offset); +minutes = divmod(seconds, 60, &seconds); +hours = divmod(minutes, 60, &minutes); +if (microseconds != 0) { +return PyUnicode_FromFormat("UTC%c%02d:%02d:%02d.%06d", +sign, hours, minutes, +seconds, microseconds); +} +if (seconds != 0) { +return PyUnicode_FromFormat("UTC%c%02d:%02d:%02d", +sign, hours, minutes, seconds); +} +return PyUnicode_FromFormat("UTC%c%02d:%02d", sign, hours, minutes); +} +static PyObject * +timezone_tzname(PyObject *op, PyObject *dt) +{ +if (_timezone_check_argument(dt, "tzname") == -1) +return NULL; +return timezone_str(op); +} +static PyObject * +timezone_utcoffset(PyObject *op, PyObject *dt) +{ +if (_timezone_check_argument(dt, "utcoffset") == -1) +return NULL; +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +return Py_NewRef(self->offset); +} +static PyObject * +timezone_dst(PyObject *op, PyObject *dt) +{ +if (_timezone_check_argument(dt, "dst") == -1) +return NULL; +Py_RETURN_NONE; +} +static PyObject * +timezone_fromutc(PyObject *op, PyObject *arg) +{ +if (!PyDateTime_Check(arg)) { +PyErr_SetString(PyExc_TypeError, +"fromutc: argument must be a datetime"); +return NULL; +} +PyDateTime_DateTime *dt = (PyDateTime_DateTime *)arg; // fast safe cast +if (!HASTZINFO(dt) || dt->tzinfo != op) { +PyErr_SetString(PyExc_ValueError, "fromutc: dt.tzinfo is not self"); +return NULL; +} +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +return add_datetime_timedelta(dt, (PyDateTime_Delta *)self->offset, 1); +} +static PyObject * +timezone_getinitargs(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_TimeZone *self = PyTimeZone_CAST(op); +if (self->name == NULL) +return PyTuple_Pack(1, self->offset); +return PyTuple_Pack(2, self->offset, self->name); +} +static PyMethodDef timezone_methods[] = { +{"tzname", timezone_tzname, METH_O, +PyDoc_STR("If name is specified when timezone is created, returns the name." +" Otherwise returns offset as 'UTC(+|-)HH:MM'.")}, +{"utcoffset", timezone_utcoffset, METH_O, +PyDoc_STR("Return fixed offset.")}, +{"dst", timezone_dst, METH_O, +PyDoc_STR("Return None.")}, +{"fromutc", timezone_fromutc, METH_O, +PyDoc_STR("datetime in UTC -> datetime in local time.")}, +{"__getinitargs__", timezone_getinitargs, METH_NOARGS, +PyDoc_STR("pickle support")}, +{NULL, NULL} +}; +static PyTypeObject PyDateTime_TimeZoneType = { +PyVarObject_HEAD_INIT(NULL, 0) +"datetime.timezone", /* tp_name */ +sizeof(PyDateTime_TimeZone), /* tp_basicsize */ +0, /* tp_itemsize */ +timezone_dealloc, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +timezone_repr, /* tp_repr */ +0, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +timezone_hash, /* tp_hash */ +0, /* tp_call */ +timezone_str, /* tp_str */ +0, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT, /* tp_flags */ +timezone_new__doc__, /* tp_doc */ +0, /* tp_traverse */ +0, /* tp_clear */ +timezone_richcompare, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +timezone_methods, /* tp_methods */ +0, /* tp_members */ +0, /* tp_getset */ +&PyDateTime_TZInfoType, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +0, /* tp_alloc */ +timezone_new, /* tp_new */ +}; +// XXX Can we make this const? +static PyDateTime_TimeZone utc_timezone = { +PyObject_HEAD_INIT(&PyDateTime_TimeZoneType) +.offset = (PyObject *)&zero_delta, +.name = NULL, +}; +static PyDateTime_TimeZone * +look_up_timezone(PyObject *offset, PyObject *name) +{ +if (offset == utc_timezone.offset && name == NULL) { +return (PyDateTime_TimeZone *)CONST_UTC(NO_STATE); +} +return NULL; +} +/* +* PyDateTime_Time implementation. +*/ +/* Accessor properties. +*/ +static PyObject * +time_hour(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Time *self = PyTime_CAST(op); +return PyLong_FromLong(TIME_GET_HOUR(self)); +} +static PyObject * +time_minute(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Time *self = PyTime_CAST(op); +return PyLong_FromLong(TIME_GET_MINUTE(self)); +} +/* The name time_second conflicted with some platform header file. */ +static PyObject * +py_time_second(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Time *self = PyTime_CAST(op); +return PyLong_FromLong(TIME_GET_SECOND(self)); +} +static PyObject * +time_microsecond(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Time *self = PyTime_CAST(op); +return PyLong_FromLong(TIME_GET_MICROSECOND(self)); +} +static PyObject * +time_tzinfo(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Time *self = PyTime_CAST(op); +PyObject *result = HASTZINFO(self) ? self->tzinfo : Py_None; +return Py_NewRef(result); +} +static PyObject * +time_fold(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_Time *self = PyTime_CAST(op); +return PyLong_FromLong(TIME_GET_FOLD(self)); +} +static PyGetSetDef time_getset[] = { +{"hour", time_hour}, +{"minute", time_minute}, +{"second", py_time_second}, +{"microsecond", time_microsecond}, +{"tzinfo", time_tzinfo}, +{"fold", time_fold}, +{NULL} +}; +/* +* Constructors. +*/ +static PyObject * +time_from_pickle(PyTypeObject *type, PyObject *state, PyObject *tzinfo) +{ +PyDateTime_Time *me; +char aware = (char)(tzinfo != Py_None); +if (aware && check_tzinfo_subclass(tzinfo) < 0) { +PyErr_SetString(PyExc_TypeError, "bad tzinfo state arg"); +return NULL; +} +me = (PyDateTime_Time *) (type->tp_alloc(type, aware)); +if (me != NULL) { +const char *pdata = PyBytes_AS_STRING(state); +memcpy(me->data, pdata, _PyDateTime_TIME_DATASIZE); +me->hashcode = -1; +me->hastzinfo = aware; +if (aware) { +me->tzinfo = Py_NewRef(tzinfo); +} +if (pdata[0] & (1 << 7)) { +me->data[0] -= 128; +me->fold = 1; +} +else { +me->fold = 0; +} +} +return (PyObject *)me; +} +static PyObject * +time_new(PyTypeObject *type, PyObject *args, PyObject *kw) +{ +/* Check for invocation from pickle with __getstate__ state */ +if (PyTuple_GET_SIZE(args) >= 1 && PyTuple_GET_SIZE(args) <= 2) { +PyObject *state = PyTuple_GET_ITEM(args, 0); +PyObject *tzinfo = Py_None; +if (PyTuple_GET_SIZE(args) == 2) { +tzinfo = PyTuple_GET_ITEM(args, 1); +} +if (PyBytes_Check(state)) { +if (PyBytes_GET_SIZE(state) == _PyDateTime_TIME_DATASIZE && +(0x7F & ((unsigned char) (PyBytes_AS_STRING(state)[0]))) < 24) +{ +return time_from_pickle(type, state, tzinfo); +} +} +else if (PyUnicode_Check(state)) { +if (PyUnicode_GET_LENGTH(state) == _PyDateTime_TIME_DATASIZE && +(0x7F & PyUnicode_READ_CHAR(state, 0)) < 24) +{ +state = PyUnicode_AsLatin1String(state); +if (state == NULL) { +if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { +/* More informative error message. */ +PyErr_SetString(PyExc_ValueError, +"Failed to encode latin1 string when unpickling " +"a time object. " +"pickle.load(data, encoding='latin1') is assumed."); +} +return NULL; +} +PyObject *self = time_from_pickle(type, state, tzinfo); +Py_DECREF(state); +return self; +} +} +} +return datetime_time(type, args, kw); +} +/*[clinic input] +@classmethod +datetime.time.__new__ +hour: int = 0 +minute: int = 0 +second: int = 0 +microsecond: int = 0 +tzinfo: object = None +* +fold: int = 0 +Time with time zone. +All arguments are optional. tzinfo may be None, or an instance of +a tzinfo subclass. The remaining arguments may be ints. +[clinic start generated code]*/ +static PyObject * +datetime_time_impl(PyTypeObject *type, int hour, int minute, int second, +int microsecond, PyObject *tzinfo, int fold) +/*[clinic end generated code: output=f06bb4315225e7f6 input=0148df5e8138fe7b]*/ +{ +return new_time_ex2(hour, minute, second, microsecond, tzinfo, fold, type); +} +/*[clinic input] +@classmethod +datetime.time.strptime +string: unicode +format: unicode +/ +Parse string according to the given time format (like time.strptime()). +For a list of supported format codes, see the documentation: +https://docs.python.org/3/library/datetime.html#format-codes +[clinic start generated code]*/ +static PyObject * +datetime_time_strptime_impl(PyTypeObject *type, PyObject *string, +PyObject *format) +/*[clinic end generated code: output=ae05a9bc0241d3bf input=82ba425ecacc54aa]*/ +{ +PyObject *result; +PyObject *module = PyImport_Import(&_Py_ID(_strptime)); +if (module == NULL) { +return NULL; +} +result = PyObject_CallMethodObjArgs(module, +&_Py_ID(_strptime_datetime_time), +(PyObject *)type, string, format, NULL); +Py_DECREF(module); +return result; +} +/* +* Destructor. +*/ +static void +time_dealloc(PyObject *op) +{ +PyDateTime_Time *self = PyTime_CAST(op); +if (HASTZINFO(self)) { +Py_XDECREF(self->tzinfo); +} +Py_TYPE(self)->tp_free(self); +} +/* +* Indirect access to tzinfo methods. +*/ +/* These are all METH_NOARGS, so don't need to check the arglist. */ +static PyObject * +time_utcoffset(PyObject *op, PyObject *Py_UNUSED(dummy)) { +PyDateTime_Time *self = PyTime_CAST(op); +return call_utcoffset(GET_TIME_TZINFO(self), Py_None); +} +static PyObject * +time_dst(PyObject *op, PyObject *Py_UNUSED(dummy)) { +PyDateTime_Time *self = PyTime_CAST(op); +return call_dst(GET_TIME_TZINFO(self), Py_None); +} +static PyObject * +time_tzname(PyObject *op, PyObject *Py_UNUSED(dummy)) { +PyDateTime_Time *self = PyTime_CAST(op); +return call_tzname(GET_TIME_TZINFO(self), Py_None); +} +/* +* Various ways to turn a time into a string. +*/ +static PyObject * +time_repr(PyObject *op) +{ +PyDateTime_Time *self = PyTime_CAST(op); +const char *type_name = Py_TYPE(self)->tp_name; +int h = TIME_GET_HOUR(self); +int m = TIME_GET_MINUTE(self); +int s = TIME_GET_SECOND(self); +int us = TIME_GET_MICROSECOND(self); +int fold = TIME_GET_FOLD(self); +PyObject *result = NULL; +if (us) +result = PyUnicode_FromFormat("%s(%d, %d, %d, %d)", +type_name, h, m, s, us); +else if (s) +result = PyUnicode_FromFormat("%s(%d, %d, %d)", +type_name, h, m, s); +else +result = PyUnicode_FromFormat("%s(%d, %d)", type_name, h, m); +if (result != NULL && HASTZINFO(self)) +result = append_keyword_tzinfo(result, self->tzinfo); +if (result != NULL && fold) +result = append_keyword_fold(result, fold); +return result; +} +static PyObject * +time_str(PyObject *op) +{ +return PyObject_CallMethodNoArgs(op, &_Py_ID(isoformat)); +} +/*[clinic input] +datetime.time.isoformat +timespec: str(c_default="NULL") = 'auto' +Return the time formatted according to ISO. +The full format is 'HH:MM:SS.mmmmmm+zz:zz'. By default, the fractional +part is omitted if self.microsecond == 0. +The optional argument timespec specifies the number of additional +terms of the time to include. Valid options are 'auto', 'hours', +'minutes', 'seconds', 'milliseconds' and 'microseconds'. +[clinic start generated code]*/ +static PyObject * +datetime_time_isoformat_impl(PyDateTime_Time *self, const char *timespec) +/*[clinic end generated code: output=2bcc7cab65c35545 input=afbbbd953d10ad07]*/ +{ +char buf[100]; +PyObject *result; +int us = TIME_GET_MICROSECOND(self); +static const char * const specs[][2] = { +{"hours", "%02d"}, +{"minutes", "%02d:%02d"}, +{"seconds", "%02d:%02d:%02d"}, +{"milliseconds", "%02d:%02d:%02d.%03d"}, +{"microseconds", "%02d:%02d:%02d.%06d"}, +}; +size_t given_spec; +if (timespec == NULL || strcmp(timespec, "auto") == 0) { +if (us == 0) { +/* seconds */ +given_spec = 2; +} +else { +/* microseconds */ +given_spec = 4; +} +} +else { +for (given_spec = 0; given_spec < Py_ARRAY_LENGTH(specs); given_spec++) { +if (strcmp(timespec, specs[given_spec][0]) == 0) { +if (given_spec == 3) { +/* milliseconds */ +us = us / 1000; +} +break; +} +} +} +if (given_spec == Py_ARRAY_LENGTH(specs)) { +PyErr_Format(PyExc_ValueError, "Unknown timespec value"); +return NULL; +} +else { +result = PyUnicode_FromFormat(specs[given_spec][1], +TIME_GET_HOUR(self), TIME_GET_MINUTE(self), +TIME_GET_SECOND(self), us); +} +if (result == NULL || !HASTZINFO(self) || self->tzinfo == Py_None) +return result; +/* We need to append the UTC offset. */ +if (format_utcoffset(buf, sizeof(buf), ":", self->tzinfo, +Py_None) < 0) { +Py_DECREF(result); +return NULL; +} +PyUnicode_AppendAndDel(&result, PyUnicode_FromString(buf)); +return result; +} +/*[clinic input] +@permit_long_docstring_body +datetime.time.strftime +format: unicode +Format using strftime(). +The date part of the timestamp passed to underlying strftime should not be used. +For a list of supported format codes, see the documentation: +https://docs.python.org/3/library/datetime.html#format-codes +[clinic start generated code]*/ +static PyObject * +datetime_time_strftime_impl(PyDateTime_Time *self, PyObject *format) +/*[clinic end generated code: output=10f65af20e2a78c7 input=c4a5bbecd798654b]*/ +{ +PyObject *result; +PyObject *tuple; +/* Python's strftime does insane things with the year part of the +* timetuple. The year is forced to (the otherwise nonsensical) +* 1900 to work around that. +*/ +tuple = Py_BuildValue("iiiiiiiii", +1900, 1, 1, /* year, month, day */ +TIME_GET_HOUR(self), +TIME_GET_MINUTE(self), +TIME_GET_SECOND(self), +0, 1, -1); /* weekday, daynum, dst */ +if (tuple == NULL) +return NULL; +assert(PyTuple_Size(tuple) == 9); +result = wrap_strftime((PyObject *)self, format, tuple, +Py_None); +Py_DECREF(tuple); +return result; +} +/*[clinic input] +datetime.time.__format__ +self: self(type="PyObject *") +format: unicode +/ +Formats self with strftime. +[clinic start generated code]*/ +static PyObject * +datetime_time___format___impl(PyObject *self, PyObject *format) +/*[clinic end generated code: output=4646451f7a5d2156 input=6a858ae787d20230]*/ +{ +/* if the format is zero length, return str(self) */ +if (PyUnicode_GetLength(format) == 0) +return PyObject_Str(self); +return PyObject_CallMethodOneArg(self, &_Py_ID(strftime), format); +} +/* +* Miscellaneous methods. +*/ +static PyObject * +time_richcompare(PyObject *self, PyObject *other, int op) +{ +PyObject *result = NULL; +PyObject *offset1, *offset2; +int diff; +if (! PyTime_Check(other)) +Py_RETURN_NOTIMPLEMENTED; +if (GET_TIME_TZINFO(self) == GET_TIME_TZINFO(other)) { +diff = memcmp(((PyDateTime_Time *)self)->data, +((PyDateTime_Time *)other)->data, +_PyDateTime_TIME_DATASIZE); +return diff_to_bool(diff, op); +} +offset1 = time_utcoffset(self, NULL); +if (offset1 == NULL) +return NULL; +offset2 = time_utcoffset(other, NULL); +if (offset2 == NULL) +goto done; +/* If they're both naive, or both aware and have the same offsets, +* we get off cheap. Note that if they're both naive, offset1 == +* offset2 == Py_None at this point. +*/ +if ((offset1 == offset2) || +(PyDelta_Check(offset1) && PyDelta_Check(offset2) && +delta_cmp(offset1, offset2) == 0)) { +diff = memcmp(((PyDateTime_Time *)self)->data, +((PyDateTime_Time *)other)->data, +_PyDateTime_TIME_DATASIZE); +result = diff_to_bool(diff, op); +} +/* The hard case: both aware with different UTC offsets */ +else if (offset1 != Py_None && offset2 != Py_None) { +int offsecs1, offsecs2; +assert(offset1 != offset2); /* else last "if" handled it */ +offsecs1 = TIME_GET_HOUR(self) * 3600 + +TIME_GET_MINUTE(self) * 60 + +TIME_GET_SECOND(self) - +GET_TD_DAYS(offset1) * 86400 - +GET_TD_SECONDS(offset1); +offsecs2 = TIME_GET_HOUR(other) * 3600 + +TIME_GET_MINUTE(other) * 60 + +TIME_GET_SECOND(other) - +GET_TD_DAYS(offset2) * 86400 - +GET_TD_SECONDS(offset2); +diff = offsecs1 - offsecs2; +if (diff == 0) +diff = TIME_GET_MICROSECOND(self) - +TIME_GET_MICROSECOND(other); +result = diff_to_bool(diff, op); +} +else if (op == Py_EQ) { +result = Py_NewRef(Py_False); +} +else if (op == Py_NE) { +result = Py_NewRef(Py_True); +} +else { +PyErr_SetString(PyExc_TypeError, +"can't compare offset-naive and " +"offset-aware times"); +} +done: +Py_DECREF(offset1); +Py_XDECREF(offset2); +return result; +} +static Py_hash_t +time_hash(PyObject *op) +{ +PyDateTime_Time *self = PyTime_CAST(op); +Py_hash_t hash = FT_ATOMIC_LOAD_SSIZE_RELAXED(self->hashcode); +if (hash == -1) { +PyObject *offset, *self0; +if (TIME_GET_FOLD(self)) { +self0 = new_time_ex2(TIME_GET_HOUR(self), +TIME_GET_MINUTE(self), +TIME_GET_SECOND(self), +TIME_GET_MICROSECOND(self), +HASTZINFO(self) ? self->tzinfo : Py_None, +0, Py_TYPE(self)); +if (self0 == NULL) +return -1; +} +else { +self0 = Py_NewRef(self); +} +offset = time_utcoffset(self0, NULL); +Py_DECREF(self0); +if (offset == NULL) +return -1; +/* Reduce this to a hash of another object. */ +if (offset == Py_None) { +hash = generic_hash( +(unsigned char *)self->data, _PyDateTime_TIME_DATASIZE); +FT_ATOMIC_STORE_SSIZE_RELAXED(self->hashcode, hash); +} else { +PyObject *temp1, *temp2; +int seconds, microseconds; +assert(HASTZINFO(self)); +seconds = TIME_GET_HOUR(self) * 3600 + +TIME_GET_MINUTE(self) * 60 + +TIME_GET_SECOND(self); +microseconds = TIME_GET_MICROSECOND(self); +temp1 = new_delta(0, seconds, microseconds, 1); +if (temp1 == NULL) { +Py_DECREF(offset); +return -1; +} +temp2 = delta_subtract(temp1, offset); +Py_DECREF(temp1); +if (temp2 == NULL) { +Py_DECREF(offset); +return -1; +} +hash = PyObject_Hash(temp2); +FT_ATOMIC_STORE_SSIZE_RELAXED(self->hashcode, hash); +Py_DECREF(temp2); +} +Py_DECREF(offset); +} +return hash; +} +/*[clinic input] +datetime.time.replace +hour: int(c_default="TIME_GET_HOUR(self)") = unchanged +minute: int(c_default="TIME_GET_MINUTE(self)") = unchanged +second: int(c_default="TIME_GET_SECOND(self)") = unchanged +microsecond: int(c_default="TIME_GET_MICROSECOND(self)") = unchanged +tzinfo: object(c_default="HASTZINFO(self) ? ((PyDateTime_Time *)self)->tzinfo : Py_None") = unchanged +* +fold: int(c_default="TIME_GET_FOLD(self)") = unchanged +Return time with new specified fields. +[clinic start generated code]*/ +static PyObject * +datetime_time_replace_impl(PyDateTime_Time *self, int hour, int minute, +int second, int microsecond, PyObject *tzinfo, +int fold) +/*[clinic end generated code: output=0b89a44c299e4f80 input=abf23656e8df4e97]*/ +{ +return new_time_subclass_fold_ex(hour, minute, second, microsecond, tzinfo, +fold, Py_TYPE(self)); +} +/*[clinic input] +@classmethod +datetime.time.fromisoformat +string: unicode +/ +Construct a time from a string in ISO 8601 format. +[clinic start generated code]*/ +static PyObject * +datetime_time_fromisoformat_impl(PyTypeObject *type, PyObject *string) +/*[clinic end generated code: output=97c57e896e7f2535 input=bdb4b8abea9cd688]*/ +{ +Py_ssize_t len; +const char *p = PyUnicode_AsUTF8AndSize(string, &len); +if (p == NULL) { +goto invalid_string_error; +} +// The spec actually requires that time-only ISO 8601 strings start with +// T, but the extended format allows this to be omitted as long as there +// is no ambiguity with date strings. +if (*p == 'T') { +++p; +len -= 1; +} +int hour = 0, minute = 0, second = 0, microsecond = 0; +int tzoffset = 0, tzimicrosecond = 0; +int rv = parse_isoformat_time(p, len, +&hour, &minute, &second, µsecond, +&tzoffset, &tzimicrosecond); +if (rv < 0) { +if (rv == -6) { +goto error; +} +goto invalid_string_error; +} +if (hour == 24) { +if (minute == 0 && second == 0 && microsecond == 0) { +hour = 0; +} else { +goto invalid_iso_midnight; +} +} +PyObject *tzinfo = tzinfo_from_isoformat_results(rv, tzoffset, +tzimicrosecond); +if (tzinfo == NULL) { +return NULL; +} +PyObject *t; +if (type == TIME_TYPE(NO_STATE)) { +t = new_time(hour, minute, second, microsecond, tzinfo, 0); +} else { +t = PyObject_CallFunction((PyObject *)type, "iiiiO", +hour, minute, second, microsecond, tzinfo); +} +Py_DECREF(tzinfo); +return t; +invalid_iso_midnight: +PyErr_SetString(PyExc_ValueError, "minute, second, and microsecond must be 0 when hour is 24"); +return NULL; +invalid_string_error: +PyErr_Format(PyExc_ValueError, "Invalid isoformat string: %R", string); +return NULL; +error: +return NULL; +} +/* Pickle support, a simple use of __reduce__. */ +/* Let basestate be the non-tzinfo data string. +* If tzinfo is None, this returns (basestate,), else (basestate, tzinfo). +* So it's a tuple in any (non-error) case. +* __getstate__ isn't exposed. +*/ +static PyObject * +time_getstate(PyDateTime_Time *self, int proto) +{ +PyObject *basestate; +PyObject *result = NULL; +basestate = PyBytes_FromStringAndSize((char *)self->data, +_PyDateTime_TIME_DATASIZE); +if (basestate != NULL) { +if (proto > 3 && TIME_GET_FOLD(self)) +/* Set the first bit of the first byte */ +PyBytes_AS_STRING(basestate)[0] |= (1 << 7); +if (! HASTZINFO(self) || self->tzinfo == Py_None) +result = PyTuple_Pack(1, basestate); +else +result = PyTuple_Pack(2, basestate, self->tzinfo); +Py_DECREF(basestate); +} +return result; +} +/*[clinic input] +datetime.time.__reduce_ex__ +proto: int +/ +[clinic start generated code]*/ +static PyObject * +datetime_time___reduce_ex___impl(PyDateTime_Time *self, int proto) +/*[clinic end generated code: output=ccfab65f5c320c1b input=4cd06bb3ac3657bb]*/ +{ +return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self, proto)); +} +/*[clinic input] +datetime.time.__reduce__ +[clinic start generated code]*/ +static PyObject * +datetime_time___reduce___impl(PyDateTime_Time *self) +/*[clinic end generated code: output=9a2fcc87e64ce300 input=0fb8dd14d275857f]*/ +{ +return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self, 2)); +} +static PyMethodDef time_methods[] = { +/* Class method: */ +DATETIME_TIME_FROMISOFORMAT_METHODDEF +DATETIME_TIME_STRPTIME_METHODDEF +/* Instance methods: */ +DATETIME_TIME_ISOFORMAT_METHODDEF +DATETIME_TIME_STRFTIME_METHODDEF +DATETIME_TIME___FORMAT___METHODDEF +{"utcoffset", time_utcoffset, METH_NOARGS, +PyDoc_STR("Return self.tzinfo.utcoffset(self).")}, +{"tzname", time_tzname, METH_NOARGS, +PyDoc_STR("Return self.tzinfo.tzname(self).")}, +{"dst", time_dst, METH_NOARGS, +PyDoc_STR("Return self.tzinfo.dst(self).")}, +DATETIME_TIME_REPLACE_METHODDEF +{"__replace__", _PyCFunction_CAST(datetime_time_replace), METH_FASTCALL | METH_KEYWORDS, +PyDoc_STR("__replace__($self, /, **changes)\n--\n\nThe same as replace().")}, +DATETIME_TIME___REDUCE_EX___METHODDEF +DATETIME_TIME___REDUCE___METHODDEF +{NULL, NULL} +}; +static PyTypeObject PyDateTime_TimeType = { +PyVarObject_HEAD_INIT(NULL, 0) +"datetime.time", /* tp_name */ +sizeof(PyDateTime_Time), /* tp_basicsize */ +0, /* tp_itemsize */ +time_dealloc, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +time_repr, /* tp_repr */ +0, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +time_hash, /* tp_hash */ +0, /* tp_call */ +time_str, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ +datetime_time__doc__, /* tp_doc */ +0, /* tp_traverse */ +0, /* tp_clear */ +time_richcompare, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +time_methods, /* tp_methods */ +0, /* tp_members */ +time_getset, /* tp_getset */ +0, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +time_alloc, /* tp_alloc */ +time_new, /* tp_new */ +0, /* tp_free */ +}; +/* +* PyDateTime_DateTime implementation. +*/ +/* Accessor properties. Properties for day, month, and year are inherited +* from date. +*/ +static PyObject * +datetime_hour(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return PyLong_FromLong(DATE_GET_HOUR(self)); +} +static PyObject * +datetime_minute(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return PyLong_FromLong(DATE_GET_MINUTE(self)); +} +static PyObject * +datetime_second(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return PyLong_FromLong(DATE_GET_SECOND(self)); +} +static PyObject * +datetime_microsecond(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return PyLong_FromLong(DATE_GET_MICROSECOND(self)); +} +static PyObject * +datetime_tzinfo(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +PyObject *result = HASTZINFO(self) ? self->tzinfo : Py_None; +return Py_NewRef(result); +} +static PyObject * +datetime_fold(PyObject *op, void *Py_UNUSED(closure)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return PyLong_FromLong(DATE_GET_FOLD(self)); +} +static PyGetSetDef datetime_getset[] = { +{"hour", datetime_hour}, +{"minute", datetime_minute}, +{"second", datetime_second}, +{"microsecond", datetime_microsecond}, +{"tzinfo", datetime_tzinfo}, +{"fold", datetime_fold}, +{NULL} +}; +/* +* Constructors. +*/ +static PyObject * +datetime_from_pickle(PyTypeObject *type, PyObject *state, PyObject *tzinfo) +{ +PyDateTime_DateTime *me; +char aware = (char)(tzinfo != Py_None); +if (aware && check_tzinfo_subclass(tzinfo) < 0) { +PyErr_SetString(PyExc_TypeError, "bad tzinfo state arg"); +return NULL; +} +me = (PyDateTime_DateTime *) (type->tp_alloc(type , aware)); +if (me != NULL) { +const char *pdata = PyBytes_AS_STRING(state); +memcpy(me->data, pdata, _PyDateTime_DATETIME_DATASIZE); +me->hashcode = -1; +me->hastzinfo = aware; +if (aware) { +me->tzinfo = Py_NewRef(tzinfo); +} +if (pdata[2] & (1 << 7)) { +me->data[2] -= 128; +me->fold = 1; +} +else { +me->fold = 0; +} +} +return (PyObject *)me; +} +static PyObject * +datetime_new(PyTypeObject *type, PyObject *args, PyObject *kw) +{ +/* Check for invocation from pickle with __getstate__ state */ +if (PyTuple_GET_SIZE(args) >= 1 && PyTuple_GET_SIZE(args) <= 2) { +PyObject *state = PyTuple_GET_ITEM(args, 0); +PyObject *tzinfo = Py_None; +if (PyTuple_GET_SIZE(args) == 2) { +tzinfo = PyTuple_GET_ITEM(args, 1); +} +if (PyBytes_Check(state)) { +if (PyBytes_GET_SIZE(state) == _PyDateTime_DATETIME_DATASIZE && +MONTH_IS_SANE(PyBytes_AS_STRING(state)[2] & 0x7F)) +{ +return datetime_from_pickle(type, state, tzinfo); +} +} +else if (PyUnicode_Check(state)) { +if (PyUnicode_GET_LENGTH(state) == _PyDateTime_DATETIME_DATASIZE && +MONTH_IS_SANE(PyUnicode_READ_CHAR(state, 2) & 0x7F)) +{ +state = PyUnicode_AsLatin1String(state); +if (state == NULL) { +if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { +/* More informative error message. */ +PyErr_SetString(PyExc_ValueError, +"Failed to encode latin1 string when unpickling " +"a datetime object. " +"pickle.load(data, encoding='latin1') is assumed."); +} +return NULL; +} +PyObject *self = datetime_from_pickle(type, state, tzinfo); +Py_DECREF(state); +return self; +} +} +} +return datetime_datetime(type, args, kw); +} +/*[clinic input] +@classmethod +datetime.datetime.__new__ +year: int +month: int +day: int +hour: int = 0 +minute: int = 0 +second: int = 0 +microsecond: int = 0 +tzinfo: object = None +* +fold: int = 0 +A combination of a date and a time. +The year, month and day arguments are required. tzinfo may be None, or an +instance of a tzinfo subclass. The remaining arguments may be ints. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_impl(PyTypeObject *type, int year, int month, int day, +int hour, int minute, int second, int microsecond, +PyObject *tzinfo, int fold) +/*[clinic end generated code: output=47983ddb47d36037 input=2af468d7a9c1e568]*/ +{ +return new_datetime_ex2(year, month, day, +hour, minute, second, microsecond, +tzinfo, fold, type); +} +/* TM_FUNC is the shared type of _PyTime_localtime() and +* _PyTime_gmtime(). */ +typedef int (*TM_FUNC)(time_t timer, struct tm*); +/* As of version 2015f max fold in IANA database is +* 23 hours at 1969-09-30 13:00:00 in Kwajalein. */ +static long long max_fold_seconds = 24 * 3600; +/* NB: date(1970,1,1).toordinal() == 719163 */ +static long long epoch = 719163LL * 24 * 60 * 60; +static long long +utc_to_seconds(int year, int month, int day, +int hour, int minute, int second) +{ +long long ordinal; +/* ymd_to_ord() doesn't support year <= 0 */ +if (year < MINYEAR || year > MAXYEAR) { +PyErr_Format(PyExc_ValueError, +"year must be in %d..%d, not %d", MINYEAR, MAXYEAR, year); +return -1; +} +ordinal = ymd_to_ord(year, month, day); +return ((ordinal * 24 + hour) * 60 + minute) * 60 + second; +} +static long long +local(long long u) +{ +struct tm local_time; +time_t t; +u -= epoch; +t = u; +if (t != u) { +PyErr_SetString(PyExc_OverflowError, +"timestamp out of range for platform time_t"); +return -1; +} +if (_PyTime_localtime(t, &local_time) != 0) +return -1; +return utc_to_seconds(local_time.tm_year + 1900, +local_time.tm_mon + 1, +local_time.tm_mday, +local_time.tm_hour, +local_time.tm_min, +local_time.tm_sec); +} +/* Internal helper. +* Build datetime from a time_t and a distinct count of microseconds. +* Pass localtime or gmtime for f, to control the interpretation of timet. +*/ +static PyObject * +datetime_from_timet_and_us(PyTypeObject *cls, TM_FUNC f, time_t timet, int us, +PyObject *tzinfo) +{ +struct tm tm; +int year, month, day, hour, minute, second, fold = 0; +if (f(timet, &tm) != 0) +return NULL; +year = tm.tm_year + 1900; +month = tm.tm_mon + 1; +day = tm.tm_mday; +hour = tm.tm_hour; +minute = tm.tm_min; +/* The platform localtime/gmtime may insert leap seconds, +* indicated by tm.tm_sec > 59. We don't care about them, +* except to the extent that passing them on to the datetime +* constructor would raise ValueError for a reason that +* made no sense to the user. +*/ +second = Py_MIN(59, tm.tm_sec); +/* local timezone requires to compute fold */ +if (tzinfo == Py_None && f == _PyTime_localtime) { +long long probe_seconds, result_seconds, transition; +result_seconds = utc_to_seconds(year, month, day, +hour, minute, second); +if (result_seconds == -1 && PyErr_Occurred()) { +return NULL; +} +/* Probe max_fold_seconds to detect a fold. */ +probe_seconds = local(epoch + timet - max_fold_seconds); +if (probe_seconds == -1) +return NULL; +transition = result_seconds - probe_seconds - max_fold_seconds; +if (transition < 0) { +probe_seconds = local(epoch + timet + transition); +if (probe_seconds == -1) +return NULL; +if (probe_seconds == result_seconds) +fold = 1; +} +} +return new_datetime_subclass_fold_ex(year, month, day, hour, minute, +second, us, tzinfo, fold, cls); +} +/* Internal helper. +* Build datetime from a Python timestamp. Pass localtime or gmtime for f, +* to control the interpretation of the timestamp. Since a double doesn't +* have enough bits to cover a datetime's full range of precision, it's +* better to call datetime_from_timet_and_us provided you have a way +* to get that much precision (e.g., C time() isn't good enough). +*/ +static PyObject * +datetime_from_timestamp(PyTypeObject *cls, TM_FUNC f, PyObject *timestamp, +PyObject *tzinfo) +{ +time_t timet; +long us; +if (_PyTime_ObjectToTimeval(timestamp, +&timet, &us, _PyTime_ROUND_HALF_EVEN) == -1) +return NULL; +return datetime_from_timet_and_us(cls, f, timet, (int)us, tzinfo); +} +/* Internal helper. +* Build most accurate possible datetime for current time. Pass localtime or +* gmtime for f as appropriate. +*/ +static PyObject * +datetime_best_possible(PyTypeObject *cls, TM_FUNC f, PyObject *tzinfo) +{ +PyTime_t ts; +if (PyTime_Time(&ts) < 0) { +return NULL; +} +time_t secs; +int us; +if (_PyTime_AsTimevalTime_t(ts, &secs, &us, _PyTime_ROUND_HALF_EVEN) < 0) { +return NULL; +} +assert(0 <= us && us <= 999999); +return datetime_from_timet_and_us(cls, f, secs, us, tzinfo); +} +/*[clinic input] +@classmethod +datetime.datetime.now +tz: object = None +Timezone object. +Returns new datetime object representing current time local to tz. +If no tz is specified, uses local timezone. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_now_impl(PyTypeObject *type, PyObject *tz) +/*[clinic end generated code: output=b3386e5345e2b47a input=80d09869c5267d00]*/ +{ +PyObject *self; +/* Return best possible local time -- this isn't constrained by the +* precision of a timestamp. +*/ +if (check_tzinfo_subclass(tz) < 0) +return NULL; +self = datetime_best_possible(type, +tz == Py_None ? _PyTime_localtime : +_PyTime_gmtime, +tz); +if (self != NULL && tz != Py_None) { +/* Convert UTC to tzinfo's zone. */ +PyObject *res = PyObject_CallMethodOneArg(tz, &_Py_ID(fromutc), self); +Py_DECREF(self); +return res; +} +return self; +} +/* Return best possible UTC time -- this isn't constrained by the +* precision of a timestamp. +*/ +/*[clinic input] +@classmethod +datetime.datetime.utcnow +Return a new datetime representing UTC day and time. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_utcnow_impl(PyTypeObject *type) +/*[clinic end generated code: output=cfcfe71c6c916ba9 input=576eff2b222b80a1]*/ +{ +if (PyErr_WarnEx(PyExc_DeprecationWarning, +"datetime.datetime.utcnow() is deprecated and scheduled for removal in a " +"future version. Use timezone-aware objects to represent datetimes " +"in UTC: datetime.datetime.now(datetime.UTC).", 1)) +{ +return NULL; +} +return datetime_best_possible(type, _PyTime_gmtime, Py_None); +} +/*[clinic input] +@permit_long_docstring_body +@classmethod +datetime.datetime.fromtimestamp +timestamp: object +tz as tzinfo: object = None +Create a datetime from a POSIX timestamp. +The timestamp is a number, e.g. created via time.time(), that is interpreted +as local time. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_fromtimestamp_impl(PyTypeObject *type, PyObject *timestamp, +PyObject *tzinfo) +/*[clinic end generated code: output=9c47ea2b2ebdaded input=d6b5b2095c5a34b2]*/ +{ +PyObject *self; +if (check_tzinfo_subclass(tzinfo) < 0) +return NULL; +self = datetime_from_timestamp(type, +tzinfo == Py_None ? _PyTime_localtime : +_PyTime_gmtime, +timestamp, +tzinfo); +if (self != NULL && tzinfo != Py_None) { +/* Convert UTC to tzinfo's zone. */ +PyObject *res = PyObject_CallMethodOneArg(tzinfo, &_Py_ID(fromutc), self); +Py_DECREF(self); +return res; +} +return self; +} +/* This is a wrapper for API compatibility with the public C API. */ +static PyObject * +datetime_datetime_fromtimestamp_capi(PyObject *cls, PyObject *args, PyObject *kw) +{ +PyObject *timestamp; +PyObject *tzinfo = Py_None; +static char *keywords[] = {"timestamp", "tz", NULL}; +if (!PyArg_ParseTupleAndKeywords(args, kw, "O|O:fromtimestamp", +keywords, ×tamp, &tzinfo)) +return NULL; +return datetime_datetime_fromtimestamp_impl((PyTypeObject *)cls, +timestamp, tzinfo); +} +/*[clinic input] +@classmethod +datetime.datetime.utcfromtimestamp +timestamp: object +/ +Create a naive UTC datetime from a POSIX timestamp. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_utcfromtimestamp_impl(PyTypeObject *type, +PyObject *timestamp) +/*[clinic end generated code: output=66d0b1741d788fd2 input=13fabd4296b1c206]*/ +{ +if (PyErr_WarnEx(PyExc_DeprecationWarning, +"datetime.datetime.utcfromtimestamp() is deprecated and scheduled for removal " +"in a future version. Use timezone-aware objects to represent " +"datetimes in UTC: datetime.datetime.fromtimestamp(timestamp, datetime.UTC).", 1)) +{ +return NULL; +} +return datetime_from_timestamp(type, _PyTime_gmtime, timestamp, Py_None); +} +/*[clinic input] +@permit_long_summary +@classmethod +datetime.datetime.strptime +string: unicode +format: unicode +/ +Parse string according to the given date and time format (like time.strptime()). +For a list of supported format codes, see the documentation: +https://docs.python.org/3/library/datetime.html#format-codes +[clinic start generated code]*/ +static PyObject * +datetime_datetime_strptime_impl(PyTypeObject *type, PyObject *string, +PyObject *format) +/*[clinic end generated code: output=af2c2d024f3203f5 input=ef7807589f1d50e7]*/ +{ +PyObject *result; +PyObject *module = PyImport_Import(&_Py_ID(_strptime)); +if (module == NULL) { +return NULL; +} +result = PyObject_CallMethodObjArgs(module, +&_Py_ID(_strptime_datetime_datetime), +(PyObject *)type, string, format, NULL); +Py_DECREF(module); +return result; +} +/*[clinic input] +@classmethod +datetime.datetime.combine +date: object(subclass_of="DATE_TYPE(NO_STATE)") +time: object(subclass_of="TIME_TYPE(NO_STATE)") +tzinfo: object = NULL +Construct a datetime from a given date and a given time. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_combine_impl(PyTypeObject *type, PyObject *date, +PyObject *time, PyObject *tzinfo) +/*[clinic end generated code: output=a10f3cbb90f4d0aa input=4fcf0743288d0bab]*/ +{ +if (tzinfo == NULL) { +if (HASTZINFO(time)) +tzinfo = ((PyDateTime_Time *)time)->tzinfo; +else +tzinfo = Py_None; +} +return new_datetime_subclass_fold_ex(GET_YEAR(date), +GET_MONTH(date), +GET_DAY(date), +TIME_GET_HOUR(time), +TIME_GET_MINUTE(time), +TIME_GET_SECOND(time), +TIME_GET_MICROSECOND(time), +tzinfo, +TIME_GET_FOLD(time), +type); +} +static PyObject * +_sanitize_isoformat_str(PyObject *dtstr) +{ +Py_ssize_t len = PyUnicode_GetLength(dtstr); +if (len < 7) { // All valid ISO 8601 strings are at least 7 characters long +return NULL; +} +// `fromisoformat` allows surrogate characters in exactly one position, +// the separator; to allow datetime_fromisoformat to make the simplifying +// assumption that all valid strings can be encoded in UTF-8, this function +// replaces any surrogate character separators with `T`. +// +// The result of this, if not NULL, returns a new reference +const void* const unicode_data = PyUnicode_DATA(dtstr); +const int kind = PyUnicode_KIND(dtstr); +// Depending on the format of the string, the separator can only ever be +// in positions 7, 8 or 10. We'll check each of these for a surrogate and +// if we find one, replace it with `T`. If there is more than one surrogate, +// we don't have to bother sanitizing it, because the function will later +// fail when we try to encode the string as ASCII. +static const size_t potential_separators[3] = {7, 8, 10}; +size_t surrogate_separator = 0; +for(size_t idx = 0; +idx < sizeof(potential_separators) / sizeof(*potential_separators); +++idx) { +size_t pos = potential_separators[idx]; +if (pos > (size_t)len) { +break; +} +if(Py_UNICODE_IS_SURROGATE(PyUnicode_READ(kind, unicode_data, pos))) { +surrogate_separator = pos; +break; +} +} +if (surrogate_separator == 0) { +return Py_NewRef(dtstr); +} +PyObject *str_out = _PyUnicode_Copy(dtstr); +if (str_out == NULL) { +return NULL; +} +if (PyUnicode_WriteChar(str_out, surrogate_separator, (Py_UCS4)'T')) { +Py_DECREF(str_out); +return NULL; +} +return str_out; +} +static Py_ssize_t +_find_isoformat_datetime_separator(const char *dtstr, Py_ssize_t len) { +// The valid date formats can all be distinguished by characters 4 and 5 +// and further narrowed down by character +// which tells us where to look for the separator character. +// Format | As-rendered | Position +// --------------------------------------- +// %Y-%m-%d | YYYY-MM-DD | 10 +// %Y%m%d | YYYYMMDD | 8 +// %Y-W%V | YYYY-Www | 8 +// %YW%V | YYYYWww | 7 +// %Y-W%V-%u | YYYY-Www-d | 10 +// %YW%V%u | YYYYWwwd | 8 +// %Y-%j | YYYY-DDD | 8 +// %Y%j | YYYYDDD | 7 +// +// Note that because we allow *any* character for the separator, in the +// case where character 4 is W, it's not straightforward to determine where +// the separator is — in the case of YYYY-Www-d, you have actual ambiguity, +// e.g. 2020-W01-0000 could be YYYY-Www-D0HH or YYYY-Www-HHMM, when the +// separator character is a number in the former case or a hyphen in the +// latter case. +// +// The case of YYYYWww can be distinguished from YYYYWwwd by tracking ahead +// to either the end of the string or the first non-numeric character — +// since the time components all come in pairs YYYYWww#HH can be +// distinguished from YYYYWwwd#HH by the fact that there will always be an +// odd number of digits before the first non-digit character in the former +// case. +static const char date_separator = '-'; +static const char week_indicator = 'W'; +if (len == 7) { +return 7; +} +if (dtstr[4] == date_separator) { +// YYYY-??? +if (dtstr[5] == week_indicator) { +// YYYY-W?? +if (len < 8) { +return -1; +} +if (len > 8 && dtstr[8] == date_separator) { +// YYYY-Www-D (10) or YYYY-Www-HH (8) +if (len == 9) { return -1; } +if (len > 10 && is_digit(dtstr[10])) { +// This is as far as we'll try to go to resolve the +// ambiguity for the moment — if we have YYYY-Www-##, the +// separator is either a hyphen at 8 or a number at 10. +// +// We'll assume it's a hyphen at 8 because it's way more +// likely that someone will use a hyphen as a separator +// than a number, but at this point it's really best effort +// because this is an extension of the spec anyway. +return 8; +} +return 10; +} else { +// YYYY-Www (8) +return 8; +} +} else { +// YYYY-MM-DD (10) +return 10; +} +} else { +// YYYY??? +if (dtstr[4] == week_indicator) { +// YYYYWww (7) or YYYYWwwd (8) +size_t idx = 7; +for (; idx < (size_t)len; ++idx) { +// Keep going until we run out of digits. +if (!is_digit(dtstr[idx])) { +break; +} +} +if (idx < 9) { +return idx; +} +if (idx % 2 == 0) { +// If the index of the last number is even, it's YYYYWww +return 7; +} else { +return 8; +} +} else { +// YYYYMMDD (8) +return 8; +} +} +} +/*[clinic input] +@classmethod +datetime.datetime.fromisoformat +string: unicode +/ +Construct a date from a string in ISO 8601 format. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_fromisoformat_impl(PyTypeObject *type, PyObject *string) +/*[clinic end generated code: output=1800a952fcab79d9 input=d517b158209ded42]*/ +{ +// We only need to sanitize this string if the separator is a surrogate +// character. In the situation where the separator location is ambiguous, +// we don't have to sanitize it anything because that can only happen when +// the separator is either '-' or a number. This should mostly be a noop +// but it makes the reference counting easier if we still sanitize. +PyObject *dtstr_clean = _sanitize_isoformat_str(string); +if (dtstr_clean == NULL) { +goto invalid_string_error; +} +Py_ssize_t len; +const char *dt_ptr = PyUnicode_AsUTF8AndSize(dtstr_clean, &len); +if (dt_ptr == NULL) { +if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { +// Encoding errors are invalid string errors at this point +goto invalid_string_error; +} +else { +goto error; +} +} +const Py_ssize_t separator_location = _find_isoformat_datetime_separator( +dt_ptr, len); +const char *p = dt_ptr; +int year = 0, month = 0, day = 0; +int hour = 0, minute = 0, second = 0, microsecond = 0; +int tzoffset = 0, tzusec = 0; +// date runs up to separator_location +int rv = parse_isoformat_date(p, separator_location, &year, &month, &day); +if (!rv && len > separator_location) { +// In UTF-8, the length of multi-byte characters is encoded in the MSB +p += separator_location; +if ((p[0] & 0x80) == 0) { +p += 1; +} +else { +switch (p[0] & 0xf0) { +case 0xe0: +p += 3; +break; +case 0xf0: +p += 4; +break; +default: +p += 2; +break; +} +} +len -= (p - dt_ptr); +rv = parse_isoformat_time(p, len, &hour, &minute, &second, +µsecond, &tzoffset, &tzusec); +if (rv == -6) { +goto error; +} +} +if (rv < 0) { +goto invalid_string_error; +} +PyObject *tzinfo = tzinfo_from_isoformat_results(rv, tzoffset, tzusec); +if (tzinfo == NULL) { +goto error; +} +if ((hour == 24) && (month <= 12)) { +int d_in_month = days_in_month(year, month); +if (day <= d_in_month) { +if (minute == 0 && second == 0 && microsecond == 0) { +// Calculate midnight of the next day +hour = 0; +day += 1; +if (day > d_in_month) { +day = 1; +month += 1; +if (month > 12) { +month = 1; +year += 1; +} +} +} else { +goto invalid_iso_midnight; +} +} +} +PyObject *dt = new_datetime_subclass_ex(year, month, day, hour, minute, +second, microsecond, tzinfo, type); +Py_DECREF(tzinfo); +Py_DECREF(dtstr_clean); +return dt; +invalid_iso_midnight: +PyErr_SetString(PyExc_ValueError, "minute, second, and microsecond must be 0 when hour is 24"); +Py_DECREF(tzinfo); +Py_DECREF(dtstr_clean); +return NULL; +invalid_string_error: +PyErr_Format(PyExc_ValueError, "Invalid isoformat string: %R", string); +error: +Py_XDECREF(dtstr_clean); +return NULL; +} +/* +* Destructor. +*/ +static void +datetime_dealloc(PyObject *op) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +if (HASTZINFO(self)) { +Py_XDECREF(self->tzinfo); +} +Py_TYPE(self)->tp_free(self); +} +/* +* Indirect access to tzinfo methods. +*/ +/* These are all METH_NOARGS, so don't need to check the arglist. */ +static PyObject * +datetime_utcoffset(PyObject *op, PyObject *Py_UNUSED(dummy)) { +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return call_utcoffset(GET_DT_TZINFO(self), op); +} +static PyObject * +datetime_dst(PyObject *op, PyObject *Py_UNUSED(dummy)) { +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return call_dst(GET_DT_TZINFO(self), op); +} +static PyObject * +datetime_tzname(PyObject *op, PyObject *Py_UNUSED(dummy)) { +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return call_tzname(GET_DT_TZINFO(self), op); +} +/* +* datetime arithmetic. +*/ +/* factor must be 1 (to add) or -1 (to subtract). The result inherits +* the tzinfo state of date. +*/ +static PyObject * +add_datetime_timedelta(PyDateTime_DateTime *date, PyDateTime_Delta *delta, +int factor) +{ +/* Note that the C-level additions can't overflow, because of +* invariant bounds on the member values. +*/ +int year = GET_YEAR(date); +int month = GET_MONTH(date); +int day = GET_DAY(date) + GET_TD_DAYS(delta) * factor; +int hour = DATE_GET_HOUR(date); +int minute = DATE_GET_MINUTE(date); +int second = DATE_GET_SECOND(date) + GET_TD_SECONDS(delta) * factor; +int microsecond = DATE_GET_MICROSECOND(date) + +GET_TD_MICROSECONDS(delta) * factor; +assert(factor == 1 || factor == -1); +if (normalize_datetime(&year, &month, &day, +&hour, &minute, &second, µsecond) < 0) { +return NULL; +} +return new_datetime_subclass_ex(year, month, day, +hour, minute, second, microsecond, +HASTZINFO(date) ? date->tzinfo : Py_None, +Py_TYPE(date)); +} +static PyObject * +datetime_add(PyObject *left, PyObject *right) +{ +if (PyDateTime_Check(left)) { +/* datetime + ??? */ +if (PyDelta_Check(right)) +/* datetime + delta */ +return add_datetime_timedelta( +(PyDateTime_DateTime *)left, +(PyDateTime_Delta *)right, +1); +} +else if (PyDelta_Check(left)) { +/* delta + datetime */ +return add_datetime_timedelta((PyDateTime_DateTime *) right, +(PyDateTime_Delta *) left, +1); +} +Py_RETURN_NOTIMPLEMENTED; +} +static PyObject * +datetime_subtract(PyObject *left, PyObject *right) +{ +PyObject *result = Py_NotImplemented; +if (PyDateTime_Check(left)) { +/* datetime - ??? */ +if (PyDateTime_Check(right)) { +/* datetime - datetime */ +PyObject *offset1, *offset2, *offdiff = NULL; +int delta_d, delta_s, delta_us; +if (GET_DT_TZINFO(left) == GET_DT_TZINFO(right)) { +offset1 = Py_NewRef(Py_None); +offset2 = Py_NewRef(Py_None); +} +else { +offset1 = datetime_utcoffset(left, NULL); +if (offset1 == NULL) +return NULL; +offset2 = datetime_utcoffset(right, NULL); +if (offset2 == NULL) { +Py_DECREF(offset1); +return NULL; +} +if ((offset1 != Py_None) != (offset2 != Py_None)) { +PyErr_SetString(PyExc_TypeError, +"can't subtract offset-naive and " +"offset-aware datetimes"); +Py_DECREF(offset1); +Py_DECREF(offset2); +return NULL; +} +} +if ((offset1 != offset2) && +delta_cmp(offset1, offset2) != 0) { +offdiff = delta_subtract(offset1, offset2); +if (offdiff == NULL) { +Py_DECREF(offset1); +Py_DECREF(offset2); +return NULL; +} +} +Py_DECREF(offset1); +Py_DECREF(offset2); +delta_d = ymd_to_ord(GET_YEAR(left), +GET_MONTH(left), +GET_DAY(left)) - +ymd_to_ord(GET_YEAR(right), +GET_MONTH(right), +GET_DAY(right)); +/* These can't overflow, since the values are +* normalized. At most this gives the number of +* seconds in one day. +*/ +delta_s = (DATE_GET_HOUR(left) - +DATE_GET_HOUR(right)) * 3600 + +(DATE_GET_MINUTE(left) - +DATE_GET_MINUTE(right)) * 60 + +(DATE_GET_SECOND(left) - +DATE_GET_SECOND(right)); +delta_us = DATE_GET_MICROSECOND(left) - +DATE_GET_MICROSECOND(right); +result = new_delta(delta_d, delta_s, delta_us, 1); +if (result == NULL) +return NULL; +if (offdiff != NULL) { +Py_SETREF(result, delta_subtract(result, offdiff)); +Py_DECREF(offdiff); +} +} +else if (PyDelta_Check(right)) { +/* datetime - delta */ +result = add_datetime_timedelta( +(PyDateTime_DateTime *)left, +(PyDateTime_Delta *)right, +-1); +} +} +if (result == Py_NotImplemented) +Py_INCREF(result); +return result; +} +/* Various ways to turn a datetime into a string. */ +static PyObject * +datetime_repr(PyObject *op) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +const char *type_name = Py_TYPE(self)->tp_name; +PyObject *baserepr; +if (DATE_GET_MICROSECOND(self)) { +baserepr = PyUnicode_FromFormat( +"%s(%d, %d, %d, %d, %d, %d, %d)", +type_name, +GET_YEAR(self), GET_MONTH(self), GET_DAY(self), +DATE_GET_HOUR(self), DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), +DATE_GET_MICROSECOND(self)); +} +else if (DATE_GET_SECOND(self)) { +baserepr = PyUnicode_FromFormat( +"%s(%d, %d, %d, %d, %d, %d)", +type_name, +GET_YEAR(self), GET_MONTH(self), GET_DAY(self), +DATE_GET_HOUR(self), DATE_GET_MINUTE(self), +DATE_GET_SECOND(self)); +} +else { +baserepr = PyUnicode_FromFormat( +"%s(%d, %d, %d, %d, %d)", +type_name, +GET_YEAR(self), GET_MONTH(self), GET_DAY(self), +DATE_GET_HOUR(self), DATE_GET_MINUTE(self)); +} +if (baserepr != NULL && DATE_GET_FOLD(self) != 0) +baserepr = append_keyword_fold(baserepr, DATE_GET_FOLD(self)); +if (baserepr == NULL || ! HASTZINFO(self)) +return baserepr; +return append_keyword_tzinfo(baserepr, self->tzinfo); +} +static PyObject * +datetime_str(PyObject *op) +{ +PyObject *space = PyUnicode_FromString(" "); +if (space == NULL) { +return NULL; +} +PyObject *res = PyObject_CallMethodOneArg(op, &_Py_ID(isoformat), space); +Py_DECREF(space); +return res; +} +/*[clinic input] +datetime.datetime.isoformat +sep: int(accept={str}, c_default="'T'", py_default="'T'") = ord('T') +timespec: str(c_default="NULL") = 'auto' +Return the time formatted according to ISO. +The full format looks like 'YYYY-MM-DD HH:MM:SS.mmmmmm'. +By default, the fractional part is omitted if self.microsecond == 0. +If self.tzinfo is not None, the UTC offset is also attached, giving +a full format of 'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM'. +Optional argument sep specifies the separator between date and +time, default 'T'. +The optional argument timespec specifies the number of additional +terms of the time to include. Valid options are 'auto', 'hours', +'minutes', 'seconds', 'milliseconds' and 'microseconds'. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_isoformat_impl(PyDateTime_DateTime *self, int sep, +const char *timespec) +/*[clinic end generated code: output=9b6ce1383189b0bf input=2fa2512172ccf5d5]*/ +{ +char buffer[100]; +PyObject *result = NULL; +int us = DATE_GET_MICROSECOND(self); +static const char * const specs[][2] = { +{"hours", "%04d-%02d-%02d%c%02d"}, +{"minutes", "%04d-%02d-%02d%c%02d:%02d"}, +{"seconds", "%04d-%02d-%02d%c%02d:%02d:%02d"}, +{"milliseconds", "%04d-%02d-%02d%c%02d:%02d:%02d.%03d"}, +{"microseconds", "%04d-%02d-%02d%c%02d:%02d:%02d.%06d"}, +}; +size_t given_spec; +if (timespec == NULL || strcmp(timespec, "auto") == 0) { +if (us == 0) { +/* seconds */ +given_spec = 2; +} +else { +/* microseconds */ +given_spec = 4; +} +} +else { +for (given_spec = 0; given_spec < Py_ARRAY_LENGTH(specs); given_spec++) { +if (strcmp(timespec, specs[given_spec][0]) == 0) { +if (given_spec == 3) { +us = us / 1000; +} +break; +} +} +} +if (given_spec == Py_ARRAY_LENGTH(specs)) { +PyErr_Format(PyExc_ValueError, "Unknown timespec value"); +return NULL; +} +else { +result = PyUnicode_FromFormat(specs[given_spec][1], +GET_YEAR(self), GET_MONTH(self), +GET_DAY(self), (int)sep, +DATE_GET_HOUR(self), DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), us); +} +if (!result || !HASTZINFO(self)) +return result; +/* We need to append the UTC offset. */ +if (format_utcoffset(buffer, sizeof(buffer), ":", self->tzinfo, (PyObject *)self) < 0) { +Py_DECREF(result); +return NULL; +} +PyUnicode_AppendAndDel(&result, PyUnicode_FromString(buffer)); +return result; +} +static PyObject * +datetime_ctime(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return format_ctime(op, +DATE_GET_HOUR(self), +DATE_GET_MINUTE(self), +DATE_GET_SECOND(self)); +} +/* Miscellaneous methods. */ +static PyObject * +flip_fold(PyObject *dt) +{ +return new_datetime_ex2(GET_YEAR(dt), +GET_MONTH(dt), +GET_DAY(dt), +DATE_GET_HOUR(dt), +DATE_GET_MINUTE(dt), +DATE_GET_SECOND(dt), +DATE_GET_MICROSECOND(dt), +HASTZINFO(dt) ? +((PyDateTime_DateTime *)dt)->tzinfo : Py_None, +!DATE_GET_FOLD(dt), +Py_TYPE(dt)); +} +static PyObject * +get_flip_fold_offset(PyObject *dt) +{ +PyObject *result, *flip_dt; +flip_dt = flip_fold(dt); +if (flip_dt == NULL) +return NULL; +result = datetime_utcoffset(flip_dt, NULL); +Py_DECREF(flip_dt); +return result; +} +/* PEP 495 exception: Whenever one or both of the operands in +* inter-zone comparison is such that its utcoffset() depends +* on the value of its fold attribute, the result is False. +* +* Return 1 if exception applies, 0 if not, and -1 on error. +*/ +static int +pep495_eq_exception(PyObject *self, PyObject *other, +PyObject *offset_self, PyObject *offset_other) +{ +int result = 0; +PyObject *flip_offset; +flip_offset = get_flip_fold_offset(self); +if (flip_offset == NULL) +return -1; +if (flip_offset != offset_self && +delta_cmp(flip_offset, offset_self)) +{ +result = 1; +goto done; +} +Py_DECREF(flip_offset); +flip_offset = get_flip_fold_offset(other); +if (flip_offset == NULL) +return -1; +if (flip_offset != offset_other && +delta_cmp(flip_offset, offset_other)) +result = 1; +done: +Py_DECREF(flip_offset); +return result; +} +static PyObject * +datetime_richcompare(PyObject *self, PyObject *other, int op) +{ +PyObject *result = NULL; +PyObject *offset1, *offset2; +int diff; +if (!PyDateTime_Check(other)) { +Py_RETURN_NOTIMPLEMENTED; +} +if (GET_DT_TZINFO(self) == GET_DT_TZINFO(other)) { +diff = memcmp(((PyDateTime_DateTime *)self)->data, +((PyDateTime_DateTime *)other)->data, +_PyDateTime_DATETIME_DATASIZE); +return diff_to_bool(diff, op); +} +offset1 = datetime_utcoffset(self, NULL); +if (offset1 == NULL) +return NULL; +offset2 = datetime_utcoffset(other, NULL); +if (offset2 == NULL) +goto done; +/* If they're both naive, or both aware and have the same offsets, +* we get off cheap. Note that if they're both naive, offset1 == +* offset2 == Py_None at this point. +*/ +if ((offset1 == offset2) || +(PyDelta_Check(offset1) && PyDelta_Check(offset2) && +delta_cmp(offset1, offset2) == 0)) { +diff = memcmp(((PyDateTime_DateTime *)self)->data, +((PyDateTime_DateTime *)other)->data, +_PyDateTime_DATETIME_DATASIZE); +if ((op == Py_EQ || op == Py_NE) && diff == 0) { +int ex = pep495_eq_exception(self, other, offset1, offset2); +if (ex == -1) +goto done; +if (ex) +diff = 1; +} +result = diff_to_bool(diff, op); +} +else if (offset1 != Py_None && offset2 != Py_None) { +PyDateTime_Delta *delta; +assert(offset1 != offset2); /* else last "if" handled it */ +delta = (PyDateTime_Delta *)datetime_subtract(self, other); +if (delta == NULL) +goto done; +diff = GET_TD_DAYS(delta); +if (diff == 0) +diff = GET_TD_SECONDS(delta) | +GET_TD_MICROSECONDS(delta); +Py_DECREF(delta); +if ((op == Py_EQ || op == Py_NE) && diff == 0) { +int ex = pep495_eq_exception(self, other, offset1, offset2); +if (ex == -1) +goto done; +if (ex) +diff = 1; +} +result = diff_to_bool(diff, op); +} +else if (op == Py_EQ) { +result = Py_NewRef(Py_False); +} +else if (op == Py_NE) { +result = Py_NewRef(Py_True); +} +else { +PyErr_SetString(PyExc_TypeError, +"can't compare offset-naive and " +"offset-aware datetimes"); +} +done: +Py_DECREF(offset1); +Py_XDECREF(offset2); +return result; +} +static Py_hash_t +datetime_hash(PyObject *op) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +Py_hash_t hash = FT_ATOMIC_LOAD_SSIZE_RELAXED(self->hashcode); +if (hash == -1) { +PyObject *offset, *self0; +if (DATE_GET_FOLD(self)) { +self0 = new_datetime_ex2(GET_YEAR(self), +GET_MONTH(self), +GET_DAY(self), +DATE_GET_HOUR(self), +DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), +DATE_GET_MICROSECOND(self), +HASTZINFO(self) ? self->tzinfo : Py_None, +0, Py_TYPE(self)); +if (self0 == NULL) +return -1; +} +else { +self0 = Py_NewRef(self); +} +offset = datetime_utcoffset(self0, NULL); +Py_DECREF(self0); +if (offset == NULL) +return -1; +/* Reduce this to a hash of another object. */ +if (offset == Py_None) { +hash = generic_hash( +(unsigned char *)self->data, _PyDateTime_DATETIME_DATASIZE); +FT_ATOMIC_STORE_SSIZE_RELAXED(self->hashcode, hash); +} else { +PyObject *temp1, *temp2; +int days, seconds; +assert(HASTZINFO(self)); +days = ymd_to_ord(GET_YEAR(self), +GET_MONTH(self), +GET_DAY(self)); +seconds = DATE_GET_HOUR(self) * 3600 + +DATE_GET_MINUTE(self) * 60 + +DATE_GET_SECOND(self); +temp1 = new_delta(days, seconds, +DATE_GET_MICROSECOND(self), +1); +if (temp1 == NULL) { +Py_DECREF(offset); +return -1; +} +temp2 = delta_subtract(temp1, offset); +Py_DECREF(temp1); +if (temp2 == NULL) { +Py_DECREF(offset); +return -1; +} +hash = PyObject_Hash(temp2); +FT_ATOMIC_STORE_SSIZE_RELAXED(self->hashcode, hash); +Py_DECREF(temp2); +} +Py_DECREF(offset); +} +return hash; +} +/*[clinic input] +datetime.datetime.replace +year: int(c_default="GET_YEAR(self)") = unchanged +month: int(c_default="GET_MONTH(self)") = unchanged +day: int(c_default="GET_DAY(self)") = unchanged +hour: int(c_default="DATE_GET_HOUR(self)") = unchanged +minute: int(c_default="DATE_GET_MINUTE(self)") = unchanged +second: int(c_default="DATE_GET_SECOND(self)") = unchanged +microsecond: int(c_default="DATE_GET_MICROSECOND(self)") = unchanged +tzinfo: object(c_default="HASTZINFO(self) ? ((PyDateTime_DateTime *)self)->tzinfo : Py_None") = unchanged +* +fold: int(c_default="DATE_GET_FOLD(self)") = unchanged +Return datetime with new specified fields. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_replace_impl(PyDateTime_DateTime *self, int year, +int month, int day, int hour, int minute, +int second, int microsecond, PyObject *tzinfo, +int fold) +/*[clinic end generated code: output=00bc96536833fddb input=fd972762d604d3e7]*/ +{ +return new_datetime_subclass_fold_ex(year, month, day, hour, minute, +second, microsecond, tzinfo, fold, +Py_TYPE(self)); +} +static PyObject * +local_timezone_from_timestamp(time_t timestamp) +{ +PyObject *result = NULL; +PyObject *delta; +struct tm local_time_tm; +PyObject *nameo = NULL; +const char *zone = NULL; +if (_PyTime_localtime(timestamp, &local_time_tm) != 0) +return NULL; +#ifdef HAVE_STRUCT_TM_TM_ZONE +zone = local_time_tm.tm_zone; +delta = new_delta(0, local_time_tm.tm_gmtoff, 0, 1); +#else /* HAVE_STRUCT_TM_TM_ZONE */ +{ +PyObject *local_time, *utc_time; +struct tm utc_time_tm; +char buf[100]; +strftime(buf, sizeof(buf), "%Z", &local_time_tm); +zone = buf; +local_time = new_datetime(local_time_tm.tm_year + 1900, +local_time_tm.tm_mon + 1, +local_time_tm.tm_mday, +local_time_tm.tm_hour, +local_time_tm.tm_min, +local_time_tm.tm_sec, 0, Py_None, 0); +if (local_time == NULL) { +return NULL; +} +if (_PyTime_gmtime(timestamp, &utc_time_tm) != 0) +return NULL; +utc_time = new_datetime(utc_time_tm.tm_year + 1900, +utc_time_tm.tm_mon + 1, +utc_time_tm.tm_mday, +utc_time_tm.tm_hour, +utc_time_tm.tm_min, +utc_time_tm.tm_sec, 0, Py_None, 0); +if (utc_time == NULL) { +Py_DECREF(local_time); +return NULL; +} +delta = datetime_subtract(local_time, utc_time); +Py_DECREF(local_time); +Py_DECREF(utc_time); +} +#endif /* HAVE_STRUCT_TM_TM_ZONE */ +if (delta == NULL) { +return NULL; +} +if (zone != NULL) { +nameo = PyUnicode_DecodeLocale(zone, "surrogateescape"); +if (nameo == NULL) +goto error; +} +result = new_timezone(delta, nameo); +Py_XDECREF(nameo); +error: +Py_DECREF(delta); +return result; +} +static PyObject * +local_timezone(PyDateTime_DateTime *utc_time) +{ +time_t timestamp; +PyObject *delta; +PyObject *one_second; +PyObject *seconds; +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +delta = datetime_subtract((PyObject *)utc_time, CONST_EPOCH(st)); +RELEASE_CURRENT_STATE(st, current_mod); +if (delta == NULL) +return NULL; +one_second = new_delta(0, 1, 0, 0); +if (one_second == NULL) { +Py_DECREF(delta); +return NULL; +} +seconds = divide_timedelta_timedelta((PyDateTime_Delta *)delta, +(PyDateTime_Delta *)one_second); +Py_DECREF(one_second); +Py_DECREF(delta); +if (seconds == NULL) +return NULL; +timestamp = _PyLong_AsTime_t(seconds); +Py_DECREF(seconds); +if (timestamp == -1 && PyErr_Occurred()) +return NULL; +return local_timezone_from_timestamp(timestamp); +} +static long long +local_to_seconds(int year, int month, int day, +int hour, int minute, int second, int fold); +static PyObject * +local_timezone_from_local(PyDateTime_DateTime *local_dt) +{ +long long seconds, seconds2; +time_t timestamp; +int fold = DATE_GET_FOLD(local_dt); +seconds = local_to_seconds(GET_YEAR(local_dt), +GET_MONTH(local_dt), +GET_DAY(local_dt), +DATE_GET_HOUR(local_dt), +DATE_GET_MINUTE(local_dt), +DATE_GET_SECOND(local_dt), +fold); +if (seconds == -1) +return NULL; +seconds2 = local_to_seconds(GET_YEAR(local_dt), +GET_MONTH(local_dt), +GET_DAY(local_dt), +DATE_GET_HOUR(local_dt), +DATE_GET_MINUTE(local_dt), +DATE_GET_SECOND(local_dt), +!fold); +if (seconds2 == -1) +return NULL; +/* Detect gap */ +if (seconds2 != seconds && (seconds2 > seconds) == fold) +seconds = seconds2; +/* XXX: add bounds check */ +timestamp = seconds - epoch; +return local_timezone_from_timestamp(timestamp); +} +/*[clinic input] +datetime.datetime.astimezone +tz as tzinfo: object = None +Convert to local time in new timezone tz. +[clinic start generated code]*/ +static PyObject * +datetime_datetime_astimezone_impl(PyDateTime_DateTime *self, +PyObject *tzinfo) +/*[clinic end generated code: output=ae2263d04e944537 input=9c675c8595009935]*/ +{ +PyDateTime_DateTime *result; +PyObject *offset; +PyObject *temp; +PyObject *self_tzinfo; +if (check_tzinfo_subclass(tzinfo) == -1) +return NULL; +if (!HASTZINFO(self) || self->tzinfo == Py_None) { +naive: +self_tzinfo = local_timezone_from_local(self); +if (self_tzinfo == NULL) +return NULL; +} else { +self_tzinfo = Py_NewRef(self->tzinfo); +} +/* Conversion to self's own time zone is a NOP. */ +if (self_tzinfo == tzinfo) { +Py_DECREF(self_tzinfo); +return Py_NewRef(self); +} +/* Convert self to UTC. */ +offset = call_utcoffset(self_tzinfo, (PyObject *)self); +Py_DECREF(self_tzinfo); +if (offset == NULL) +return NULL; +else if(offset == Py_None) { +Py_DECREF(offset); +goto naive; +} +else if (!PyDelta_Check(offset)) { +Py_DECREF(offset); +PyErr_Format(PyExc_TypeError, "utcoffset() returned %.200s," +" expected timedelta or None", Py_TYPE(offset)->tp_name); +return NULL; +} +/* result = self - offset */ +result = (PyDateTime_DateTime *)add_datetime_timedelta(self, +(PyDateTime_Delta *)offset, -1); +Py_DECREF(offset); +if (result == NULL) +return NULL; +/* Make sure result is aware and UTC. */ +if (!HASTZINFO(result)) { +temp = (PyObject *)result; +result = (PyDateTime_DateTime *) +new_datetime_ex2(GET_YEAR(result), +GET_MONTH(result), +GET_DAY(result), +DATE_GET_HOUR(result), +DATE_GET_MINUTE(result), +DATE_GET_SECOND(result), +DATE_GET_MICROSECOND(result), +CONST_UTC(NO_STATE), +DATE_GET_FOLD(result), +Py_TYPE(result)); +Py_DECREF(temp); +if (result == NULL) +return NULL; +} +else { +/* Result is already aware - just replace tzinfo. */ +Py_SETREF(result->tzinfo, Py_NewRef(CONST_UTC(NO_STATE))); +} +/* Attach new tzinfo and let fromutc() do the rest. */ +if (tzinfo == Py_None) { +tzinfo = local_timezone(result); +if (tzinfo == NULL) { +Py_DECREF(result); +return NULL; +} +} +else +Py_INCREF(tzinfo); +Py_SETREF(result->tzinfo, tzinfo); +temp = (PyObject *)result; +result = (PyDateTime_DateTime *) +PyObject_CallMethodOneArg(tzinfo, &_Py_ID(fromutc), temp); +Py_DECREF(temp); +return (PyObject *)result; +} +static PyObject * +datetime_timetuple(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +int dstflag = -1; +if (HASTZINFO(self) && self->tzinfo != Py_None) { +PyObject * dst; +dst = call_dst(self->tzinfo, op); +if (dst == NULL) +return NULL; +if (dst != Py_None) +dstflag = delta_bool(dst); +Py_DECREF(dst); +} +return build_struct_time(GET_YEAR(self), +GET_MONTH(self), +GET_DAY(self), +DATE_GET_HOUR(self), +DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), +dstflag); +} +static long long +local_to_seconds(int year, int month, int day, +int hour, int minute, int second, int fold) +{ +long long t, a, b, u1, u2, t1, t2, lt; +t = utc_to_seconds(year, month, day, hour, minute, second); +/* Our goal is to solve t = local(u) for u. */ +lt = local(t); +if (lt == -1) +return -1; +a = lt - t; +u1 = t - a; +t1 = local(u1); +if (t1 == -1) +return -1; +if (t1 == t) { +/* We found one solution, but it may not be the one we need. +* Look for an earlier solution (if `fold` is 0), or a +* later one (if `fold` is 1). */ +if (fold) +u2 = u1 + max_fold_seconds; +else +u2 = u1 - max_fold_seconds; +lt = local(u2); +if (lt == -1) +return -1; +b = lt - u2; +if (a == b) +return u1; +} +else { +b = t1 - u1; +assert(a != b); +} +u2 = t - b; +t2 = local(u2); +if (t2 == -1) +return -1; +if (t2 == t) +return u2; +if (t1 == t) +return u1; +/* We have found both offsets a and b, but neither t - a nor t - b is +* a solution. This means t is in the gap. */ +return fold?Py_MIN(u1, u2):Py_MAX(u1, u2); +} +/* date(1970,1,1).toordinal() == 719163 */ +#define EPOCH_SECONDS (719163LL * 24 * 60 * 60) +static PyObject * +datetime_timestamp(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +PyObject *result; +if (HASTZINFO(self) && self->tzinfo != Py_None) { +PyObject *current_mod = NULL; +datetime_state *st = GET_CURRENT_STATE(current_mod); +PyObject *delta; +delta = datetime_subtract(op, CONST_EPOCH(st)); +RELEASE_CURRENT_STATE(st, current_mod); +if (delta == NULL) +return NULL; +result = delta_total_seconds(delta, NULL); +Py_DECREF(delta); +} +else { +long long seconds; +seconds = local_to_seconds(GET_YEAR(self), +GET_MONTH(self), +GET_DAY(self), +DATE_GET_HOUR(self), +DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), +DATE_GET_FOLD(self)); +if (seconds == -1) +return NULL; +result = PyFloat_FromDouble(seconds - EPOCH_SECONDS + +DATE_GET_MICROSECOND(self) / 1e6); +} +return result; +} +static PyObject * +datetime_getdate(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return new_date(GET_YEAR(self), +GET_MONTH(self), +GET_DAY(self)); +} +static PyObject * +datetime_gettime(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return new_time(DATE_GET_HOUR(self), +DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), +DATE_GET_MICROSECOND(self), +Py_None, +DATE_GET_FOLD(self)); +} +static PyObject * +datetime_gettimetz(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +PyDateTime_DateTime *self = PyDateTime_CAST(op); +return new_time(DATE_GET_HOUR(self), +DATE_GET_MINUTE(self), +DATE_GET_SECOND(self), +DATE_GET_MICROSECOND(self), +GET_DT_TZINFO(self), +DATE_GET_FOLD(self)); +} +static PyObject * +datetime_utctimetuple(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ +int y, m, d, hh, mm, ss; +PyObject *tzinfo; +PyDateTime_DateTime *utcself; +PyDateTime_DateTime *self = PyDateTime_CAST(op); +tzinfo = GET_DT_TZINFO(self); +if (tzinfo == Py_None) { +utcself = (PyDateTime_DateTime*)Py_NewRef(self); +} +else { +PyObject *offset; +offset = call_utcoffset(tzinfo, (PyObject *)self); +if (offset == NULL) +return NULL; +if (offset == Py_None) { +Py_DECREF(offset); +utcself = (PyDateTime_DateTime*)Py_NewRef(self); +} +else { +utcself = (PyDateTime_DateTime *)add_datetime_timedelta(self, +(PyDateTime_Delta *)offset, -1); +Py_DECREF(offset); +if (utcself == NULL) +return NULL; +} +} +y = GET_YEAR(utcself); +m = GET_MONTH(utcself); +d = GET_DAY(utcself); +hh = DATE_GET_HOUR(utcself); +mm = DATE_GET_MINUTE(utcself); +ss = DATE_GET_SECOND(utcself); +Py_DECREF(utcself); +return build_struct_time(y, m, d, hh, mm, ss, 0); +} +/* Pickle support, a simple use of __reduce__. */ +/* Let basestate be the non-tzinfo data string. +* If tzinfo is None, this returns (basestate,), else (basestate, tzinfo). +* So it's a tuple in any (non-error) case. +* __getstate__ isn't exposed. +*/ +static PyObject * +datetime_getstate(PyDateTime_DateTime *self, int proto) +{ +PyObject *basestate; +PyObject *result = NULL; +basestate = PyBytes_FromStringAndSize((char *)self->data, +_PyDateTime_DATETIME_DATASIZE); +if (basestate != NULL) { +if (proto > 3 && DATE_GET_FOLD(self)) +/* Set the first bit of the third byte */ +PyBytes_AS_STRING(basestate)[2] |= (1 << 7); +if (! HASTZINFO(self) || self->tzinfo == Py_None) +result = PyTuple_Pack(1, basestate); +else +result = PyTuple_Pack(2, basestate, self->tzinfo); +Py_DECREF(basestate); +} +return result; +} +/*[clinic input] +datetime.datetime.__reduce_ex__ +proto: int +/ +[clinic start generated code]*/ +static PyObject * +datetime_datetime___reduce_ex___impl(PyDateTime_DateTime *self, int proto) +/*[clinic end generated code: output=53d712ce3e927735 input=bab748e49ffb30c3]*/ +{ +return Py_BuildValue("(ON)", Py_TYPE(self), +datetime_getstate(self, proto)); +} +/*[clinic input] +datetime.datetime.__reduce__ +[clinic start generated code]*/ +static PyObject * +datetime_datetime___reduce___impl(PyDateTime_DateTime *self) +/*[clinic end generated code: output=6794df9ea75666cf input=cadbbeb3bf3bf94c]*/ +{ +return Py_BuildValue("(ON)", Py_TYPE(self), +datetime_getstate(self, 2)); +} +static PyMethodDef datetime_methods[] = { +/* Class methods: */ +DATETIME_DATETIME_NOW_METHODDEF +DATETIME_DATETIME_UTCNOW_METHODDEF +DATETIME_DATETIME_FROMTIMESTAMP_METHODDEF +DATETIME_DATETIME_UTCFROMTIMESTAMP_METHODDEF +DATETIME_DATETIME_STRPTIME_METHODDEF +DATETIME_DATETIME_COMBINE_METHODDEF +DATETIME_DATETIME_FROMISOFORMAT_METHODDEF +/* Instance methods: */ +{"date", datetime_getdate, METH_NOARGS, +PyDoc_STR("Return date object with same year, month and day.")}, +{"time", datetime_gettime, METH_NOARGS, +PyDoc_STR("Return time object with same time but with tzinfo=None.")}, +{"timetz", datetime_gettimetz, METH_NOARGS, +PyDoc_STR("Return time object with same time and tzinfo.")}, +{"ctime", datetime_ctime, METH_NOARGS, +PyDoc_STR("Return ctime() style string.")}, +{"timetuple", datetime_timetuple, METH_NOARGS, +PyDoc_STR("Return time tuple, compatible with time.localtime().")}, +{"timestamp", datetime_timestamp, METH_NOARGS, +PyDoc_STR("Return POSIX timestamp as float.")}, +{"utctimetuple", datetime_utctimetuple, METH_NOARGS, +PyDoc_STR("Return UTC time tuple, compatible with time.localtime().")}, +DATETIME_DATETIME_ISOFORMAT_METHODDEF +{"utcoffset", datetime_utcoffset, METH_NOARGS, +PyDoc_STR("Return self.tzinfo.utcoffset(self).")}, +{"tzname", datetime_tzname, METH_NOARGS, +PyDoc_STR("Return self.tzinfo.tzname(self).")}, +{"dst", datetime_dst, METH_NOARGS, +PyDoc_STR("Return self.tzinfo.dst(self).")}, +DATETIME_DATETIME_REPLACE_METHODDEF +{"__replace__", _PyCFunction_CAST(datetime_datetime_replace), METH_FASTCALL | METH_KEYWORDS, +PyDoc_STR("__replace__($self, /, **changes)\n--\n\nThe same as replace().")}, +DATETIME_DATETIME_ASTIMEZONE_METHODDEF +DATETIME_DATETIME___REDUCE_EX___METHODDEF +DATETIME_DATETIME___REDUCE___METHODDEF +{NULL, NULL} +}; +static PyNumberMethods datetime_as_number = { +datetime_add, /* nb_add */ +datetime_subtract, /* nb_subtract */ +0, /* nb_multiply */ +0, /* nb_remainder */ +0, /* nb_divmod */ +0, /* nb_power */ +0, /* nb_negative */ +0, /* nb_positive */ +0, /* nb_absolute */ +0, /* nb_bool */ +}; +static PyTypeObject PyDateTime_DateTimeType = { +PyVarObject_HEAD_INIT(NULL, 0) +"datetime.datetime", /* tp_name */ +sizeof(PyDateTime_DateTime), /* tp_basicsize */ +0, /* tp_itemsize */ +datetime_dealloc, /* tp_dealloc */ +0, /* tp_vectorcall_offset */ +0, /* tp_getattr */ +0, /* tp_setattr */ +0, /* tp_as_async */ +datetime_repr, /* tp_repr */ +&datetime_as_number, /* tp_as_number */ +0, /* tp_as_sequence */ +0, /* tp_as_mapping */ +datetime_hash, /* tp_hash */ +0, /* tp_call */ +datetime_str, /* tp_str */ +PyObject_GenericGetAttr, /* tp_getattro */ +0, /* tp_setattro */ +0, /* tp_as_buffer */ +Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ +datetime_datetime__doc__, /* tp_doc */ +0, /* tp_traverse */ +0, /* tp_clear */ +datetime_richcompare, /* tp_richcompare */ +0, /* tp_weaklistoffset */ +0, /* tp_iter */ +0, /* tp_iternext */ +datetime_methods, /* tp_methods */ +0, /* tp_members */ +datetime_getset, /* tp_getset */ +&PyDateTime_DateType, /* tp_base */ +0, /* tp_dict */ +0, /* tp_descr_get */ +0, /* tp_descr_set */ +0, /* tp_dictoffset */ +0, /* tp_init */ +datetime_alloc, /* tp_alloc */ +datetime_new, /* tp_new */ +0, /* tp_free */ +}; +/* --------------------------------------------------------------------------- +* datetime C-API. +*/ +static PyTypeObject * const capi_types[] = { +&PyDateTime_DateType, +&PyDateTime_DateTimeType, +&PyDateTime_TimeType, +&PyDateTime_DeltaType, +&PyDateTime_TZInfoType, +/* Indirectly, via the utc object. */ +&PyDateTime_TimeZoneType, +}; +/* The C-API is process-global. This violates interpreter isolation +* due to the objects stored here. Thus each of those objects must +* be managed carefully. */ +// XXX Can we make this const? +static PyDateTime_CAPI capi = { +/* The classes must be readied before used here. +* That will happen the first time the module is loaded. +* They aren't safe to be shared between interpreters, +* but that's okay as long as the module is single-phase init. */ +.DateType = &PyDateTime_DateType, +.DateTimeType = &PyDateTime_DateTimeType, +.TimeType = &PyDateTime_TimeType, +.DeltaType = &PyDateTime_DeltaType, +.TZInfoType = &PyDateTime_TZInfoType, +.TimeZone_UTC = (PyObject *)&utc_timezone, +.Date_FromDate = new_date_ex, +.DateTime_FromDateAndTime = new_datetime_ex, +.Time_FromTime = new_time_ex, +.Delta_FromDelta = new_delta_ex, +.TimeZone_FromTimeZone = new_timezone, +.DateTime_FromTimestamp = datetime_datetime_fromtimestamp_capi, +.Date_FromTimestamp = datetime_date_fromtimestamp_capi, +.DateTime_FromDateAndTimeAndFold = new_datetime_ex2, +.Time_FromTimeAndFold = new_time_ex2, +}; +/* Get a new C API by calling this function. +* Clients get at C API via PyDateTime_IMPORT, defined in datetime.h. +*/ +static inline PyDateTime_CAPI * +get_datetime_capi(void) +{ +return &capi; +} +static PyObject * +create_timezone_from_delta(int days, int sec, int ms, int normalize) +{ +PyObject *delta = new_delta(days, sec, ms, normalize); +if (delta == NULL) { +return NULL; +} +PyObject *tz = create_timezone(delta, NULL); +Py_DECREF(delta); +return tz; +} +/* --------------------------------------------------------------------------- +* Module state lifecycle. +*/ +static int +init_state(datetime_state *st, PyObject *module, PyObject *old_module) +{ +/* Each module gets its own heap types. */ +#define ADD_TYPE(FIELD, SPEC, BASE) \ +do { \ +PyObject *cls = PyType_FromModuleAndSpec( \ +module, SPEC, (PyObject *)BASE); \ +if (cls == NULL) { \ +return -1; \ +} \ +st->FIELD = (PyTypeObject *)cls; \ +} while (0) +ADD_TYPE(isocalendar_date_type, &isocal_spec, &PyTuple_Type); +#undef ADD_TYPE +if (old_module != NULL) { +assert(old_module != module); +datetime_state *st_old = get_module_state(old_module); +*st = (datetime_state){ +.isocalendar_date_type = st->isocalendar_date_type, +.us_per_ms = Py_NewRef(st_old->us_per_ms), +.us_per_second = Py_NewRef(st_old->us_per_second), +.us_per_minute = Py_NewRef(st_old->us_per_minute), +.us_per_hour = Py_NewRef(st_old->us_per_hour), +.us_per_day = Py_NewRef(st_old->us_per_day), +.us_per_week = Py_NewRef(st_old->us_per_week), +.seconds_per_day = Py_NewRef(st_old->seconds_per_day), +.epoch = Py_NewRef(st_old->epoch), +}; +return 0; +} +st->us_per_ms = PyLong_FromLong(1000); +if (st->us_per_ms == NULL) { +return -1; +} +st->us_per_second = PyLong_FromLong(1000000); +if (st->us_per_second == NULL) { +return -1; +} +st->us_per_minute = PyLong_FromLong(60000000); +if (st->us_per_minute == NULL) { +return -1; +} +st->seconds_per_day = PyLong_FromLong(24 * 3600); +if (st->seconds_per_day == NULL) { +return -1; +} +/* The rest are too big for 32-bit ints, but even +* us_per_week fits in 40 bits, so doubles should be exact. +*/ +st->us_per_hour = PyLong_FromDouble(3600000000.0); +if (st->us_per_hour == NULL) { +return -1; +} +st->us_per_day = PyLong_FromDouble(86400000000.0); +if (st->us_per_day == NULL) { +return -1; +} +st->us_per_week = PyLong_FromDouble(604800000000.0); +if (st->us_per_week == NULL) { +return -1; +} +/* Init Unix epoch */ +st->epoch = new_datetime( +1970, 1, 1, 0, 0, 0, 0, (PyObject *)&utc_timezone, 0); +if (st->epoch == NULL) { +return -1; +} +return 0; +} +static int +traverse_state(datetime_state *st, visitproc visit, void *arg) +{ +/* heap types */ +Py_VISIT(st->isocalendar_date_type); +return 0; +} +static int +clear_state(datetime_state *st) +{ +Py_CLEAR(st->isocalendar_date_type); +Py_CLEAR(st->us_per_ms); +Py_CLEAR(st->us_per_second); +Py_CLEAR(st->us_per_minute); +Py_CLEAR(st->us_per_hour); +Py_CLEAR(st->us_per_day); +Py_CLEAR(st->us_per_week); +Py_CLEAR(st->seconds_per_day); +Py_CLEAR(st->epoch); +return 0; +} +PyStatus +_PyDateTime_InitTypes(PyInterpreterState *interp) +{ +/* Bases classes must be initialized before subclasses, +* so capi_types must have the types in the appropriate order. */ +for (size_t i = 0; i < Py_ARRAY_LENGTH(capi_types); i++) { +PyTypeObject *type = capi_types[i]; +if (_PyStaticType_InitForExtension(interp, type) < 0) { +return _PyStatus_ERR("could not initialize static types"); +} +} +#define DATETIME_ADD_MACRO(dict, c, value_expr) \ +do { \ +assert(!PyErr_Occurred()); \ +PyObject *value = (value_expr); \ +if (value == NULL) { \ +goto error; \ +} \ +if (PyDict_SetItemString(dict, c, value) < 0) { \ +Py_DECREF(value); \ +goto error; \ +} \ +Py_DECREF(value); \ +} while(0) +/* timedelta values */ +PyObject *d = _PyType_GetDict(&PyDateTime_DeltaType); +DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0)); +DATETIME_ADD_MACRO(d, "min", new_delta(-MAX_DELTA_DAYS, 0, 0, 0)); +DATETIME_ADD_MACRO(d, "max", +new_delta(MAX_DELTA_DAYS, 24*3600-1, 1000000-1, 0)); +/* date values */ +d = _PyType_GetDict(&PyDateTime_DateType); +DATETIME_ADD_MACRO(d, "min", new_date(1, 1, 1)); +DATETIME_ADD_MACRO(d, "max", new_date(MAXYEAR, 12, 31)); +DATETIME_ADD_MACRO(d, "resolution", new_delta(1, 0, 0, 0)); +/* time values */ +d = _PyType_GetDict(&PyDateTime_TimeType); +DATETIME_ADD_MACRO(d, "min", new_time(0, 0, 0, 0, Py_None, 0)); +DATETIME_ADD_MACRO(d, "max", new_time(23, 59, 59, 999999, Py_None, 0)); +DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0)); +/* datetime values */ +d = _PyType_GetDict(&PyDateTime_DateTimeType); +DATETIME_ADD_MACRO(d, "min", +new_datetime(1, 1, 1, 0, 0, 0, 0, Py_None, 0)); +DATETIME_ADD_MACRO(d, "max", new_datetime(MAXYEAR, 12, 31, 23, 59, 59, +999999, Py_None, 0)); +DATETIME_ADD_MACRO(d, "resolution", new_delta(0, 0, 1, 0)); +/* timezone values */ +d = _PyType_GetDict(&PyDateTime_TimeZoneType); +if (PyDict_SetItemString(d, "utc", (PyObject *)&utc_timezone) < 0) { +goto error; +} +/* bpo-37642: These attributes are rounded to the nearest minute for backwards +* compatibility, even though the constructor will accept a wider range of +* values. This may change in the future.*/ +/* -23:59 */ +DATETIME_ADD_MACRO(d, "min", create_timezone_from_delta(-1, 60, 0, 1)); +/* +23:59 */ +DATETIME_ADD_MACRO( +d, "max", create_timezone_from_delta(0, (23 * 60 + 59) * 60, 0, 0)); +#undef DATETIME_ADD_MACRO +return _PyStatus_OK(); +error: +return _PyStatus_NO_MEMORY(); +} +/* --------------------------------------------------------------------------- +* Module methods and initialization. +*/ +static PyMethodDef module_methods[] = { +{NULL, NULL} +}; +static int +_datetime_exec(PyObject *module) +{ +int rc = -1; +datetime_state *st = get_module_state(module); +PyInterpreterState *interp = PyInterpreterState_Get(); +PyObject *old_module = get_current_module(interp); +if (PyErr_Occurred()) { +assert(old_module == NULL); +goto error; +} +/* We actually set the "current" module right before a successful return. */ +for (size_t i = 0; i < Py_ARRAY_LENGTH(capi_types); i++) { +PyTypeObject *type = capi_types[i]; +const char *name = _PyType_Name(type); +assert(name != NULL); +if (PyModule_AddObjectRef(module, name, (PyObject *)type) < 0) { +goto error; +} +} +if (init_state(st, module, old_module) < 0) { +goto error; +} +/* Add module level attributes */ +if (PyModule_AddIntMacro(module, MINYEAR) < 0) { +goto error; +} +if (PyModule_AddIntMacro(module, MAXYEAR) < 0) { +goto error; +} +if (PyModule_AddObjectRef(module, "UTC", (PyObject *)&utc_timezone) < 0) { +goto error; +} +/* At last, set up and add the encapsulated C API */ +PyDateTime_CAPI *capi = get_datetime_capi(); +if (capi == NULL) { +goto error; +} +PyObject *capsule = PyCapsule_New(capi, PyDateTime_CAPSULE_NAME, NULL); +// (capsule == NULL) is handled by PyModule_Add +if (PyModule_Add(module, "datetime_CAPI", capsule) < 0) { +goto error; +} +/* A 4-year cycle has an extra leap day over what we'd get from +* pasting together 4 single years. +*/ +static_assert(DI4Y == 4 * 365 + 1, "DI4Y"); +assert(DI4Y == days_before_year(4+1)); +/* Similarly, a 400-year cycle has an extra leap day over what we'd +* get from pasting together 4 100-year cycles. +*/ +static_assert(DI400Y == 4 * DI100Y + 1, "DI400Y"); +assert(DI400Y == days_before_year(400+1)); +/* OTOH, a 100-year cycle has one fewer leap day than we'd get from +* pasting together 25 4-year cycles. +*/ +static_assert(DI100Y == 25 * DI4Y - 1, "DI100Y"); +assert(DI100Y == days_before_year(100+1)); +if (set_current_module(interp, module) < 0) { +goto error; +} +rc = 0; +goto finally; +error: +clear_state(st); +finally: +Py_XDECREF(old_module); +return rc; +} +static PyModuleDef_Slot module_slots[] = { +_Py_INTERNAL_ABI_SLOT, +{Py_mod_exec, _datetime_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL}, +}; +static int +module_traverse(PyObject *mod, visitproc visit, void *arg) +{ +datetime_state *st = get_module_state(mod); +traverse_state(st, visit, arg); +return 0; +} +static int +module_clear(PyObject *mod) +{ +datetime_state *st = get_module_state(mod); +clear_state(st); +PyInterpreterState *interp = PyInterpreterState_Get(); +clear_current_module(interp, mod); +// The runtime takes care of the static types for us. +// See _PyTypes_FiniExtTypes().. +return 0; +} +static void +module_free(void *mod) +{ +(void)module_clear((PyObject *)mod); +} +static PyModuleDef datetimemodule = { +.m_base = PyModuleDef_HEAD_INIT, +.m_name = "_datetime", +.m_doc = "Fast implementation of the datetime module.", +.m_size = sizeof(datetime_state), +.m_methods = module_methods, +.m_slots = module_slots, +.m_traverse = module_traverse, +.m_clear = module_clear, +.m_free = module_free, +}; +PyMODINIT_FUNC +PyInit__datetime(void) +{ +return PyModuleDef_Init(&datetimemodule); +} +/* --------------------------------------------------------------------------- +Some time zone algebra. For a datetime x, let +x.n = x stripped of its timezone -- its naive time. +x.o = x.utcoffset(), and assuming that doesn't raise an exception or +return None +x.d = x.dst(), and assuming that doesn't raise an exception or +return None +x.s = x's standard offset, x.o - x.d +Now some derived rules, where k is a duration (timedelta). +1. x.o = x.s + x.d +This follows from the definition of x.s. +2. If x and y have the same tzinfo member, x.s = y.s. +This is actually a requirement, an assumption we need to make about +sane tzinfo classes. +3. The naive UTC time corresponding to x is x.n - x.o. +This is again a requirement for a sane tzinfo class. +4. (x+k).s = x.s +This follows from #2, and that datimetimetz+timedelta preserves tzinfo. +5. (x+k).n = x.n + k +Again follows from how arithmetic is defined. +Now we can explain tz.fromutc(x). Let's assume it's an interesting case +(meaning that the various tzinfo methods exist, and don't blow up or return +None when called). +The function wants to return a datetime y with timezone tz, equivalent to x. +x is already in UTC. +By #3, we want +y.n - y.o = x.n [1] +The algorithm starts by attaching tz to x.n, and calling that y. So +x.n = y.n at the start. Then it wants to add a duration k to y, so that [1] +becomes true; in effect, we want to solve [2] for k: +(y+k).n - (y+k).o = x.n [2] +By #1, this is the same as +(y+k).n - ((y+k).s + (y+k).d) = x.n [3] +By #5, (y+k).n = y.n + k, which equals x.n + k because x.n=y.n at the start. +Substituting that into [3], +x.n + k - (y+k).s - (y+k).d = x.n; the x.n terms cancel, leaving +k - (y+k).s - (y+k).d = 0; rearranging, +k = (y+k).s - (y+k).d; by #4, (y+k).s == y.s, so +k = y.s - (y+k).d +On the RHS, (y+k).d can't be computed directly, but y.s can be, and we +approximate k by ignoring the (y+k).d term at first. Note that k can't be +very large, since all offset-returning methods return a duration of magnitude +less than 24 hours. For that reason, if y is firmly in std time, (y+k).d must +be 0, so ignoring it has no consequence then. +In any case, the new value is +z = y + y.s [4] +It's helpful to step back at look at [4] from a higher level: it's simply +mapping from UTC to tz's standard time. +At this point, if +z.n - z.o = x.n [5] +we have an equivalent time, and are almost done. The insecurity here is +at the start of daylight time. Picture US Eastern for concreteness. The wall +time jumps from 1:59 to 3:00, and wall hours of the form 2:MM don't make good +sense then. The docs ask that an Eastern tzinfo class consider such a time to +be EDT (because it's "after 2"), which is a redundant spelling of 1:MM EST +on the day DST starts. We want to return the 1:MM EST spelling because that's +the only spelling that makes sense on the local wall clock. +In fact, if [5] holds at this point, we do have the standard-time spelling, +but that takes a bit of proof. We first prove a stronger result. What's the +difference between the LHS and RHS of [5]? Let +diff = x.n - (z.n - z.o) [6] +Now +z.n = by [4] +(y + y.s).n = by #5 +y.n + y.s = since y.n = x.n +x.n + y.s = since z and y are have the same tzinfo member, +y.s = z.s by #2 +x.n + z.s +Plugging that back into [6] gives +diff = +x.n - ((x.n + z.s) - z.o) = expanding +x.n - x.n - z.s + z.o = cancelling +- z.s + z.o = by #2 +z.d +So diff = z.d. +If [5] is true now, diff = 0, so z.d = 0 too, and we have the standard-time +spelling we wanted in the endcase described above. We're done. Contrarily, +if z.d = 0, then we have a UTC equivalent, and are also done. +If [5] is not true now, diff = z.d != 0, and z.d is the offset we need to +add to z (in effect, z is in tz's standard time, and we need to shift the +local clock into tz's daylight time). +Let +z' = z + z.d = z + diff [7] +and we can again ask whether +z'.n - z'.o = x.n [8] +If so, we're done. If not, the tzinfo class is insane, according to the +assumptions we've made. This also requires a bit of proof. As before, let's +compute the difference between the LHS and RHS of [8] (and skipping some of +the justifications for the kinds of substitutions we've done several times +already): +diff' = x.n - (z'.n - z'.o) = replacing z'.n via [7] +x.n - (z.n + diff - z'.o) = replacing diff via [6] +x.n - (z.n + x.n - (z.n - z.o) - z'.o) = +x.n - z.n - x.n + z.n - z.o + z'.o = cancel x.n +- z.n + z.n - z.o + z'.o = cancel z.n +- z.o + z'.o = #1 twice +-z.s - z.d + z'.s + z'.d = z and z' have same tzinfo +z'.d - z.d +So z' is UTC-equivalent to x iff z'.d = z.d at this point. If they are equal, +we've found the UTC-equivalent so are done. In fact, we stop with [7] and +return z', not bothering to compute z'.d. +How could z.d and z'd differ? z' = z + z.d [7], so merely moving z' by +a dst() offset, and starting *from* a time already in DST (we know z.d != 0), +would have to change the result dst() returns: we start in DST, and moving +a little further into it takes us out of DST. +There isn't a sane case where this can happen. The closest it gets is at +the end of DST, where there's an hour in UTC with no spelling in a hybrid +tzinfo class. In US Eastern, that's 5:MM UTC = 0:MM EST = 1:MM EDT. During +that hour, on an Eastern clock 1:MM is taken as being in standard time (6:MM +UTC) because the docs insist on that, but 0:MM is taken as being in daylight +time (4:MM UTC). There is no local time mapping to 5:MM UTC. The local +clock jumps from 1:59 back to 1:00 again, and repeats the 1:MM hour in +standard time. Since that's what the local clock *does*, we want to map both +UTC hours 5:MM and 6:MM to 1:MM Eastern. The result is ambiguous +in local time, but so it goes -- it's the way the local clock works. +When x = 5:MM UTC is the input to this algorithm, x.o=0, y.o=-5 and y.d=0, +so z=0:MM. z.d=60 (minutes) then, so [5] doesn't hold and we keep going. +z' = z + z.d = 1:MM then, and z'.d=0, and z'.d - z.d = -60 != 0 so [8] +(correctly) concludes that z' is not UTC-equivalent to x. +Because we know z.d said z was in daylight time (else [5] would have held and +we would have stopped then), and we know z.d != z'.d (else [8] would have held +and we would have stopped then), and there are only 2 possible values dst() can +return in Eastern, it follows that z'.d must be 0 (which it is in the example, +but the reasoning doesn't depend on the example -- it depends on there being +two possible dst() outcomes, one zero and the other non-zero). Therefore +z' must be in standard time, and is the spelling we want in this case. +Note again that z' is not UTC-equivalent as far as the hybrid tzinfo class is +concerned (because it takes z' as being in standard time rather than the +daylight time we intend here), but returning it gives the real-life "local +clock repeats an hour" behavior when mapping the "unspellable" UTC hour into +tz. +When the input is 6:MM, z=1:MM and z.d=0, and we stop at once, again with +the 1:MM standard time spelling we want. +So how can this break? One of the assumptions must be violated. Two +possibilities: +1) [2] effectively says that y.s is invariant across all y belong to a given +time zone. This isn't true if, for political reasons or continental drift, +a region decides to change its base offset from UTC. +2) There may be versions of "double daylight" time where the tail end of +the analysis gives up a step too early. I haven't thought about that +enough to say. +In any case, it's clear that the default fromutc() is strong enough to handle +"almost all" time zones: so long as the standard offset is invariant, it +doesn't matter if daylight time transition points change from year to year, or +if daylight time is skipped in some years; it doesn't matter how large or +small dst() may get within its bounds; and it doesn't even matter if some +perverse time zone returns a negative dst()). So a breaking case must be +pretty bizarre, and a tzinfo subclass can override fromutc() if it is. +--------------------------------------------------------------------------- */ + +/* ------------------------------------------------------------------------ +unicodedata -- Provides access to the Unicode database. +The current version number is reported in the unidata_version constant. +Written by Marc-Andre Lemburg (mal@lemburg.com). +Modified for Python 2.0 by Fredrik Lundh (fredrik@pythonware.com) +Modified by Martin v. Löwis (martin@v.loewis.de) +Copyright (c) Corporation for National Research Initiatives. +------------------------------------------------------------------------ */ +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif +#include "Python.h" +#include "pycore_object.h" // _PyObject_VisitType() +#include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI +#include "pycore_unicodectype.h" // _PyUnicode_IsXidStart() +#include +#include // offsetof() +/* helper macro to fixup start/end slice values */ +#define ADJUST_INDICES(start, end, len) \ +do { \ +if (end > len) { \ +end = len; \ +} \ +else if (end < 0) { \ +end += len; \ +if (end < 0) { \ +end = 0; \ +} \ +} \ +if (start < 0) { \ +start += len; \ +if (start < 0) { \ +start = 0; \ +} \ +} \ +} while (0) +/*[clinic input] +module unicodedata +class unicodedata.UCD 'PreviousDBVersion *' '' +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=e47113e05924be43]*/ +/* character properties */ +typedef struct { +const unsigned char category; /* index into +_PyUnicode_CategoryNames */ +const unsigned char combining; /* combining class value 0 - 255 */ +const unsigned char bidirectional; /* index into +_PyUnicode_BidirectionalNames */ +const unsigned char mirrored; /* true if mirrored in bidir mode */ +const unsigned char east_asian_width; /* index into +_PyUnicode_EastAsianWidth */ +const unsigned char normalization_quick_check; /* see is_normalized() */ +const unsigned char grapheme_cluster_break; /* index into +_PyUnicode_GraphemeBreakNames */ +const unsigned char incb; /* index into +_PyUnicode_IndicConjunctBreakNames */ +const unsigned char ext_pict; /* true if Extended_Pictographic */ +} _PyUnicode_DatabaseRecord; +typedef struct change_record { +/* sequence of fields should be the same as in merge_old_version */ +const unsigned char bidir_changed; +const unsigned char category_changed; +const unsigned char decimal_changed; +const unsigned char mirrored_changed; +const unsigned char east_asian_width_changed; +const double numeric_changed; +} change_record; +/* data file generated by Tools/unicode/makeunicodedata.py */ +#include "unicodedata_db.h" +static const _PyUnicode_DatabaseRecord* +_getrecord_ex(Py_UCS4 code) +{ +int index; +if (code >= 0x110000) +index = 0; +else { +index = index1[(code>>SHIFT)]; +index = index2[(index<getrecord(v)) +static PyMemberDef DB_members[] = { +{"unidata_version", Py_T_STRING, offsetof(PreviousDBVersion, name), Py_READONLY}, +{NULL} +}; +// Check if self is an unicodedata.UCD instance. +// If self is NULL (when the PyCapsule C API is used), return 0. +// PyModule_Check() is used to avoid having to retrieve the ucd_type. +// See unicodedata_functions comment to the rationale of this macro. +#define UCD_Check(self) (self != NULL && !PyModule_Check(self)) +static PyObject* +new_previous_version(PyTypeObject *ucd_type, +const char*name, const change_record* (*getrecord)(Py_UCS4), +Py_UCS4 (*normalization)(Py_UCS4)) +{ +PreviousDBVersion *self; +self = PyObject_GC_New(PreviousDBVersion, ucd_type); +if (self == NULL) +return NULL; +self->name = name; +self->getrecord = getrecord; +self->normalization = normalization; +PyObject_GC_Track(self); +return (PyObject*)self; +} +/* --- Module API --------------------------------------------------------- */ +/*[clinic input] +unicodedata.UCD.decimal +self: self +chr: int(accept={str}) +default: object=NULL +/ +Converts a Unicode character into its equivalent decimal value. +Returns the decimal value assigned to the character chr as integer. +If no such value is defined, default is returned, or, if not given, +ValueError is raised. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_decimal_impl(PyObject *self, int chr, +PyObject *default_value) +/*[clinic end generated code: output=be23376e1a185231 input=933f8107993f23d0]*/ +{ +int have_old = 0; +long rc; +Py_UCS4 c = (Py_UCS4)chr; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) { +/* unassigned */ +have_old = 1; +rc = -1; +} +else if (old->decimal_changed != 0xFF) { +have_old = 1; +rc = old->decimal_changed; +} +} +if (!have_old) +rc = Py_UNICODE_TODECIMAL(c); +if (rc < 0) { +if (default_value == NULL) { +PyErr_SetString(PyExc_ValueError, +"not a decimal"); +return NULL; +} +else { +return Py_NewRef(default_value); +} +} +return PyLong_FromLong(rc); +} +/*[clinic input] +unicodedata.UCD.digit +self: self +chr: int(accept={str}) +default: object=NULL +/ +Converts a Unicode character into its equivalent digit value. +Returns the digit value assigned to the character chr as integer. +If no such value is defined, default is returned, or, if not given, +ValueError is raised. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_digit_impl(PyObject *self, int chr, PyObject *default_value) +/*[clinic end generated code: output=96e18c950171fd2f input=e27d6e4565cd29f2]*/ +{ +long rc; +Py_UCS4 c = (Py_UCS4)chr; +rc = Py_UNICODE_TODIGIT(c); +if (rc < 0) { +if (default_value == NULL) { +PyErr_SetString(PyExc_ValueError, "not a digit"); +return NULL; +} +else { +return Py_NewRef(default_value); +} +} +return PyLong_FromLong(rc); +} +/*[clinic input] +unicodedata.UCD.numeric +self: self +chr: int(accept={str}) +default: object=NULL +/ +Converts a Unicode character into its equivalent numeric value. +Returns the numeric value assigned to the character chr as float. +If no such value is defined, default is returned, or, if not given, +ValueError is raised. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_numeric_impl(PyObject *self, int chr, +PyObject *default_value) +/*[clinic end generated code: output=53ce281fe85b10c4 input=fdf5871a5542893c]*/ +{ +int have_old = 0; +double rc; +Py_UCS4 c = (Py_UCS4)chr; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) { +/* unassigned */ +have_old = 1; +rc = -1.0; +} +else if (old->decimal_changed != 0xFF) { +have_old = 1; +rc = old->decimal_changed; +} +} +if (!have_old) +rc = Py_UNICODE_TONUMERIC(c); +if (rc == -1.0) { +if (default_value == NULL) { +PyErr_SetString(PyExc_ValueError, "not a numeric character"); +return NULL; +} +else { +return Py_NewRef(default_value); +} +} +return PyFloat_FromDouble(rc); +} +/*[clinic input] +unicodedata.UCD.category +self: self +chr: int(accept={str}) +/ +Returns the general category assigned to the character chr as string. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_category_impl(PyObject *self, int chr) +/*[clinic end generated code: output=8571539ee2e6783a input=27d6f3d85050bc06]*/ +{ +int index; +Py_UCS4 c = (Py_UCS4)chr; +index = (int) _getrecord_ex(c)->category; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed != 0xFF) +index = old->category_changed; +} +return PyUnicode_FromString(_PyUnicode_CategoryNames[index]); +} +/*[clinic input] +unicodedata.UCD.bidirectional +self: self +chr: int(accept={str}) +/ +Returns the bidirectional class assigned to the character chr as string. +If no such value is defined, an empty string is returned. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_bidirectional_impl(PyObject *self, int chr) +/*[clinic end generated code: output=d36310ce2039bb92 input=b3d8f42cebfcf475]*/ +{ +int index; +Py_UCS4 c = (Py_UCS4)chr; +index = (int) _getrecord_ex(c)->bidirectional; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) +index = 0; /* unassigned */ +else if (old->bidir_changed != 0xFF) +index = old->bidir_changed; +} +return PyUnicode_FromString(_PyUnicode_BidirectionalNames[index]); +} +/*[clinic input] +@permit_long_summary +unicodedata.UCD.combining -> int +self: self +chr: int(accept={str}) +/ +Returns the canonical combining class assigned to the character chr as integer. +Returns 0 if no combining class is defined. +[clinic start generated code]*/ +static int +unicodedata_UCD_combining_impl(PyObject *self, int chr) +/*[clinic end generated code: output=cad056d0cb6a5920 input=e05edfbb882ebfed]*/ +{ +int index; +Py_UCS4 c = (Py_UCS4)chr; +index = (int) _getrecord_ex(c)->combining; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) +index = 0; /* unassigned */ +} +return index; +} +/*[clinic input] +unicodedata.UCD.mirrored -> int +self: self +chr: int(accept={str}) +/ +Returns the mirrored property assigned to the character chr as integer. +Returns 1 if the character has been identified as a "mirrored" +character in bidirectional text, 0 otherwise. +[clinic start generated code]*/ +static int +unicodedata_UCD_mirrored_impl(PyObject *self, int chr) +/*[clinic end generated code: output=2532dbf8121b50e6 input=5dd400d351ae6f3b]*/ +{ +int index; +Py_UCS4 c = (Py_UCS4)chr; +index = (int) _getrecord_ex(c)->mirrored; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) +index = 0; /* unassigned */ +else if (old->mirrored_changed != 0xFF) +index = old->mirrored_changed; +} +return index; +} +/*[clinic input] +unicodedata.UCD.east_asian_width +self: self +chr: int(accept={str}) +/ +Returns the east asian width assigned to the character chr as string. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_east_asian_width_impl(PyObject *self, int chr) +/*[clinic end generated code: output=484e8537d9ee8197 input=c4854798aab026e0]*/ +{ +int index; +Py_UCS4 c = (Py_UCS4)chr; +index = (int) _getrecord_ex(c)->east_asian_width; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) +index = 0; /* unassigned */ +else if (old->east_asian_width_changed != 0xFF) +index = old->east_asian_width_changed; +} +return PyUnicode_FromString(_PyUnicode_EastAsianWidthNames[index]); +} +/*[clinic input] +@permit_long_summary +unicodedata.UCD.decomposition +self: self +chr: int(accept={str}) +/ +Returns the character decomposition mapping assigned to the character chr as string. +An empty string is returned in case no such mapping is defined. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_decomposition_impl(PyObject *self, int chr) +/*[clinic end generated code: output=7d699f3ec7565d27 input=84d628d1abfd01ec]*/ +{ +char decomp[256]; +int code, index, count; +size_t i; +unsigned int prefix_index; +Py_UCS4 c = (Py_UCS4)chr; +code = (int)c; +if (UCD_Check(self)) { +const change_record *old = get_old_record(self, c); +if (old->category_changed == 0) +return Py_GetConstant(Py_CONSTANT_EMPTY_STR); /* unassigned */ +} +if (code < 0 || code >= 0x110000) +index = 0; +else { +index = decomp_index1[(code>>DECOMP_SHIFT)]; +index = decomp_index2[(index<> 8; +/* XXX: could allocate the PyString up front instead +(strlen(prefix) + 5 * count + 1 bytes) */ +/* Based on how index is calculated above and decomp_data is generated +from Tools/unicode/makeunicodedata.py, it should not be possible +to overflow decomp_prefix. */ +prefix_index = decomp_data[index] & 255; +assert(prefix_index < Py_ARRAY_LENGTH(decomp_prefix)); +/* copy prefix */ +i = strlen(decomp_prefix[prefix_index]); +memcpy(decomp, decomp_prefix[prefix_index], i); +while (count-- > 0) { +if (i) +decomp[i++] = ' '; +assert(i < sizeof(decomp)); +PyOS_snprintf(decomp + i, sizeof(decomp) - i, "%04X", +decomp_data[++index]); +i += strlen(decomp + i); +} +return PyUnicode_FromStringAndSize(decomp, i); +} +static void +get_decomp_record(PyObject *self, Py_UCS4 code, +int *index, int *prefix, int *count) +{ +if (code >= 0x110000) { +*index = 0; +} +else if (UCD_Check(self) +&& get_old_record(self, code)->category_changed==0) { +/* unassigned in old version */ +*index = 0; +} +else { +*index = decomp_index1[(code>>DECOMP_SHIFT)]; +*index = decomp_index2[(*index<> 8; +*prefix = decomp_data[*index] & 255; +(*index)++; +} +#define SBase 0xAC00 +#define LBase 0x1100 +#define VBase 0x1161 +#define TBase 0x11A7 +#define LCount 19 +#define VCount 21 +#define TCount 28 +#define NCount (VCount*TCount) +#define SCount (LCount*NCount) +static PyObject* +nfd_nfkd(PyObject *self, PyObject *input, int k) +{ +PyObject *result; +Py_UCS4 *output; +Py_ssize_t i, o, osize; +int kind; +const void *data; +/* Longest decomposition in Unicode 3.2: U+FDFA */ +Py_UCS4 stack[20]; +Py_ssize_t space, isize; +int index, prefix, count, stackptr; +unsigned char prev, cur; +stackptr = 0; +isize = PyUnicode_GET_LENGTH(input); +space = isize; +/* Overallocate at most 10 characters. */ +if (space > 10) { +if (space <= PY_SSIZE_T_MAX - 10) +space += 10; +} +else { +space *= 2; +} +osize = space; +output = PyMem_NEW(Py_UCS4, space); +if (!output) { +PyErr_NoMemory(); +return NULL; +} +i = o = 0; +kind = PyUnicode_KIND(input); +data = PyUnicode_DATA(input); +while (i < isize) { +stack[stackptr++] = PyUnicode_READ(kind, data, i++); +while(stackptr) { +Py_UCS4 code = stack[--stackptr]; +/* Hangul Decomposition adds three characters in +a single step, so we need at least that much room. */ +if (space < 3) { +Py_UCS4 *new_output; +osize += 10; +space += 10; +new_output = PyMem_Realloc(output, osize*sizeof(Py_UCS4)); +if (new_output == NULL) { +PyMem_Free(output); +PyErr_NoMemory(); +return NULL; +} +output = new_output; +} +/* Hangul Decomposition. */ +if (SBase <= code && code < (SBase+SCount)) { +int SIndex = code - SBase; +int L = LBase + SIndex / NCount; +int V = VBase + (SIndex % NCount) / TCount; +int T = TBase + SIndex % TCount; +output[o++] = L; +output[o++] = V; +space -= 2; +if (T != TBase) { +output[o++] = T; +space --; +} +continue; +} +/* normalization changes */ +if (UCD_Check(self)) { +Py_UCS4 value = ((PreviousDBVersion*)self)->normalization(code); +if (value != 0) { +stack[stackptr++] = value; +continue; +} +} +/* Other decompositions. */ +get_decomp_record(self, code, &index, &prefix, &count); +/* Copy character if it is not decomposable, or has a +compatibility decomposition, but we do NFD. */ +if (!count || (prefix && !k)) { +output[o++] = code; +space--; +continue; +} +/* Copy decomposition onto the stack, in reverse +order. */ +while(count) { +code = decomp_data[index + (--count)]; +stack[stackptr++] = code; +} +} +} +result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, +output, o); +PyMem_Free(output); +if (!result) +return NULL; +kind = PyUnicode_KIND(result); +data = PyUnicode_DATA(result); +/* Sort canonically. */ +i = 0; +prev = _getrecord_ex(PyUnicode_READ(kind, data, i))->combining; +for (i++; i < PyUnicode_GET_LENGTH(result); i++) { +cur = _getrecord_ex(PyUnicode_READ(kind, data, i))->combining; +if (prev == 0 || cur == 0 || prev <= cur) { +prev = cur; +continue; +} +/* Non-canonical order. Need to switch *i with previous. */ +o = i - 1; +while (1) { +Py_UCS4 tmp = PyUnicode_READ(kind, data, o+1); +PyUnicode_WRITE(kind, data, o+1, +PyUnicode_READ(kind, data, o)); +PyUnicode_WRITE(kind, data, o, tmp); +o--; +if (o < 0) +break; +prev = _getrecord_ex(PyUnicode_READ(kind, data, o))->combining; +if (prev == 0 || prev <= cur) +break; +} +prev = _getrecord_ex(PyUnicode_READ(kind, data, i))->combining; +} +return result; +} +static int +find_nfc_index(const struct reindex* nfc, Py_UCS4 code) +{ +unsigned int index; +for (index = 0; nfc[index].start; index++) { +unsigned int start = nfc[index].start; +if (code < start) +return -1; +if (code <= start + nfc[index].count) { +unsigned int delta = code - start; +return nfc[index].index + delta; +} +} +return -1; +} +static PyObject* +nfc_nfkc(PyObject *self, PyObject *input, int k) +{ +PyObject *result; +int kind; +const void *data; +Py_UCS4 *output; +Py_ssize_t i, i1, o, len; +int f,l,index,index1,comb; +Py_UCS4 code; +Py_ssize_t skipped[20]; +int cskipped = 0; +result = nfd_nfkd(self, input, k); +if (!result) +return NULL; +kind = PyUnicode_KIND(result); +data = PyUnicode_DATA(result); +len = PyUnicode_GET_LENGTH(result); +/* We allocate a buffer for the output. +If we find that we made no changes, we still return +the NFD result. */ +output = PyMem_NEW(Py_UCS4, len); +if (!output) { +PyErr_NoMemory(); +Py_DECREF(result); +return 0; +} +i = o = 0; +again: +while (i < len) { +for (index = 0; index < cskipped; index++) { +if (skipped[index] == i) { +/* *i character is skipped. +Remove from list. */ +skipped[index] = skipped[cskipped-1]; +cskipped--; +i++; +goto again; /* continue while */ +} +} +/* Hangul Composition. We don't need to check for +pairs, since we always have decomposed data. */ +code = PyUnicode_READ(kind, data, i); +if (LBase <= code && code < (LBase+LCount) && +i + 1 < len && +VBase <= PyUnicode_READ(kind, data, i+1) && +PyUnicode_READ(kind, data, i+1) < (VBase+VCount)) { +/* check L character is a modern leading consonant (0x1100 ~ 0x1112) +and V character is a modern vowel (0x1161 ~ 0x1175). */ +int LIndex, VIndex; +LIndex = code - LBase; +VIndex = PyUnicode_READ(kind, data, i+1) - VBase; +code = SBase + (LIndex*VCount+VIndex)*TCount; +i+=2; +if (i < len && +TBase < PyUnicode_READ(kind, data, i) && +PyUnicode_READ(kind, data, i) < (TBase+TCount)) { +/* check T character is a modern trailing consonant +(0x11A8 ~ 0x11C2). */ +code += PyUnicode_READ(kind, data, i)-TBase; +i++; +} +output[o++] = code; +continue; +} +/* code is still input[i] here */ +f = find_nfc_index(nfc_first, code); +if (f == -1) { +output[o++] = code; +i++; +continue; +} +/* Find next unblocked character. */ +i1 = i+1; +comb = 0; +/* output base character for now; might be updated later. */ +output[o] = PyUnicode_READ(kind, data, i); +while (i1 < len) { +Py_UCS4 code1 = PyUnicode_READ(kind, data, i1); +int comb1 = _getrecord_ex(code1)->combining; +if (comb) { +if (comb1 == 0) +break; +if (comb >= comb1) { +/* Character is blocked. */ +i1++; +continue; +} +} +l = find_nfc_index(nfc_last, code1); +/* i1 cannot be combined with i. If i1 +is a starter, we don't need to look further. +Otherwise, record the combining class. */ +if (l == -1) { +not_combinable: +if (comb1 == 0) +break; +comb = comb1; +i1++; +continue; +} +index = f*TOTAL_LAST + l; +index1 = comp_index[index >> COMP_SHIFT]; +code = comp_data[(index1<combining; +if (combining && prev_combining > combining) +return NO; /* non-canonical sort order, not normalized */ +prev_combining = combining; +unsigned char quickcheck_whole = record->normalization_quick_check; +if (yes_only) { +if (quickcheck_whole & (3 << quickcheck_shift)) +return MAYBE; +} else { +switch ((quickcheck_whole >> quickcheck_shift) & 3) { +case NO: +return NO; +case MAYBE: +result = MAYBE; /* this string might need normalization */ +} +} +} +return result; +} +/*[clinic input] +unicodedata.UCD.is_normalized +self: self +form: unicode +unistr as input: unicode +/ +Return whether the Unicode string unistr is in the normal form 'form'. +Valid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_is_normalized_impl(PyObject *self, PyObject *form, +PyObject *input) +/*[clinic end generated code: output=11e5a3694e723ca5 input=a544f14cea79e508]*/ +{ +if (PyUnicode_GET_LENGTH(input) == 0) { +/* special case empty input strings. */ +Py_RETURN_TRUE; +} +PyObject *result; +bool nfc = false; +bool k = false; +QuickcheckResult m; +PyObject *cmp; +int match = 0; +if (PyUnicode_CompareWithASCIIString(form, "NFC") == 0) { +nfc = true; +} +else if (PyUnicode_CompareWithASCIIString(form, "NFKC") == 0) { +nfc = true; +k = true; +} +else if (PyUnicode_CompareWithASCIIString(form, "NFD") == 0) { +/* matches default values for `nfc` and `k` */ +} +else if (PyUnicode_CompareWithASCIIString(form, "NFKD") == 0) { +k = true; +} +else { +PyErr_SetString(PyExc_ValueError, "invalid normalization form"); +return NULL; +} +m = is_normalized_quickcheck(self, input, nfc, k, false); +if (m == MAYBE) { +cmp = (nfc ? nfc_nfkc : nfd_nfkd)(self, input, k); +if (cmp == NULL) { +return NULL; +} +match = PyUnicode_Compare(input, cmp); +Py_DECREF(cmp); +result = (match == 0) ? Py_True : Py_False; +} +else { +result = (m == YES) ? Py_True : Py_False; +} +return Py_NewRef(result); +} +/*[clinic input] +unicodedata.UCD.normalize +self: self +form: unicode +unistr as input: unicode +/ +Return the normal form 'form' for the Unicode string unistr. +Valid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_normalize_impl(PyObject *self, PyObject *form, +PyObject *input) +/*[clinic end generated code: output=05ca4385a2ad6983 input=3a5206c0ad2833fb]*/ +{ +if (PyUnicode_GET_LENGTH(input) == 0) { +/* Special case empty input strings, since resizing +them later would cause internal errors. */ +return PyUnicode_FromObject(input); +} +if (PyUnicode_CompareWithASCIIString(form, "NFC") == 0) { +if (is_normalized_quickcheck(self, input, +true, false, true) == YES) { +return PyUnicode_FromObject(input); +} +return nfc_nfkc(self, input, 0); +} +if (PyUnicode_CompareWithASCIIString(form, "NFKC") == 0) { +if (is_normalized_quickcheck(self, input, +true, true, true) == YES) { +return PyUnicode_FromObject(input); +} +return nfc_nfkc(self, input, 1); +} +if (PyUnicode_CompareWithASCIIString(form, "NFD") == 0) { +if (is_normalized_quickcheck(self, input, +false, false, true) == YES) { +return PyUnicode_FromObject(input); +} +return nfd_nfkd(self, input, 0); +} +if (PyUnicode_CompareWithASCIIString(form, "NFKD") == 0) { +if (is_normalized_quickcheck(self, input, +false, true, true) == YES) { +return PyUnicode_FromObject(input); +} +return nfd_nfkd(self, input, 1); +} +PyErr_SetString(PyExc_ValueError, "invalid normalization form"); +return NULL; +} +/* -------------------------------------------------------------------- */ +/* unicode character name tables */ +/* data file generated by Tools/unicode/makeunicodedata.py */ +#include "unicodename_db.h" +/* -------------------------------------------------------------------- */ +/* database code (cut and pasted from the unidb package) */ +static const char * const hangul_syllables[][3] = { +{ "G", "A", "" }, +{ "GG", "AE", "G" }, +{ "N", "YA", "GG" }, +{ "D", "YAE", "GS" }, +{ "DD", "EO", "N", }, +{ "R", "E", "NJ" }, +{ "M", "YEO", "NH" }, +{ "B", "YE", "D" }, +{ "BB", "O", "L" }, +{ "S", "WA", "LG" }, +{ "SS", "WAE", "LM" }, +{ "", "OE", "LB" }, +{ "J", "YO", "LS" }, +{ "JJ", "U", "LT" }, +{ "C", "WEO", "LP" }, +{ "K", "WE", "LH" }, +{ "T", "WI", "M" }, +{ "P", "YU", "B" }, +{ "H", "EU", "BS" }, +{ 0, "YI", "S" }, +{ 0, "I", "SS" }, +{ 0, 0, "NG" }, +{ 0, 0, "J" }, +{ 0, 0, "C" }, +{ 0, 0, "K" }, +{ 0, 0, "T" }, +{ 0, 0, "P" }, +{ 0, 0, "H" } +}; +/* These ranges need to match makeunicodedata.py:cjk_ranges. */ +static int +is_unified_ideograph(Py_UCS4 code) +{ +return +(0x3400 <= code && code <= 0x4DBF) || /* CJK Ideograph Extension A */ +(0x4E00 <= code && code <= 0x9FFF) || /* CJK Ideograph */ +(0x20000 <= code && code <= 0x2A6DF) || /* CJK Ideograph Extension B */ +(0x2A700 <= code && code <= 0x2B73F) || /* CJK Ideograph Extension C */ +(0x2B740 <= code && code <= 0x2B81D) || /* CJK Ideograph Extension D */ +(0x2B820 <= code && code <= 0x2CEAD) || /* CJK Ideograph Extension E */ +(0x2CEB0 <= code && code <= 0x2EBE0) || /* CJK Ideograph Extension F */ +(0x2EBF0 <= code && code <= 0x2EE5D) || /* CJK Ideograph Extension I */ +(0x30000 <= code && code <= 0x3134A) || /* CJK Ideograph Extension G */ +(0x31350 <= code && code <= 0x323AF) || /* CJK Ideograph Extension H */ +(0x323B0 <= code && code <= 0x33479); /* CJK Ideograph Extension J */ +} +/* macros used to determine if the given code point is in the PUA range that +* we are using to store aliases and named sequences */ +#define IS_ALIAS(cp) ((cp >= aliases_start) && (cp < aliases_end)) +#define IS_NAMED_SEQ(cp) ((cp >= named_sequences_start) && \ +(cp < named_sequences_end)) +// DAWG decoding functions +static unsigned int +_dawg_decode_varint_unsigned(unsigned int index, unsigned int* result) +{ +unsigned int res = 0; +unsigned int shift = 0; +for (;;) { +unsigned char byte = packed_name_dawg[index]; +res |= (byte & 0x7f) << shift; +index++; +shift += 7; +if (!(byte & 0x80)) { +*result = res; +return index; +} +} +} +static int +_dawg_match_edge(const char* name, unsigned int namelen, unsigned int size, +unsigned int label_offset, unsigned int namepos) +{ +// This returns 1 if the edge matched, 0 if it didn't (but further edges +// could match) and -1 if the name cannot match at all. +if (size > 1 && namepos + size > namelen) { +return 0; +} +for (unsigned int i = 0; i < size; i++) { +if (packed_name_dawg[label_offset + i] != Py_TOUPPER(name[namepos + i])) { +if (i > 0) { +return -1; // cannot match at all +} +return 0; +} +} +return 1; +} +// reading DAWG node information: +// a node is encoded by a varint. The lowest bit of that int is set if the node +// is a final, accepting state. The higher bits of that int represent the +// number of names that are encoded by the sub-DAWG started by this node. It's +// used to compute the position of a name. +// +// the starting node of the DAWG is at position 0. +// +// the varint representing a node is followed by the node's edges, the encoding +// is described below +static unsigned int +_dawg_decode_node(unsigned int node_offset, bool* final) +{ +unsigned int num; +node_offset = _dawg_decode_varint_unsigned(node_offset, &num); +*final = num & 1; +return node_offset; +} +static bool +_dawg_node_is_final(unsigned int node_offset) +{ +unsigned int num; +_dawg_decode_varint_unsigned(node_offset, &num); +return num & 1; +} +static unsigned int +_dawg_node_descendant_count(unsigned int node_offset) +{ +unsigned int num; +_dawg_decode_varint_unsigned(node_offset, &num); +return num >> 1; +} +// reading DAWG edge information: +// a DAWG edge is comprised of the following information: +// (1) the size of the label of the string attached to the edge +// (2) the characters of that edge +// (3) the target node +// (4) whether the edge is the last edge in the list of edges following a node +// +// this information is encoded in a compact form as follows: +// +// +---------+-----------------+--------------+-------------------- +// | varint | size (if != 1) | label chars | ... next edge ... +// +---------+-----------------+--------------+-------------------- +// +// - first comes a varint +// - the lowest bit of that varint is whether the edge is final (4) +// - the second lowest bit of that varint is true if the size of +// the length of the label is 1 (1) +// - the rest of the varint is an offset that can be used to compute +// the offset of the target node of that edge (3) +// - if the size is not 1, the first varint is followed by a +// character encoding the number of characters of the label (1) +// (unicode character names aren't larger than 256 bytes, therefore each +// edge label can be at most 256 chars, but is usually smaller) +// - the next size bytes are the characters of the label (2) +// +// the offset of the target node is computed as follows: the number in the +// upper bits of the varint needs to be added to the offset of the target node +// of the previous edge. For the first edge, where there is no previous target +// node, the offset of the first edge is used. +// The intuition here is that edges going out from a node often lead to nodes +// that are close by, leading to small offsets from the current node and thus +// fewer bytes. +// +// There is a special case: if a final node has no outgoing edges, it has to be +// followed by a 0 byte to indicate that there are no edges (because the end of +// the edge list is normally indicated in a bit in the edge encoding). This is +// indicated by _dawg_decode_edge returning -1 +static int +_dawg_decode_edge(bool is_first_edge, unsigned int prev_target_node_offset, +unsigned int edge_offset, unsigned int* size, +unsigned int* label_offset, unsigned int* target_node_offset) +{ +unsigned int num; +edge_offset = _dawg_decode_varint_unsigned(edge_offset, &num); +if (num == 0 && is_first_edge) { +return -1; // trying to decode past a final node without outgoing edges +} +bool last_edge = num & 1; +num >>= 1; +bool len_is_one = num & 1; +num >>= 1; +*target_node_offset = prev_target_node_offset + num; +if (len_is_one) { +*size = 1; +} else { +*size = packed_name_dawg[edge_offset++]; +} +*label_offset = edge_offset; +return last_edge; +} +static int +_lookup_dawg_packed(const char* name, unsigned int namelen) +{ +unsigned int stringpos = 0; +unsigned int node_offset = 0; +unsigned int result = 0; // this is the number of final nodes that we skipped to match name +while (stringpos < namelen) { +bool final; +unsigned int edge_offset = _dawg_decode_node(node_offset, &final); +unsigned int prev_target_node_offset = edge_offset; +bool is_first_edge = true; +for (;;) { +unsigned int size; +unsigned int label_offset, target_node_offset; +int last_edge = _dawg_decode_edge( +is_first_edge, prev_target_node_offset, edge_offset, +&size, &label_offset, &target_node_offset); +if (last_edge == -1) { +return -1; +} +is_first_edge = false; +prev_target_node_offset = target_node_offset; +int matched = _dawg_match_edge(name, namelen, size, label_offset, stringpos); +if (matched == -1) { +return -1; +} +if (matched) { +if (final) +result += 1; +stringpos += size; +node_offset = target_node_offset; +break; +} +if (last_edge) { +return -1; +} +result += _dawg_node_descendant_count(target_node_offset); +edge_offset = label_offset + size; +} +} +if (_dawg_node_is_final(node_offset)) { +return result; +} +return -1; +} +static int +_inverse_dawg_lookup(char* buffer, unsigned int buflen, unsigned int pos) +{ +unsigned int node_offset = 0; +unsigned int bufpos = 0; +for (;;) { +bool final; +unsigned int edge_offset = _dawg_decode_node(node_offset, &final); +if (final) { +if (pos == 0) { +if (bufpos + 1 == buflen) { +return 0; +} +buffer[bufpos] = '\0'; +return 1; +} +pos--; +} +unsigned int prev_target_node_offset = edge_offset; +bool is_first_edge = true; +for (;;) { +unsigned int size; +unsigned int label_offset, target_node_offset; +int last_edge = _dawg_decode_edge( +is_first_edge, prev_target_node_offset, edge_offset, +&size, &label_offset, &target_node_offset); +if (last_edge == -1) { +return 0; +} +is_first_edge = false; +prev_target_node_offset = target_node_offset; +unsigned int descendant_count = _dawg_node_descendant_count(target_node_offset); +if (pos < descendant_count) { +if (bufpos + size >= buflen) { +return 0; // buffer overflow +} +for (unsigned int i = 0; i < size; i++) { +buffer[bufpos++] = packed_name_dawg[label_offset++]; +} +node_offset = target_node_offset; +break; +} else if (!last_edge) { +pos -= descendant_count; +edge_offset = label_offset + size; +} else { +return 0; +} +} +} +} +static int +_getucname(PyObject *self, +Py_UCS4 code, char* buffer, int buflen, int with_alias_and_seq) +{ +/* Find the name associated with the given code point. +* If with_alias_and_seq is 1, check for names in the Private Use Area 15 +* that we are using for aliases and named sequences. */ +int offset; +if (code >= 0x110000) +return 0; +/* XXX should we just skip all the code points in the PUAs here? */ +if (!with_alias_and_seq && (IS_ALIAS(code) || IS_NAMED_SEQ(code))) +return 0; +if (UCD_Check(self)) { +/* in 3.2.0 there are no aliases and named sequences */ +const change_record *old; +if (IS_ALIAS(code) || IS_NAMED_SEQ(code)) +return 0; +old = get_old_record(self, code); +if (old->category_changed == 0) { +/* unassigned */ +return 0; +} +} +if (SBase <= code && code < SBase+SCount) { +/* Hangul syllable. */ +int SIndex = code - SBase; +int L = SIndex / NCount; +int V = (SIndex % NCount) / TCount; +int T = SIndex % TCount; +if (buflen < 27) +/* Worst case: HANGUL SYLLABLE <10chars>. */ +return 0; +strcpy(buffer, "HANGUL SYLLABLE "); +buffer += 16; +strcpy(buffer, hangul_syllables[L][0]); +buffer += strlen(hangul_syllables[L][0]); +strcpy(buffer, hangul_syllables[V][1]); +buffer += strlen(hangul_syllables[V][1]); +strcpy(buffer, hangul_syllables[T][2]); +buffer += strlen(hangul_syllables[T][2]); +*buffer = '\0'; +return 1; +} +if (is_unified_ideograph(code)) { +if (buflen < 28) +/* Worst case: CJK UNIFIED IDEOGRAPH-20000 */ +return 0; +sprintf(buffer, "CJK UNIFIED IDEOGRAPH-%X", code); +return 1; +} +/* get position of codepoint in order of names in the dawg */ +offset = dawg_codepoint_to_pos_index1[(code>>DAWG_CODEPOINT_TO_POS_SHIFT)]; +offset = dawg_codepoint_to_pos_index2[(offset<= 0); +return _inverse_dawg_lookup(buffer, Py_SAFE_DOWNCAST(buflen, int, unsigned int), offset); +} +static int +capi_getucname(Py_UCS4 code, +char* buffer, int buflen, +int with_alias_and_seq) +{ +return _getucname(NULL, code, buffer, buflen, with_alias_and_seq); +} +static void +find_syllable(const char *str, int *len, int *pos, int count, int column) +{ +int i, len1; +*len = -1; +for (i = 0; i < count; i++) { +const char *s = hangul_syllables[i][column]; +len1 = Py_SAFE_DOWNCAST(strlen(s), size_t, int); +if (len1 <= *len) +continue; +if (strncmp(str, s, len1) == 0) { +*len = len1; +*pos = i; +} +} +if (*len == -1) { +*len = 0; +} +} +static int +_check_alias_and_seq(Py_UCS4* code, int with_named_seq) +{ +/* check if named sequences are allowed */ +if (!with_named_seq && IS_NAMED_SEQ(*code)) +return 0; +/* if the code point is in the PUA range that we use for aliases, +* convert it to obtain the right code point */ +if (IS_ALIAS(*code)) +*code = name_aliases[*code-aliases_start]; +return 1; +} +static int +_getcode(const char* name, int namelen, Py_UCS4* code) +{ +/* Return the code point associated with the given name. +* Named aliases are not resolved, they are returned as a code point in the +* PUA */ +/* Check for hangul syllables. */ +if (strncmp(name, "HANGUL SYLLABLE ", 16) == 0) { +int len, L = -1, V = -1, T = -1; +const char *pos = name + 16; +find_syllable(pos, &len, &L, LCount, 0); +pos += len; +find_syllable(pos, &len, &V, VCount, 1); +pos += len; +find_syllable(pos, &len, &T, TCount, 2); +pos += len; +if (L != -1 && V != -1 && T != -1 && pos-name == namelen) { +*code = SBase + (L*VCount+V)*TCount + T; +return 1; +} +/* Otherwise, it's an illegal syllable name. */ +return 0; +} +/* Check for unified ideographs. */ +if (strncmp(name, "CJK UNIFIED IDEOGRAPH-", 22) == 0) { +/* Four or five hexdigits must follow. */ +unsigned int v; +v = 0; +name += 22; +namelen -= 22; +if (namelen != 4 && namelen != 5) +return 0; +while (namelen--) { +v *= 16; +if (*name >= '0' && *name <= '9') +v += *name - '0'; +else if (*name >= 'A' && *name <= 'F') +v += *name - 'A' + 10; +else +return 0; +name++; +} +if (!is_unified_ideograph(v)) +return 0; +*code = v; +return 1; +} +assert(namelen >= 0); +int position = _lookup_dawg_packed(name, Py_SAFE_DOWNCAST(namelen, int, unsigned int)); +if (position < 0) { +return 0; +} +*code = dawg_pos_to_codepoint[position]; +return 1; +} +static int +capi_getcode(const char* name, int namelen, Py_UCS4* code, +int with_named_seq) +{ +if (!_getcode(name, namelen, code)) { +return 0; +} +return _check_alias_and_seq(code, with_named_seq); +} +static void +unicodedata_destroy_capi(PyObject *capsule) +{ +void *capi = PyCapsule_GetPointer(capsule, PyUnicodeData_CAPSULE_NAME); +PyMem_Free(capi); +} +static PyObject * +unicodedata_create_capi(void) +{ +_PyUnicode_Name_CAPI *capi = PyMem_Malloc(sizeof(_PyUnicode_Name_CAPI)); +if (capi == NULL) { +PyErr_NoMemory(); +return NULL; +} +capi->getname = capi_getucname; +capi->getcode = capi_getcode; +PyObject *capsule = PyCapsule_New(capi, +PyUnicodeData_CAPSULE_NAME, +unicodedata_destroy_capi); +if (capsule == NULL) { +PyMem_Free(capi); +} +return capsule; +}; +/* -------------------------------------------------------------------- */ +/* Python bindings */ +/*[clinic input] +unicodedata.UCD.name +self: self +chr: int(accept={str}) +default: object=NULL +/ +Returns the name assigned to the character chr as a string. +If no name is defined, default is returned, or, if not given, +ValueError is raised. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_name_impl(PyObject *self, int chr, PyObject *default_value) +/*[clinic end generated code: output=6bbb37a326407707 input=3e0367f534de56d9]*/ +{ +char name[NAME_MAXLEN+1]; +Py_UCS4 c = (Py_UCS4)chr; +if (!_getucname(self, c, name, NAME_MAXLEN, 0)) { +if (default_value == NULL) { +PyErr_SetString(PyExc_ValueError, "no such name"); +return NULL; +} +else { +return Py_NewRef(default_value); +} +} +return PyUnicode_FromString(name); +} +/*[clinic input] +unicodedata.isxidstart +chr: int(accept={str}) +/ +Return True if the character has the XID_Start property, else False. +[clinic start generated code]*/ +static PyObject * +unicodedata_isxidstart_impl(PyObject *module, int chr) +/*[clinic end generated code: output=7ae0e1a3915aa031 input=3812717f3a6bfc56]*/ +{ +return PyBool_FromLong(_PyUnicode_IsXidStart(chr)); +} +/*[clinic input] +unicodedata.isxidcontinue +chr: int(accept={str}) +/ +Return True if the character has the XID_Continue property, else False. +[clinic start generated code]*/ +static PyObject * +unicodedata_isxidcontinue_impl(PyObject *module, int chr) +/*[clinic end generated code: output=517caa8b38c73aed input=a971ed6e57cac374]*/ +{ +return PyBool_FromLong(_PyUnicode_IsXidContinue(chr)); +} +/*[clinic input] +unicodedata.UCD.lookup +self: self +name: str(accept={str, robuffer}, zeroes=True) +/ +Look up character by name. +If a character with the given name is found, return the +corresponding character. If not found, KeyError is raised. +[clinic start generated code]*/ +static PyObject * +unicodedata_UCD_lookup_impl(PyObject *self, const char *name, +Py_ssize_t name_length) +/*[clinic end generated code: output=7f03fc4959b242f6 input=a557be0f8607a0d6]*/ +{ +Py_UCS4 code; +unsigned int index; +if (name_length > NAME_MAXLEN) { +PyErr_SetString(PyExc_KeyError, "name too long"); +return NULL; +} +if (!_getcode(name, (int)name_length, &code)) { +PyErr_Format(PyExc_KeyError, "undefined character name '%s'", name); +return NULL; +} +if (UCD_Check(self)) { +/* in 3.2.0 there are no aliases and named sequences */ +if (IS_ALIAS(code) || IS_NAMED_SEQ(code)) { +PyErr_Format(PyExc_KeyError, "undefined character name '%s'", name); +return 0; +} +} +/* check if code is in the PUA range that we use for named sequences +and convert it */ +if (IS_NAMED_SEQ(code)) { +index = code-named_sequences_start; +return PyUnicode_FromKindAndData(PyUnicode_2BYTE_KIND, +named_sequences[index].seq, +named_sequences[index].seqlen); +} +if (IS_ALIAS(code)) { +code = name_aliases[code-aliases_start]; +} +return PyUnicode_FromOrdinal(code); +} +/* Grapheme Cluster Break algorithm */ +enum ExtPictState { +ExtPictState_Init, +// \p{Extended_Pictographic} Extend* +ExtPictState_Started, +// ... ZWJ +ExtPictState_ZWJ, +// ... \p{Extended_Pictographic} +ExtPictState_Matched, +}; +enum InCBState { +InCBState_Init, +// \p{InCB=Consonant} \p{InCB=Extend}* +InCBState_Started, +// ... \p{InCB=Linker} [ \p{InCB=Extend} \p{InCB=Linker} ]* +InCBState_Linker, +// ... \p{InCB=Consonant} +InCBState_Matched, +}; +typedef struct { +PyObject *str; +Py_ssize_t start; +Py_ssize_t pos; +Py_ssize_t end; +int gcb; +enum ExtPictState ep_state; +enum InCBState incb_state; +bool ri_flag; +} _PyGraphemeBreak; +static inline enum ExtPictState +update_ext_pict_state(enum ExtPictState state, int gcb, bool ext_pict) +{ +if (ext_pict) { +return (state == ExtPictState_ZWJ) ? ExtPictState_Matched : ExtPictState_Started; +} +if (state == ExtPictState_Started || state == ExtPictState_Matched) { +if (gcb == GCB_Extend) { +return ExtPictState_Started; +} +if (gcb == GCB_ZWJ) { +return ExtPictState_ZWJ; +} +} +return ExtPictState_Init; +} +static inline enum InCBState +update_incb_state(enum InCBState state, int incb) +{ +if (incb == InCB_Consonant) { +return (state == InCBState_Linker) ? InCBState_Matched : InCBState_Started; +} +if (state != InCBState_Init) { +if (incb == InCB_Extend) { +return (state == InCBState_Linker) ? InCBState_Linker : InCBState_Started; +} +if (incb == InCB_Linker) { +return InCBState_Linker; +} +} +return InCBState_Init; +} +static inline bool +update_ri_flag(bool flag, int gcb) +{ +if (gcb == GCB_Regional_Indicator) { +return !flag; +} +else { +return false; +} +} +static inline bool +grapheme_break(int prev_gcb, int curr_gcb, enum ExtPictState ep_state, +bool ri_flag, enum InCBState incb_state) +{ +/* GB3 */ +if (prev_gcb == GCB_CR && curr_gcb == GCB_LF) { +return false; +} +/* GB4 */ +if (prev_gcb == GCB_CR || +prev_gcb == GCB_LF || +prev_gcb == GCB_Control) +{ +return true; +} +/* GB5 */ +if (curr_gcb == GCB_CR || +curr_gcb == GCB_LF || +curr_gcb == GCB_Control) +{ +return true; +} +/* GB6 */ +if (prev_gcb == GCB_L && +(curr_gcb == GCB_L || +curr_gcb == GCB_V || +curr_gcb == GCB_LV || +curr_gcb == GCB_LVT)) +{ +return false; +} +/* GB7 */ +if ((prev_gcb == GCB_LV || prev_gcb == GCB_V) && +(curr_gcb == GCB_V || curr_gcb == GCB_T)) +{ +return false; +} +/* GB8 */ +if ((prev_gcb == GCB_LVT || prev_gcb == GCB_T) && +curr_gcb == GCB_T) +{ +return false; +} +/* GB9 */ +if (curr_gcb == GCB_Extend || curr_gcb == GCB_ZWJ) { +return false; +} +/* GB9a */ +if (curr_gcb == GCB_SpacingMark) { +return false; +} +/* GB9b */ +if (prev_gcb == GCB_Prepend) { +return false; +} +/* GB9c */ +if (incb_state == InCBState_Matched) { +return false; +} +/* GB11 */ +if (ep_state == ExtPictState_Matched) { +return false; +} +/* GB12 and GB13 */ +if (prev_gcb == GCB_Regional_Indicator && curr_gcb == prev_gcb) { +return ri_flag; +} +/* GB999 */ +return true; +} +static void +_Py_InitGraphemeBreak(_PyGraphemeBreak *iter, PyObject *str, +Py_ssize_t start, Py_ssize_t end) +{ +iter->str = str; +iter->start = iter->pos = start; +iter->end = end; +iter->gcb = 0; +iter->ep_state = ExtPictState_Init; +iter->ri_flag = false; +iter->incb_state = InCBState_Init; +} +static Py_ssize_t +_Py_NextGraphemeBreak(_PyGraphemeBreak *iter) +{ +if (iter->start >= iter->end) { +return -1; +} +int kind = PyUnicode_KIND(iter->str); +void *pstr = PyUnicode_DATA(iter->str); +while (iter->pos < iter->end) { +Py_UCS4 chr = PyUnicode_READ(kind, pstr, iter->pos); +const _PyUnicode_DatabaseRecord *record = _getrecord_ex(chr); +int gcb = record->grapheme_cluster_break; +iter->ep_state = update_ext_pict_state(iter->ep_state, gcb, record->ext_pict); +iter->ri_flag = update_ri_flag(iter->ri_flag, gcb); +iter->incb_state = update_incb_state(iter->incb_state, record->incb); +int prev_gcb = iter->gcb; +iter->gcb = gcb; +if (iter->pos != iter->start && +grapheme_break(prev_gcb, gcb, iter->ep_state, iter->ri_flag, +iter->incb_state)) +{ +iter->start = iter->pos; +return iter->pos++; +} +++iter->pos; +} +iter->start = iter->pos; +return iter->pos; +} +/* Text Segment object */ +typedef struct { +PyObject_HEAD +PyObject *string; +Py_ssize_t start; +Py_ssize_t end; +} SegmentObject; +static void +Segment_dealloc(PyObject *self) +{ +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +Py_DECREF(((SegmentObject *)self)->string); +tp->tp_free(self); +Py_DECREF(tp); +} +static int +Segment_traverse(PyObject *self, visitproc visit, void *arg) +{ +Py_VISIT(((SegmentObject *)self)->string); +return 0; +} +static int +Segment_clear(PyObject *self) +{ +Py_CLEAR(((SegmentObject *)self)->string); +return 0; +} +static PyObject * +Segment_str(PyObject *self) +{ +SegmentObject *s = (SegmentObject *)self; +return PyUnicode_Substring(s->string, s->start, s->end); +} +static PyObject * +Segment_repr(PyObject *self) +{ +SegmentObject *s = (SegmentObject *)self; +return PyUnicode_FromFormat("", s->start, s->end); +} +static PyMemberDef Segment_members[] = { +{"start", Py_T_PYSSIZET, offsetof(SegmentObject, start), 0, +PyDoc_STR("grapheme start")}, +{"end", Py_T_PYSSIZET, offsetof(SegmentObject, end), 0, +PyDoc_STR("grapheme end")}, +{NULL} /* Sentinel */ +}; +static PyType_Slot Segment_slots[] = { +{Py_tp_dealloc, Segment_dealloc}, +{Py_tp_traverse, Segment_traverse}, +{Py_tp_clear, Segment_clear}, +{Py_tp_str, Segment_str}, +{Py_tp_repr, Segment_repr}, +{Py_tp_members, Segment_members}, +{0, 0}, +}; +static PyType_Spec Segment_spec = { +.name = "unicodedata.Segment", +.basicsize = sizeof(SegmentObject), +.flags = ( +Py_TPFLAGS_DEFAULT +| Py_TPFLAGS_HAVE_GC +| Py_TPFLAGS_DISALLOW_INSTANTIATION +| Py_TPFLAGS_IMMUTABLETYPE +), +.slots = Segment_slots +}; +/* Grapheme Cluster iterator */ +typedef struct { +PyObject_HEAD +_PyGraphemeBreak iter; +} GraphemeBreakIterator; +static void +GBI_dealloc(PyObject *self) +{ +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +Py_DECREF(((GraphemeBreakIterator *)self)->iter.str); +tp->tp_free(self); +Py_DECREF(tp); +} +static int +GBI_traverse(PyObject *self, visitproc visit, void *arg) +{ +Py_VISIT(((GraphemeBreakIterator *)self)->iter.str); +return 0; +} +static int +GBI_clear(PyObject *self) +{ +Py_CLEAR(((GraphemeBreakIterator *)self)->iter.str); +return 0; +} +static PyObject * +GBI_iternext(PyObject *self) +{ +GraphemeBreakIterator *it = (GraphemeBreakIterator *)self; +Py_ssize_t start = it->iter.start; +Py_ssize_t pos = _Py_NextGraphemeBreak(&it->iter); +if (pos < 0) { +return NULL; +} +PyObject *module = PyType_GetModule(Py_TYPE(it)); +PyObject *SegmentType = get_unicodedata_state(module)->SegmentType; +SegmentObject *s = PyObject_GC_New(SegmentObject, +(PyTypeObject *)SegmentType); +if (!s) { +return NULL; +} +s->string = Py_NewRef(it->iter.str); +s->start = start; +s->end = pos; +PyObject_GC_Track(s); +return (PyObject *)s; +} +static PyType_Slot GraphemeBreakIterator_slots[] = { +{Py_tp_dealloc, GBI_dealloc}, +{Py_tp_iter, PyObject_SelfIter}, +{Py_tp_iternext, GBI_iternext}, +{Py_tp_traverse, GBI_traverse}, +{Py_tp_clear, GBI_clear}, +{0, 0}, +}; +static PyType_Spec GraphemeBreakIterator_spec = { +.name = "unicodedata.GraphemeBreakIterator", +.basicsize = sizeof(GraphemeBreakIterator), +.flags = ( +Py_TPFLAGS_DEFAULT +| Py_TPFLAGS_HAVE_GC +| Py_TPFLAGS_DISALLOW_INSTANTIATION +| Py_TPFLAGS_IMMUTABLETYPE +), +.slots = GraphemeBreakIterator_slots +}; +/*[clinic input] +unicodedata.iter_graphemes +unistr: unicode +start: Py_ssize_t = 0 +end: Py_ssize_t(c_default="PY_SSIZE_T_MAX") = sys.maxsize +/ +Returns an iterator to iterate over grapheme clusters. +It uses extended grapheme cluster rules from TR29. +[clinic start generated code]*/ +static PyObject * +unicodedata_iter_graphemes_impl(PyObject *module, PyObject *unistr, +Py_ssize_t start, Py_ssize_t end) +/*[clinic end generated code: output=b0b831944265d36f input=a1454d9e8135951f]*/ +{ +PyObject *GraphemeBreakIteratorType = get_unicodedata_state(module)->GraphemeBreakIteratorType; +GraphemeBreakIterator *gbi = PyObject_GC_New(GraphemeBreakIterator, +(PyTypeObject *)GraphemeBreakIteratorType); +if (!gbi) { +return NULL; +} +Py_ssize_t len = PyUnicode_GET_LENGTH(unistr); +ADJUST_INDICES(start, end, len); +Py_INCREF(unistr); +_Py_InitGraphemeBreak(&gbi->iter, unistr, start, end); +PyObject_GC_Track(gbi); +return (PyObject*)gbi; +} +/*[clinic input] +unicodedata.grapheme_cluster_break +chr: int(accept={str}) +/ +Returns the Grapheme_Cluster_Break property assigned to the character. +[clinic start generated code]*/ +static PyObject * +unicodedata_grapheme_cluster_break_impl(PyObject *module, int chr) +/*[clinic end generated code: output=39542e0f63bba36f input=5da75e86435576fd]*/ +{ +Py_UCS4 c = (Py_UCS4)chr; +int index = (int) _getrecord_ex(c)->grapheme_cluster_break; +return PyUnicode_FromString(_PyUnicode_GraphemeBreakNames[index]); +} +/*[clinic input] +unicodedata.indic_conjunct_break +chr: int(accept={str}) +/ +Returns the Indic_Conjunct_Break property assigned to the character. +[clinic start generated code]*/ +static PyObject * +unicodedata_indic_conjunct_break_impl(PyObject *module, int chr) +/*[clinic end generated code: output=673eff2caf797f08 input=5c730f78e469f2e8]*/ +{ +Py_UCS4 c = (Py_UCS4)chr; +int index = (int) _getrecord_ex(c)->incb; +return PyUnicode_FromString(_PyUnicode_IndicConjunctBreakNames[index]); +} +/*[clinic input] +@permit_long_summary +unicodedata.extended_pictographic +chr: int(accept={str}) +/ +Returns the Extended_Pictographic property assigned to the character, as boolean. +[clinic start generated code]*/ +static PyObject * +unicodedata_extended_pictographic_impl(PyObject *module, int chr) +/*[clinic end generated code: output=b6bbb349427370b1 input=250d7bd988997eb3]*/ +{ +Py_UCS4 c = (Py_UCS4)chr; +int index = (int) _getrecord_ex(c)->ext_pict; +return PyBool_FromLong(index); +} +// List of functions used to define module functions *AND* unicodedata.UCD +// methods. For module functions, self is the module. For UCD methods, self +// is an UCD instance. The UCD_Check() macro is used to check if self is +// an UCD instance. +static PyMethodDef unicodedata_functions[] = { +// Module only functions. +UNICODEDATA_GRAPHEME_CLUSTER_BREAK_METHODDEF +UNICODEDATA_INDIC_CONJUNCT_BREAK_METHODDEF +UNICODEDATA_EXTENDED_PICTOGRAPHIC_METHODDEF +UNICODEDATA_ITER_GRAPHEMES_METHODDEF +UNICODEDATA_ISXIDSTART_METHODDEF +UNICODEDATA_ISXIDCONTINUE_METHODDEF +// The following definitions are shared between the module +// and the UCD class. +#define DB_methods (unicodedata_functions + 6) +UNICODEDATA_UCD_DECIMAL_METHODDEF +UNICODEDATA_UCD_DIGIT_METHODDEF +UNICODEDATA_UCD_NUMERIC_METHODDEF +UNICODEDATA_UCD_CATEGORY_METHODDEF +UNICODEDATA_UCD_BIDIRECTIONAL_METHODDEF +UNICODEDATA_UCD_COMBINING_METHODDEF +UNICODEDATA_UCD_MIRRORED_METHODDEF +UNICODEDATA_UCD_EAST_ASIAN_WIDTH_METHODDEF +UNICODEDATA_UCD_DECOMPOSITION_METHODDEF +UNICODEDATA_UCD_NAME_METHODDEF +UNICODEDATA_UCD_LOOKUP_METHODDEF +UNICODEDATA_UCD_IS_NORMALIZED_METHODDEF +UNICODEDATA_UCD_NORMALIZE_METHODDEF +{NULL, NULL} /* sentinel */ +}; +static void +ucd_dealloc(PyObject *self) +{ +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +PyObject_GC_Del(self); +Py_DECREF(tp); +} +static PyType_Slot ucd_type_slots[] = { +{Py_tp_dealloc, ucd_dealloc}, +{Py_tp_traverse, _PyObject_VisitType}, +{Py_tp_getattro, PyObject_GenericGetAttr}, +{Py_tp_methods, DB_methods}, +{Py_tp_members, DB_members}, +{0, 0} +}; +static PyType_Spec ucd_type_spec = { +.name = "unicodedata.UCD", +.basicsize = sizeof(PreviousDBVersion), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | +Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE), +.slots = ucd_type_slots +}; +PyDoc_STRVAR(unicodedata_docstring, +"This module provides access to the Unicode Character Database which\n\ +defines character properties for all Unicode characters. The data in\n\ +this database is based on the UnicodeData.txt file version\n\ +" UNIDATA_VERSION " which is publicly available from ftp://ftp.unicode.org/.\n\ +\n\ +The module uses the same names and symbols as defined by the\n\ +UnicodeData File Format " UNIDATA_VERSION "."); +static int +unicodedata_traverse(PyObject *module, visitproc visit, void *arg) +{ +unicodedatastate *state = get_unicodedata_state(module); +Py_VISIT(state->SegmentType); +Py_VISIT(state->GraphemeBreakIteratorType); +return 0; +} +static int +unicodedata_clear(PyObject *module) +{ +unicodedatastate *state = get_unicodedata_state(module); +Py_CLEAR(state->SegmentType); +Py_CLEAR(state->GraphemeBreakIteratorType); +return 0; +} +static void +unicodedata_free(void *module) +{ +unicodedata_clear((PyObject *)module); +} +static int +unicodedata_exec(PyObject *module) +{ +unicodedatastate *state = get_unicodedata_state(module); +PyObject *SegmentType = PyType_FromModuleAndSpec(module, &Segment_spec, NULL); +if (SegmentType == NULL) { +return -1; +} +state->SegmentType = SegmentType; +PyObject *GraphemeBreakIteratorType = PyType_FromModuleAndSpec(module, &GraphemeBreakIterator_spec, NULL); +if (GraphemeBreakIteratorType == NULL) { +return -1; +} +state->GraphemeBreakIteratorType = GraphemeBreakIteratorType; +if (PyModule_AddStringConstant(module, "unidata_version", UNIDATA_VERSION) < 0) { +return -1; +} +PyTypeObject *ucd_type = (PyTypeObject *)PyType_FromSpec(&ucd_type_spec); +if (ucd_type == NULL) { +return -1; +} +if (PyModule_AddType(module, ucd_type) < 0) { +Py_DECREF(ucd_type); +return -1; +} +// Unicode database version 3.2.0 used by the IDNA encoding +PyObject *v; +v = new_previous_version(ucd_type, "3.2.0", +get_change_3_2_0, normalization_3_2_0); +Py_DECREF(ucd_type); +if (PyModule_Add(module, "ucd_3_2_0", v) < 0) { +return -1; +} +/* Export C API */ +if (PyModule_Add(module, "_ucnhash_CAPI", unicodedata_create_capi()) < 0) { +return -1; +} +return 0; +} +static PyModuleDef_Slot unicodedata_slots[] = { +{Py_mod_exec, unicodedata_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL} +}; +static struct PyModuleDef unicodedata_module = { +PyModuleDef_HEAD_INIT, +.m_name = "unicodedata", +.m_doc = unicodedata_docstring, +.m_size = sizeof(unicodedatastate), +.m_methods = unicodedata_functions, +.m_slots = unicodedata_slots, +.m_traverse = unicodedata_traverse, +.m_clear = unicodedata_clear, +.m_free = unicodedata_free, +}; +PyMODINIT_FUNC +PyInit_unicodedata(void) +{ +return PyModuleDef_Init(&unicodedata_module); +} +/* +Local variables: +c-basic-offset: 4 +indent-tabs-mode: nil +End: +*/ + +/* csv module */ +/* +This module provides the low-level underpinnings of a CSV reading/writing +module. Users should not use this module directly, but import the csv.py +module instead. +*/ +// clinic/_csv.c.h uses internal pycore_modsupport.h API +#ifndef Py_BUILD_CORE_BUILTIN +# define Py_BUILD_CORE_MODULE 1 +#endif +#include "Python.h" +#include "pycore_pyatomic_ft_wrappers.h" +#include // offsetof() +#include +/*[clinic input] +module _csv +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=385118b71aa43706]*/ +#include "clinic/_csv.c.h" +#define NOT_SET ((Py_UCS4)-1) +#define EOL ((Py_UCS4)-2) +typedef struct { +PyObject *error_obj; /* CSV exception */ +PyObject *dialects; /* Dialect registry */ +PyTypeObject *dialect_type; +PyTypeObject *reader_type; +PyTypeObject *writer_type; +Py_ssize_t field_limit; /* max parsed field size */ +PyObject *str_write; +} _csvstate; +static struct PyModuleDef _csvmodule; +static inline _csvstate* +get_csv_state(PyObject *module) +{ +void *state = PyModule_GetState(module); +assert(state != NULL); +return (_csvstate *)state; +} +static int +_csv_clear(PyObject *module) +{ +_csvstate *module_state = PyModule_GetState(module); +Py_CLEAR(module_state->error_obj); +Py_CLEAR(module_state->dialects); +Py_CLEAR(module_state->dialect_type); +Py_CLEAR(module_state->reader_type); +Py_CLEAR(module_state->writer_type); +Py_CLEAR(module_state->str_write); +return 0; +} +static int +_csv_traverse(PyObject *module, visitproc visit, void *arg) +{ +_csvstate *module_state = PyModule_GetState(module); +Py_VISIT(module_state->error_obj); +Py_VISIT(module_state->dialects); +Py_VISIT(module_state->dialect_type); +Py_VISIT(module_state->reader_type); +Py_VISIT(module_state->writer_type); +return 0; +} +static void +_csv_free(void *module) +{ +(void)_csv_clear((PyObject *)module); +} +typedef enum { +START_RECORD, START_FIELD, ESCAPED_CHAR, IN_FIELD, +IN_QUOTED_FIELD, ESCAPE_IN_QUOTED_FIELD, QUOTE_IN_QUOTED_FIELD, +EAT_CRNL,AFTER_ESCAPED_CRNL +} ParserState; +typedef enum { +QUOTE_MINIMAL, QUOTE_ALL, QUOTE_NONNUMERIC, QUOTE_NONE, +QUOTE_STRINGS, QUOTE_NOTNULL +} QuoteStyle; +typedef struct { +QuoteStyle style; +const char *name; +} StyleDesc; +static const StyleDesc quote_styles[] = { +{ QUOTE_MINIMAL, "QUOTE_MINIMAL" }, +{ QUOTE_ALL, "QUOTE_ALL" }, +{ QUOTE_NONNUMERIC, "QUOTE_NONNUMERIC" }, +{ QUOTE_NONE, "QUOTE_NONE" }, +{ QUOTE_STRINGS, "QUOTE_STRINGS" }, +{ QUOTE_NOTNULL, "QUOTE_NOTNULL" }, +{ 0 } +}; +typedef struct { +PyObject_HEAD +char doublequote; /* is " represented by ""? */ +char skipinitialspace; /* ignore spaces following delimiter? */ +char strict; /* raise exception on bad CSV */ +int quoting; /* style of quoting to write */ +Py_UCS4 delimiter; /* field separator */ +Py_UCS4 quotechar; /* quote character */ +Py_UCS4 escapechar; /* escape character */ +PyObject *lineterminator; /* string to write between records */ +} DialectObj; +typedef struct { +PyObject_HEAD +PyObject *input_iter; /* iterate over this for input lines */ +DialectObj *dialect; /* parsing dialect */ +PyObject *fields; /* field list for current record */ +ParserState state; /* current CSV parse state */ +Py_UCS4 *field; /* temporary buffer */ +Py_ssize_t field_size; /* size of allocated buffer */ +Py_ssize_t field_len; /* length of current field */ +bool unquoted_field; /* true if no quotes around the current field */ +unsigned long line_num; /* Source-file line number */ +} ReaderObj; +typedef struct { +PyObject_HEAD +PyObject *write; /* write output lines to this file */ +DialectObj *dialect; /* parsing dialect */ +Py_UCS4 *rec; /* buffer for parser.join */ +Py_ssize_t rec_size; /* size of allocated record */ +Py_ssize_t rec_len; /* length of record */ +int num_fields; /* number of fields in record */ +PyObject *error_obj; /* cached error object */ +} WriterObj; +#define _DialectObj_CAST(op) ((DialectObj *)(op)) +#define _ReaderObj_CAST(op) ((ReaderObj *)(op)) +#define _WriterObj_CAST(op) ((WriterObj *)(op)) +/* +* DIALECT class +*/ +static PyObject * +get_dialect_from_registry(PyObject *name_obj, _csvstate *module_state) +{ +PyObject *dialect_obj; +if (PyDict_GetItemRef(module_state->dialects, name_obj, &dialect_obj) == 0) { +PyErr_SetString(module_state->error_obj, "unknown dialect"); +} +return dialect_obj; +} +static PyObject * +get_char_or_None(Py_UCS4 c) +{ +if (c == NOT_SET) { +Py_RETURN_NONE; +} +else +return PyUnicode_FromOrdinal(c); +} +static PyObject * +Dialect_get_lineterminator(PyObject *op, void *Py_UNUSED(ignored)) +{ +DialectObj *self = _DialectObj_CAST(op); +return Py_XNewRef(self->lineterminator); +} +static PyObject * +Dialect_get_delimiter(PyObject *op, void *Py_UNUSED(ignored)) +{ +DialectObj *self = _DialectObj_CAST(op); +return get_char_or_None(self->delimiter); +} +static PyObject * +Dialect_get_escapechar(PyObject *op, void *Py_UNUSED(ignored)) +{ +DialectObj *self = _DialectObj_CAST(op); +return get_char_or_None(self->escapechar); +} +static PyObject * +Dialect_get_quotechar(PyObject *op, void *Py_UNUSED(ignored)) +{ +DialectObj *self = _DialectObj_CAST(op); +return get_char_or_None(self->quotechar); +} +static PyObject * +Dialect_get_quoting(PyObject *op, void *Py_UNUSED(ignored)) +{ +DialectObj *self = _DialectObj_CAST(op); +return PyLong_FromLong(self->quoting); +} +static int +_set_bool(const char *name, char *target, PyObject *src, bool dflt) +{ +if (src == NULL) +*target = dflt; +else { +int b = PyObject_IsTrue(src); +if (b < 0) +return -1; +*target = (char)b; +} +return 0; +} +static int +_set_int(const char *name, int *target, PyObject *src, int dflt) +{ +if (src == NULL) +*target = dflt; +else { +int value; +if (!PyLong_CheckExact(src)) { +PyErr_Format(PyExc_TypeError, +"\"%s\" must be an integer, not %T", name, src); +return -1; +} +value = PyLong_AsInt(src); +if (value == -1 && PyErr_Occurred()) { +return -1; +} +*target = value; +} +return 0; +} +static int +_set_char_or_none(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt) +{ +if (src == NULL) { +*target = dflt; +} +else if (src == Py_None) { +*target = NOT_SET; +} +else { +// similar to PyArg_Parse("C?") +if (!PyUnicode_Check(src)) { +PyErr_Format(PyExc_TypeError, +"\"%s\" must be a unicode character or None, not %T", +name, src); +return -1; +} +Py_ssize_t len = PyUnicode_GetLength(src); +if (len < 0) { +return -1; +} +if (len != 1) { +PyErr_Format(PyExc_TypeError, +"\"%s\" must be a unicode character or None, " +"not a string of length %zd", +name, len); +return -1; +} +*target = PyUnicode_READ_CHAR(src, 0); +} +return 0; +} +static int +_set_char(const char *name, Py_UCS4 *target, PyObject *src, Py_UCS4 dflt) +{ +if (src == NULL) { +*target = dflt; +} +else { +// similar to PyArg_Parse("C") +if (!PyUnicode_Check(src)) { +PyErr_Format(PyExc_TypeError, +"\"%s\" must be a unicode character, not %T", +name, src); +return -1; +} +Py_ssize_t len = PyUnicode_GetLength(src); +if (len < 0) { +return -1; +} +if (len != 1) { +PyErr_Format(PyExc_TypeError, +"\"%s\" must be a unicode character, " +"not a string of length %zd", +name, len); +return -1; +} +*target = PyUnicode_READ_CHAR(src, 0); +} +return 0; +} +static int +_set_str(const char *name, PyObject **target, PyObject *src, const char *dflt) +{ +if (src == NULL) +*target = PyUnicode_DecodeASCII(dflt, strlen(dflt), NULL); +else { +if (!PyUnicode_Check(src)) { +PyErr_Format(PyExc_TypeError, +"\"%s\" must be a string, not %T", name, src); +return -1; +} +Py_XSETREF(*target, Py_NewRef(src)); +} +return 0; +} +static int +dialect_check_quoting(int quoting) +{ +const StyleDesc *qs; +for (qs = quote_styles; qs->name; qs++) { +if ((int)qs->style == quoting) +return 0; +} +PyErr_Format(PyExc_TypeError, "bad \"quoting\" value"); +return -1; +} +static int +dialect_check_char(const char *name, Py_UCS4 c, DialectObj *dialect, bool allowspace) +{ +if (c == '\r' || c == '\n' || (c == ' ' && !allowspace)) { +PyErr_Format(PyExc_ValueError, "bad %s value", name); +return -1; +} +if (PyUnicode_FindChar( +dialect->lineterminator, c, 0, +PyUnicode_GET_LENGTH(dialect->lineterminator), 1) >= 0) +{ +PyErr_Format(PyExc_ValueError, "bad %s or lineterminator value", name); +return -1; +} +return 0; +} +static int +dialect_check_chars(const char *name1, const char *name2, Py_UCS4 c1, Py_UCS4 c2) +{ +if (c1 == c2 && c1 != NOT_SET) { +PyErr_Format(PyExc_ValueError, "bad %s or %s value", name1, name2); +return -1; +} +return 0; +} +#define D_OFF(x) offsetof(DialectObj, x) +static struct PyMemberDef Dialect_memberlist[] = { +{ "skipinitialspace", Py_T_BOOL, D_OFF(skipinitialspace), Py_READONLY }, +{ "doublequote", Py_T_BOOL, D_OFF(doublequote), Py_READONLY }, +{ "strict", Py_T_BOOL, D_OFF(strict), Py_READONLY }, +{ NULL } +}; +#undef D_OFF +static PyGetSetDef Dialect_getsetlist[] = { +{"delimiter", Dialect_get_delimiter}, +{"escapechar", Dialect_get_escapechar}, +{"lineterminator", Dialect_get_lineterminator}, +{"quotechar", Dialect_get_quotechar}, +{"quoting", Dialect_get_quoting}, +{NULL}, +}; +static void +Dialect_dealloc(PyObject *self) +{ +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +tp->tp_clear((PyObject *)self); +PyObject_GC_Del(self); +Py_DECREF(tp); +} +static char *dialect_kws[] = { +"dialect", +"delimiter", +"doublequote", +"escapechar", +"lineterminator", +"quotechar", +"quoting", +"skipinitialspace", +"strict", +NULL +}; +static _csvstate * +_csv_state_from_type(PyTypeObject *type, const char *name) +{ +PyObject *module = PyType_GetModuleByDef(type, &_csvmodule); +if (module == NULL) { +return NULL; +} +_csvstate *module_state = PyModule_GetState(module); +if (module_state == NULL) { +PyErr_Format(PyExc_SystemError, +"%s: No _csv module state found", name); +return NULL; +} +return module_state; +} +static PyObject * +dialect_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) +{ +DialectObj *self; +PyObject *ret = NULL; +PyObject *dialect = NULL; +PyObject *delimiter = NULL; +PyObject *doublequote = NULL; +PyObject *escapechar = NULL; +PyObject *lineterminator = NULL; +PyObject *quotechar = NULL; +PyObject *quoting = NULL; +PyObject *skipinitialspace = NULL; +PyObject *strict = NULL; +if (!PyArg_ParseTupleAndKeywords(args, kwargs, +"|OOOOOOOOO", dialect_kws, +&dialect, +&delimiter, +&doublequote, +&escapechar, +&lineterminator, +"echar, +"ing, +&skipinitialspace, +&strict)) +return NULL; +_csvstate *module_state = _csv_state_from_type(type, "dialect_new"); +if (module_state == NULL) { +return NULL; +} +if (dialect != NULL) { +if (PyUnicode_Check(dialect)) { +dialect = get_dialect_from_registry(dialect, module_state); +if (dialect == NULL) +return NULL; +} +else +Py_INCREF(dialect); +/* Can we reuse this instance? */ +if (PyObject_TypeCheck(dialect, module_state->dialect_type) && +delimiter == NULL && +doublequote == NULL && +escapechar == NULL && +lineterminator == NULL && +quotechar == NULL && +quoting == NULL && +skipinitialspace == NULL && +strict == NULL) +return dialect; +} +self = (DialectObj *)type->tp_alloc(type, 0); +if (self == NULL) { +Py_CLEAR(dialect); +return NULL; +} +self->lineterminator = NULL; +Py_XINCREF(delimiter); +Py_XINCREF(doublequote); +Py_XINCREF(escapechar); +Py_XINCREF(lineterminator); +Py_XINCREF(quotechar); +Py_XINCREF(quoting); +Py_XINCREF(skipinitialspace); +Py_XINCREF(strict); +if (dialect != NULL) { +#define DIALECT_GETATTR(v, n) \ +do { \ +if (v == NULL) { \ +v = PyObject_GetAttrString(dialect, n); \ +if (v == NULL) \ +PyErr_Clear(); \ +} \ +} while (0) +DIALECT_GETATTR(delimiter, "delimiter"); +DIALECT_GETATTR(doublequote, "doublequote"); +DIALECT_GETATTR(escapechar, "escapechar"); +DIALECT_GETATTR(lineterminator, "lineterminator"); +DIALECT_GETATTR(quotechar, "quotechar"); +DIALECT_GETATTR(quoting, "quoting"); +DIALECT_GETATTR(skipinitialspace, "skipinitialspace"); +DIALECT_GETATTR(strict, "strict"); +} +#undef DIALECT_GETATTR +/* check types and convert to C values */ +#define DIASET(meth, name, target, src, dflt) \ +if (meth(name, target, src, dflt)) \ +goto err +DIASET(_set_char, "delimiter", &self->delimiter, delimiter, ','); +DIASET(_set_bool, "doublequote", &self->doublequote, doublequote, true); +DIASET(_set_char_or_none, "escapechar", &self->escapechar, escapechar, NOT_SET); +DIASET(_set_str, "lineterminator", &self->lineterminator, lineterminator, "\r\n"); +DIASET(_set_char_or_none, "quotechar", &self->quotechar, quotechar, '"'); +DIASET(_set_int, "quoting", &self->quoting, quoting, QUOTE_MINIMAL); +DIASET(_set_bool, "skipinitialspace", &self->skipinitialspace, skipinitialspace, false); +DIASET(_set_bool, "strict", &self->strict, strict, false); +#undef DIASET +/* validate options */ +if (dialect_check_quoting(self->quoting)) +goto err; +if (quotechar == Py_None && quoting == NULL) +self->quoting = QUOTE_NONE; +if (self->quoting != QUOTE_NONE && self->quotechar == NOT_SET) { +PyErr_SetString(PyExc_TypeError, +"quotechar must be set if quoting enabled"); +goto err; +} +if (dialect_check_char("delimiter", self->delimiter, self, true) || +dialect_check_char("escapechar", self->escapechar, self, +!self->skipinitialspace) || +dialect_check_char("quotechar", self->quotechar, self, +!self->skipinitialspace) || +dialect_check_chars("delimiter", "escapechar", +self->delimiter, self->escapechar) || +dialect_check_chars("delimiter", "quotechar", +self->delimiter, self->quotechar) || +dialect_check_chars("escapechar", "quotechar", +self->escapechar, self->quotechar)) +{ +goto err; +} +ret = Py_NewRef(self); +err: +Py_CLEAR(self); +Py_CLEAR(dialect); +Py_CLEAR(delimiter); +Py_CLEAR(doublequote); +Py_CLEAR(escapechar); +Py_CLEAR(lineterminator); +Py_CLEAR(quotechar); +Py_CLEAR(quoting); +Py_CLEAR(skipinitialspace); +Py_CLEAR(strict); +return ret; +} +/* Since dialect is now a heap type, it inherits pickling method for +* protocol 0 and 1 from object, therefore it needs to be overridden */ +PyDoc_STRVAR(dialect_reduce_doc, "raises an exception to avoid pickling"); +static PyObject * +Dialect_reduce(PyObject *self, PyObject *args) { +PyErr_Format(PyExc_TypeError, +"cannot pickle '%.100s' instances", _PyType_Name(Py_TYPE(self))); +return NULL; +} +static struct PyMethodDef dialect_methods[] = { +{"__reduce__", Dialect_reduce, METH_VARARGS, dialect_reduce_doc}, +{"__reduce_ex__", Dialect_reduce, METH_VARARGS, dialect_reduce_doc}, +{NULL, NULL} +}; +PyDoc_STRVAR(Dialect_Type_doc, +"CSV dialect\n" +"\n" +"The Dialect type records CSV parsing and generation options.\n"); +static int +Dialect_clear(PyObject *op) +{ +DialectObj *self = _DialectObj_CAST(op); +Py_CLEAR(self->lineterminator); +return 0; +} +static int +Dialect_traverse(PyObject *op, visitproc visit, void *arg) +{ +DialectObj *self = _DialectObj_CAST(op); +Py_VISIT(self->lineterminator); +Py_VISIT(Py_TYPE(self)); +return 0; +} +static PyType_Slot Dialect_Type_slots[] = { +{Py_tp_doc, (char*)Dialect_Type_doc}, +{Py_tp_members, Dialect_memberlist}, +{Py_tp_getset, Dialect_getsetlist}, +{Py_tp_new, dialect_new}, +{Py_tp_methods, dialect_methods}, +{Py_tp_dealloc, Dialect_dealloc}, +{Py_tp_clear, Dialect_clear}, +{Py_tp_traverse, Dialect_traverse}, +{0, NULL} +}; +PyType_Spec Dialect_Type_spec = { +.name = "_csv.Dialect", +.basicsize = sizeof(DialectObj), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE), +.slots = Dialect_Type_slots, +}; +/* +* Return an instance of the dialect type, given a Python instance or kwarg +* description of the dialect +*/ +static PyObject * +_call_dialect(_csvstate *module_state, PyObject *dialect_inst, PyObject *kwargs) +{ +PyObject *type = (PyObject *)module_state->dialect_type; +if (dialect_inst) { +return PyObject_VectorcallDict(type, &dialect_inst, 1, kwargs); +} +else { +return PyObject_VectorcallDict(type, NULL, 0, kwargs); +} +} +/* +* READER +*/ +static int +parse_save_field(ReaderObj *self) +{ +int quoting = self->dialect->quoting; +PyObject *field; +if (self->unquoted_field && +self->field_len == 0 && +(quoting == QUOTE_NOTNULL || quoting == QUOTE_STRINGS)) +{ +field = Py_NewRef(Py_None); +} +else { +field = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, +(void *) self->field, self->field_len); +if (field == NULL) { +return -1; +} +if (self->unquoted_field && +self->field_len != 0 && +(quoting == QUOTE_NONNUMERIC || quoting == QUOTE_STRINGS)) +{ +PyObject *tmp = PyNumber_Float(field); +Py_DECREF(field); +if (tmp == NULL) { +return -1; +} +field = tmp; +} +self->field_len = 0; +} +if (PyList_Append(self->fields, field) < 0) { +Py_DECREF(field); +return -1; +} +Py_DECREF(field); +return 0; +} +static int +parse_grow_buff(ReaderObj *self) +{ +assert((size_t)self->field_size <= PY_SSIZE_T_MAX / sizeof(Py_UCS4)); +Py_ssize_t field_size_new = self->field_size ? 2 * self->field_size : 4096; +Py_UCS4 *field_new = self->field; +PyMem_Resize(field_new, Py_UCS4, field_size_new); +if (field_new == NULL) { +PyErr_NoMemory(); +return 0; +} +self->field = field_new; +self->field_size = field_size_new; +return 1; +} +static int +parse_add_char(ReaderObj *self, _csvstate *module_state, Py_UCS4 c) +{ +Py_ssize_t field_limit = FT_ATOMIC_LOAD_SSIZE_RELAXED(module_state->field_limit); +if (self->field_len >= field_limit) { +PyErr_Format(module_state->error_obj, +"field larger than field limit (%zd)", +field_limit); +return -1; +} +if (self->field_len == self->field_size && !parse_grow_buff(self)) +return -1; +self->field[self->field_len++] = c; +return 0; +} +static int +parse_process_char(ReaderObj *self, _csvstate *module_state, Py_UCS4 c) +{ +DialectObj *dialect = self->dialect; +switch (self->state) { +case START_RECORD: +/* start of record */ +if (c == EOL) +/* empty line - return [] */ +break; +else if (c == '\n' || c == '\r') { +self->state = EAT_CRNL; +break; +} +/* normal character - handle as START_FIELD */ +self->state = START_FIELD; +_Py_FALLTHROUGH; +case START_FIELD: +/* expecting field */ +self->unquoted_field = true; +if (c == '\n' || c == '\r' || c == EOL) { +/* save empty field - return [fields] */ +if (parse_save_field(self) < 0) +return -1; +self->state = (c == EOL ? START_RECORD : EAT_CRNL); +} +else if (c == dialect->quotechar && +dialect->quoting != QUOTE_NONE) { +/* start quoted field */ +self->unquoted_field = false; +self->state = IN_QUOTED_FIELD; +} +else if (c == dialect->escapechar) { +/* possible escaped character */ +self->state = ESCAPED_CHAR; +} +else if (c == ' ' && dialect->skipinitialspace) +/* ignore spaces at start of field */ +; +else if (c == dialect->delimiter) { +/* save empty field */ +if (parse_save_field(self) < 0) +return -1; +} +else { +/* begin new unquoted field */ +if (parse_add_char(self, module_state, c) < 0) +return -1; +self->state = IN_FIELD; +} +break; +case ESCAPED_CHAR: +if (c == '\n' || c=='\r') { +if (parse_add_char(self, module_state, c) < 0) +return -1; +self->state = AFTER_ESCAPED_CRNL; +break; +} +if (c == EOL) +c = '\n'; +if (parse_add_char(self, module_state, c) < 0) +return -1; +self->state = IN_FIELD; +break; +case AFTER_ESCAPED_CRNL: +if (c == EOL) +break; +_Py_FALLTHROUGH; +case IN_FIELD: +/* in unquoted field */ +if (c == '\n' || c == '\r' || c == EOL) { +/* end of line - return [fields] */ +if (parse_save_field(self) < 0) +return -1; +self->state = (c == EOL ? START_RECORD : EAT_CRNL); +} +else if (c == dialect->escapechar) { +/* possible escaped character */ +self->state = ESCAPED_CHAR; +} +else if (c == dialect->delimiter) { +/* save field - wait for new field */ +if (parse_save_field(self) < 0) +return -1; +self->state = START_FIELD; +} +else { +/* normal character - save in field */ +if (parse_add_char(self, module_state, c) < 0) +return -1; +} +break; +case IN_QUOTED_FIELD: +/* in quoted field */ +if (c == EOL) +; +else if (c == dialect->escapechar) { +/* Possible escape character */ +self->state = ESCAPE_IN_QUOTED_FIELD; +} +else if (c == dialect->quotechar && +dialect->quoting != QUOTE_NONE) { +if (dialect->doublequote) { +/* doublequote; " represented by "" */ +self->state = QUOTE_IN_QUOTED_FIELD; +} +else { +/* end of quote part of field */ +self->state = IN_FIELD; +} +} +else { +/* normal character - save in field */ +if (parse_add_char(self, module_state, c) < 0) +return -1; +} +break; +case ESCAPE_IN_QUOTED_FIELD: +if (c == EOL) +c = '\n'; +if (parse_add_char(self, module_state, c) < 0) +return -1; +self->state = IN_QUOTED_FIELD; +break; +case QUOTE_IN_QUOTED_FIELD: +/* doublequote - seen a quote in a quoted field */ +if (dialect->quoting != QUOTE_NONE && +c == dialect->quotechar) { +/* save "" as " */ +if (parse_add_char(self, module_state, c) < 0) +return -1; +self->state = IN_QUOTED_FIELD; +} +else if (c == dialect->delimiter) { +/* save field - wait for new field */ +if (parse_save_field(self) < 0) +return -1; +self->state = START_FIELD; +} +else if (c == '\n' || c == '\r' || c == EOL) { +/* end of line - return [fields] */ +if (parse_save_field(self) < 0) +return -1; +self->state = (c == EOL ? START_RECORD : EAT_CRNL); +} +else if (!dialect->strict) { +if (parse_add_char(self, module_state, c) < 0) +return -1; +self->state = IN_FIELD; +} +else { +/* illegal */ +PyErr_Format(module_state->error_obj, "'%c' expected after '%c'", +dialect->delimiter, +dialect->quotechar); +return -1; +} +break; +case EAT_CRNL: +if (c == '\n' || c == '\r') +; +else if (c == EOL) +self->state = START_RECORD; +else { +PyErr_Format(module_state->error_obj, +"new-line character seen in unquoted field - " +"do you need to open the file with newline=''?"); +return -1; +} +break; +} +return 0; +} +static int +parse_reset(ReaderObj *self) +{ +Py_XSETREF(self->fields, PyList_New(0)); +if (self->fields == NULL) +return -1; +self->field_len = 0; +self->state = START_RECORD; +self->unquoted_field = false; +return 0; +} +static PyObject * +Reader_iternext_lock_held(PyObject *op) +{ +ReaderObj *self = _ReaderObj_CAST(op); +PyObject *fields = NULL; +Py_UCS4 c; +Py_ssize_t pos, linelen; +int kind; +const void *data; +PyObject *lineobj; +_csvstate *module_state = _csv_state_from_type(Py_TYPE(self), +"Reader.__next__"); +if (module_state == NULL) { +return NULL; +} +if (parse_reset(self) < 0) +return NULL; +do { +lineobj = PyIter_Next(self->input_iter); +if (lineobj == NULL) { +/* End of input OR exception */ +if (!PyErr_Occurred() && (self->field_len != 0 || +self->state == IN_QUOTED_FIELD)) { +if (self->dialect->strict) +PyErr_SetString(module_state->error_obj, +"unexpected end of data"); +else if (parse_save_field(self) >= 0) +break; +} +return NULL; +} +if (!PyUnicode_Check(lineobj)) { +PyErr_Format(module_state->error_obj, +"iterator should return strings, " +"not %.200s " +"(the file should be opened in text mode)", +Py_TYPE(lineobj)->tp_name +); +Py_DECREF(lineobj); +return NULL; +} +++self->line_num; +kind = PyUnicode_KIND(lineobj); +data = PyUnicode_DATA(lineobj); +pos = 0; +linelen = PyUnicode_GET_LENGTH(lineobj); +while (linelen--) { +c = PyUnicode_READ(kind, data, pos); +if (parse_process_char(self, module_state, c) < 0) { +Py_DECREF(lineobj); +goto err; +} +pos++; +} +Py_DECREF(lineobj); +if (parse_process_char(self, module_state, EOL) < 0) +goto err; +} while (self->state != START_RECORD); +fields = self->fields; +self->fields = NULL; +err: +return fields; +} +static PyObject * +Reader_iternext(PyObject *op) +{ +PyObject *result; +Py_BEGIN_CRITICAL_SECTION(op); +result = Reader_iternext_lock_held(op); +Py_END_CRITICAL_SECTION(); +return result; +} +static void +Reader_dealloc(PyObject *op) +{ +ReaderObj *self = _ReaderObj_CAST(op); +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +(void)tp->tp_clear(op); +if (self->field != NULL) { +PyMem_Free(self->field); +self->field = NULL; +} +PyObject_GC_Del(self); +Py_DECREF(tp); +} +static int +Reader_traverse(PyObject *op, visitproc visit, void *arg) +{ +ReaderObj *self = _ReaderObj_CAST(op); +Py_VISIT(self->dialect); +Py_VISIT(self->input_iter); +Py_VISIT(self->fields); +Py_VISIT(Py_TYPE(self)); +return 0; +} +static int +Reader_clear(PyObject *op) +{ +ReaderObj *self = _ReaderObj_CAST(op); +Py_CLEAR(self->dialect); +Py_CLEAR(self->input_iter); +Py_CLEAR(self->fields); +return 0; +} +PyDoc_STRVAR(Reader_Type_doc, +"CSV reader\n" +"\n" +"Reader objects are responsible for reading and parsing tabular data\n" +"in CSV format.\n" +); +static struct PyMethodDef Reader_methods[] = { +{ NULL, NULL } +}; +#define R_OFF(x) offsetof(ReaderObj, x) +static struct PyMemberDef Reader_memberlist[] = { +{ "dialect", _Py_T_OBJECT, R_OFF(dialect), Py_READONLY }, +{ "line_num", Py_T_ULONG, R_OFF(line_num), Py_READONLY }, +{ NULL } +}; +#undef R_OFF +static PyType_Slot Reader_Type_slots[] = { +{Py_tp_doc, (char*)Reader_Type_doc}, +{Py_tp_traverse, Reader_traverse}, +{Py_tp_iter, PyObject_SelfIter}, +{Py_tp_iternext, Reader_iternext}, +{Py_tp_methods, Reader_methods}, +{Py_tp_members, Reader_memberlist}, +{Py_tp_clear, Reader_clear}, +{Py_tp_dealloc, Reader_dealloc}, +{0, NULL} +}; +PyType_Spec Reader_Type_spec = { +.name = "_csv.reader", +.basicsize = sizeof(ReaderObj), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), +.slots = Reader_Type_slots +}; +static PyObject * +csv_reader(PyObject *module, PyObject *args, PyObject *keyword_args) +{ +PyObject * iterator, * dialect = NULL; +_csvstate *module_state = get_csv_state(module); +ReaderObj * self = PyObject_GC_New( +ReaderObj, +module_state->reader_type); +if (!self) +return NULL; +self->dialect = NULL; +self->fields = NULL; +self->input_iter = NULL; +self->field = NULL; +self->field_size = 0; +self->line_num = 0; +if (parse_reset(self) < 0) { +Py_DECREF(self); +return NULL; +} +if (!PyArg_UnpackTuple(args, "reader", 1, 2, &iterator, &dialect)) { +Py_DECREF(self); +return NULL; +} +self->input_iter = PyObject_GetIter(iterator); +if (self->input_iter == NULL) { +Py_DECREF(self); +return NULL; +} +self->dialect = (DialectObj *)_call_dialect(module_state, dialect, +keyword_args); +if (self->dialect == NULL) { +Py_DECREF(self); +return NULL; +} +PyObject_GC_Track(self); +return (PyObject *)self; +} +/* +* WRITER +*/ +/* ---------------------------------------------------------------- */ +static void +join_reset(WriterObj *self) +{ +self->rec_len = 0; +self->num_fields = 0; +} +#define MEM_INCR 32768 +/* Calculate new record length or append field to record. Return new +* record length. +*/ +static Py_ssize_t +join_append_data(WriterObj *self, int field_kind, const void *field_data, +Py_ssize_t field_len, int *quoted, +int copy_phase) +{ +DialectObj *dialect = self->dialect; +Py_ssize_t i; +Py_ssize_t rec_len; +#define INCLEN \ +do {\ +if (!copy_phase && rec_len == PY_SSIZE_T_MAX) { \ +goto overflow; \ +} \ +rec_len++; \ +} while(0) +#define ADDCH(c) \ +do {\ +if (copy_phase) \ +self->rec[rec_len] = c;\ +INCLEN;\ +} while(0) +rec_len = self->rec_len; +/* If this is not the first field we need a field separator */ +if (self->num_fields > 0) +ADDCH(dialect->delimiter); +/* Handle preceding quote */ +if (copy_phase && *quoted) +ADDCH(dialect->quotechar); +/* Copy/count field data */ +/* If field is null just pass over */ +for (i = 0; field_data && (i < field_len); i++) { +Py_UCS4 c = PyUnicode_READ(field_kind, field_data, i); +int want_escape = 0; +if (c == dialect->delimiter || +c == dialect->escapechar || +c == dialect->quotechar || +c == '\n' || +c == '\r' || +PyUnicode_FindChar( +dialect->lineterminator, c, 0, +PyUnicode_GET_LENGTH(dialect->lineterminator), 1) >= 0) { +if (dialect->quoting == QUOTE_NONE) +want_escape = 1; +else { +if (c == dialect->quotechar) { +if (dialect->doublequote) +ADDCH(dialect->quotechar); +else +want_escape = 1; +} +else if (c == dialect->escapechar) { +want_escape = 1; +} +if (!want_escape) +*quoted = 1; +} +if (want_escape) { +if (dialect->escapechar == NOT_SET) { +PyErr_Format(self->error_obj, +"need to escape, but no escapechar set"); +return -1; +} +ADDCH(dialect->escapechar); +} +} +/* Copy field character into record buffer. +*/ +ADDCH(c); +} +if (*quoted) { +if (copy_phase) +ADDCH(dialect->quotechar); +else { +INCLEN; /* starting quote */ +INCLEN; /* ending quote */ +} +} +return rec_len; +overflow: +PyErr_NoMemory(); +return -1; +#undef ADDCH +#undef INCLEN +} +static int +join_check_rec_size(WriterObj *self, Py_ssize_t rec_len) +{ +assert(rec_len >= 0); +if (rec_len > self->rec_size) { +size_t rec_size_new = (size_t)(rec_len / MEM_INCR + 1) * MEM_INCR; +Py_UCS4 *rec_new = self->rec; +PyMem_Resize(rec_new, Py_UCS4, rec_size_new); +if (rec_new == NULL) { +PyErr_NoMemory(); +return 0; +} +self->rec = rec_new; +self->rec_size = (Py_ssize_t)rec_size_new; +} +return 1; +} +static int +join_append(WriterObj *self, PyObject *field, int quoted) +{ +DialectObj *dialect = self->dialect; +int field_kind = -1; +const void *field_data = NULL; +Py_ssize_t field_len = 0; +Py_ssize_t rec_len; +if (field != NULL) { +field_kind = PyUnicode_KIND(field); +field_data = PyUnicode_DATA(field); +field_len = PyUnicode_GET_LENGTH(field); +} +if (!field_len && dialect->delimiter == ' ' && dialect->skipinitialspace) { +if (dialect->quoting == QUOTE_NONE || +(field == NULL && +(dialect->quoting == QUOTE_STRINGS || +dialect->quoting == QUOTE_NOTNULL))) +{ +PyErr_Format(self->error_obj, +"empty field must be quoted if delimiter is a space " +"and skipinitialspace is true"); +return 0; +} +quoted = 1; +} +rec_len = join_append_data(self, field_kind, field_data, field_len, +"ed, 0); +if (rec_len < 0) +return 0; +/* grow record buffer if necessary */ +if (!join_check_rec_size(self, rec_len)) +return 0; +self->rec_len = join_append_data(self, field_kind, field_data, field_len, +"ed, 1); +self->num_fields++; +return 1; +} +static int +join_append_lineterminator(WriterObj *self) +{ +Py_ssize_t terminator_len, i; +int term_kind; +const void *term_data; +terminator_len = PyUnicode_GET_LENGTH(self->dialect->lineterminator); +if (terminator_len == -1) +return 0; +/* grow record buffer if necessary */ +if (!join_check_rec_size(self, self->rec_len + terminator_len)) +return 0; +term_kind = PyUnicode_KIND(self->dialect->lineterminator); +term_data = PyUnicode_DATA(self->dialect->lineterminator); +for (i = 0; i < terminator_len; i++) +self->rec[self->rec_len + i] = PyUnicode_READ(term_kind, term_data, i); +self->rec_len += terminator_len; +return 1; +} +static PyObject * +csv_writerow_lock_held(PyObject *op, PyObject *seq) +{ +WriterObj *self = _WriterObj_CAST(op); +DialectObj *dialect = self->dialect; +PyObject *iter, *field, *line, *result; +bool null_field = false; +iter = PyObject_GetIter(seq); +if (iter == NULL) { +if (PyErr_ExceptionMatches(PyExc_TypeError)) { +PyErr_Format(self->error_obj, +"iterable expected, not %.200s", +Py_TYPE(seq)->tp_name); +} +return NULL; +} +/* Join all fields in internal buffer. +*/ +join_reset(self); +while ((field = PyIter_Next(iter))) { +int append_ok; +int quoted; +switch (dialect->quoting) { +case QUOTE_NONNUMERIC: +quoted = !PyNumber_Check(field); +break; +case QUOTE_ALL: +quoted = 1; +break; +case QUOTE_STRINGS: +quoted = PyUnicode_Check(field); +break; +case QUOTE_NOTNULL: +quoted = field != Py_None; +break; +default: +quoted = 0; +break; +} +null_field = (field == Py_None); +if (PyUnicode_Check(field)) { +append_ok = join_append(self, field, quoted); +Py_DECREF(field); +} +else if (null_field) { +append_ok = join_append(self, NULL, quoted); +Py_DECREF(field); +} +else { +PyObject *str; +str = PyObject_Str(field); +Py_DECREF(field); +if (str == NULL) { +Py_DECREF(iter); +return NULL; +} +append_ok = join_append(self, str, quoted); +Py_DECREF(str); +} +if (!append_ok) { +Py_DECREF(iter); +return NULL; +} +} +Py_DECREF(iter); +if (PyErr_Occurred()) +return NULL; +if (self->num_fields > 0 && self->rec_len == 0) { +if (dialect->quoting == QUOTE_NONE || +(null_field && +(dialect->quoting == QUOTE_STRINGS || +dialect->quoting == QUOTE_NOTNULL))) +{ +PyErr_Format(self->error_obj, +"single empty field record must be quoted"); +return NULL; +} +self->num_fields--; +if (!join_append(self, NULL, 1)) +return NULL; +} +/* Add line terminator. +*/ +if (!join_append_lineterminator(self)) { +return NULL; +} +line = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, +(void *) self->rec, self->rec_len); +if (line == NULL) { +return NULL; +} +result = PyObject_CallOneArg(self->write, line); +Py_DECREF(line); +return result; +} +PyDoc_STRVAR(csv_writerow_doc, +"writerow($self, row, /)\n" +"--\n\n" +"Construct and write a CSV record from an iterable of fields.\n" +"\n" +"Non-string elements will be converted to string."); +static PyObject * +csv_writerow(PyObject *op, PyObject *seq) +{ +PyObject *result; +Py_BEGIN_CRITICAL_SECTION(op); +result = csv_writerow_lock_held(op, seq); +Py_END_CRITICAL_SECTION(); +return result; +} +PyDoc_STRVAR(csv_writerows_doc, +"writerows($self, rows, /)\n" +"--\n\n" +"Construct and write a series of iterables to a csv file.\n" +"\n" +"Non-string elements will be converted to string."); +static PyObject * +csv_writerows(PyObject *self, PyObject *seqseq) +{ +PyObject *row_iter, *row_obj, *result; +row_iter = PyObject_GetIter(seqseq); +if (row_iter == NULL) { +return NULL; +} +while ((row_obj = PyIter_Next(row_iter))) { +result = csv_writerow(self, row_obj); +Py_DECREF(row_obj); +if (!result) { +Py_DECREF(row_iter); +return NULL; +} +else +Py_DECREF(result); +} +Py_DECREF(row_iter); +if (PyErr_Occurred()) +return NULL; +Py_RETURN_NONE; +} +static struct PyMethodDef Writer_methods[] = { +{"writerow", csv_writerow, METH_O, csv_writerow_doc}, +{"writerows", csv_writerows, METH_O, csv_writerows_doc}, +{NULL, NULL, 0, NULL} /* sentinel */ +}; +#define W_OFF(x) offsetof(WriterObj, x) +static struct PyMemberDef Writer_memberlist[] = { +{ "dialect", _Py_T_OBJECT, W_OFF(dialect), Py_READONLY }, +{ NULL } +}; +#undef W_OFF +static int +Writer_traverse(PyObject *op, visitproc visit, void *arg) +{ +WriterObj *self = _WriterObj_CAST(op); +Py_VISIT(self->dialect); +Py_VISIT(self->write); +Py_VISIT(self->error_obj); +Py_VISIT(Py_TYPE(self)); +return 0; +} +static int +Writer_clear(PyObject *op) +{ +WriterObj *self = _WriterObj_CAST(op); +Py_CLEAR(self->dialect); +Py_CLEAR(self->write); +Py_CLEAR(self->error_obj); +return 0; +} +static void +Writer_dealloc(PyObject *op) +{ +WriterObj *self = _WriterObj_CAST(op); +PyTypeObject *tp = Py_TYPE(self); +PyObject_GC_UnTrack(self); +tp->tp_clear(op); +if (self->rec != NULL) { +PyMem_Free(self->rec); +} +PyObject_GC_Del(self); +Py_DECREF(tp); +} +PyDoc_STRVAR(Writer_Type_doc, +"CSV writer\n" +"\n" +"Writer objects are responsible for generating tabular data\n" +"in CSV format from sequence input.\n" +); +static PyType_Slot Writer_Type_slots[] = { +{Py_tp_doc, (char*)Writer_Type_doc}, +{Py_tp_traverse, Writer_traverse}, +{Py_tp_clear, Writer_clear}, +{Py_tp_dealloc, Writer_dealloc}, +{Py_tp_methods, Writer_methods}, +{Py_tp_members, Writer_memberlist}, +{0, NULL} +}; +PyType_Spec Writer_Type_spec = { +.name = "_csv.writer", +.basicsize = sizeof(WriterObj), +.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC | +Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION), +.slots = Writer_Type_slots, +}; +static PyObject * +csv_writer(PyObject *module, PyObject *args, PyObject *keyword_args) +{ +PyObject * output_file, * dialect = NULL; +_csvstate *module_state = get_csv_state(module); +WriterObj * self = PyObject_GC_New(WriterObj, module_state->writer_type); +if (!self) +return NULL; +self->dialect = NULL; +self->write = NULL; +self->rec = NULL; +self->rec_size = 0; +self->rec_len = 0; +self->num_fields = 0; +self->error_obj = Py_NewRef(module_state->error_obj); +if (!PyArg_UnpackTuple(args, "writer", 1, 2, &output_file, &dialect)) { +Py_DECREF(self); +return NULL; +} +if (PyObject_GetOptionalAttr(output_file, +module_state->str_write, +&self->write) < 0) { +Py_DECREF(self); +return NULL; +} +if (self->write == NULL || !PyCallable_Check(self->write)) { +PyErr_SetString(PyExc_TypeError, +"argument 1 must have a \"write\" method"); +Py_DECREF(self); +return NULL; +} +self->dialect = (DialectObj *)_call_dialect(module_state, dialect, +keyword_args); +if (self->dialect == NULL) { +Py_DECREF(self); +return NULL; +} +PyObject_GC_Track(self); +return (PyObject *)self; +} +/* +* DIALECT REGISTRY +*/ +/*[clinic input] +_csv.list_dialects +Return a list of all known dialect names. +[clinic start generated code]*/ +static PyObject * +_csv_list_dialects_impl(PyObject *module) +/*[clinic end generated code: output=a5b92b215b006a6d input=ec58040aafd6a20a]*/ +{ +return PyDict_Keys(get_csv_state(module)->dialects); +} +static PyObject * +csv_register_dialect(PyObject *module, PyObject *args, PyObject *kwargs) +{ +PyObject *name_obj, *dialect_obj = NULL; +_csvstate *module_state = get_csv_state(module); +PyObject *dialect; +if (!PyArg_UnpackTuple(args, "register_dialect", 1, 2, &name_obj, &dialect_obj)) +return NULL; +if (!PyUnicode_Check(name_obj)) { +PyErr_SetString(PyExc_TypeError, +"dialect name must be a string"); +return NULL; +} +dialect = _call_dialect(module_state, dialect_obj, kwargs); +if (dialect == NULL) +return NULL; +if (PyDict_SetItem(module_state->dialects, name_obj, dialect) < 0) { +Py_DECREF(dialect); +return NULL; +} +Py_DECREF(dialect); +Py_RETURN_NONE; +} +/*[clinic input] +_csv.unregister_dialect +name: object +Delete the name/dialect mapping associated with a string name. +[clinic start generated code]*/ +static PyObject * +_csv_unregister_dialect_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=0813ebca6c058df4 input=e1cf81bfe3ba0f62]*/ +{ +_csvstate *module_state = get_csv_state(module); +int rc = PyDict_Pop(module_state->dialects, name, NULL); +if (rc < 0) { +return NULL; +} +if (rc == 0) { +PyErr_Format(module_state->error_obj, "unknown dialect"); +return NULL; +} +Py_RETURN_NONE; +} +/*[clinic input] +_csv.get_dialect +name: object +Return the dialect instance associated with name. +[clinic start generated code]*/ +static PyObject * +_csv_get_dialect_impl(PyObject *module, PyObject *name) +/*[clinic end generated code: output=aa988cd573bebebb input=74865c659dcb441f]*/ +{ +return get_dialect_from_registry(name, get_csv_state(module)); +} +/*[clinic input] +_csv.field_size_limit +new_limit: object = NULL +Sets an upper limit on parsed fields. +Returns old limit. If limit is not given, no new limit is set and +the old limit is returned +[clinic start generated code]*/ +static PyObject * +_csv_field_size_limit_impl(PyObject *module, PyObject *new_limit) +/*[clinic end generated code: output=f2799ecd908e250b input=77db7485ee3ae90a]*/ +{ +_csvstate *module_state = get_csv_state(module); +Py_ssize_t old_limit = FT_ATOMIC_LOAD_SSIZE_RELAXED(module_state->field_limit); +if (new_limit != NULL) { +if (!PyLong_CheckExact(new_limit)) { +PyErr_Format(PyExc_TypeError, +"limit must be an integer"); +return NULL; +} +Py_ssize_t new_limit_value = PyLong_AsSsize_t(new_limit); +if (new_limit_value == -1 && PyErr_Occurred()) { +return NULL; +} +FT_ATOMIC_STORE_SSIZE_RELAXED(module_state->field_limit, new_limit_value); +} +return PyLong_FromSsize_t(old_limit); +} +static PyType_Slot error_slots[] = { +{0, NULL}, +}; +PyType_Spec error_spec = { +.name = "_csv.Error", +.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, +.slots = error_slots, +}; +/* +* MODULE +*/ +PyDoc_STRVAR(csv_module_doc, "CSV parsing and writing.\n"); +PyDoc_STRVAR(csv_reader_doc, +"reader($module, iterable, /, dialect='excel', **fmtparams)\n" +"--\n\n" +"Return a reader object that will process lines from the given iterable.\n" +"\n" +"The \"iterable\" argument can be any object that returns a line\n" +"of input for each iteration, such as a file object or a list. The\n" +"optional \"dialect\" argument defines a CSV dialect. The function\n" +"also accepts optional keyword arguments which override settings\n" +"provided by the dialect.\n" +"\n" +"The returned object is an iterator. Each iteration returns a row\n" +"of the CSV file (which can span multiple input lines).\n"); +PyDoc_STRVAR(csv_writer_doc, +"writer($module, fileobj, /, dialect='excel', **fmtparams)\n" +"--\n\n" +"Return a writer object that will write user data on the given file object.\n" +"\n" +"The \"fileobj\" argument can be any object that supports the file API.\n" +"The optional \"dialect\" argument defines a CSV dialect. The function\n" +"also accepts optional keyword arguments which override settings\n" +"provided by the dialect.\n"); +PyDoc_STRVAR(csv_register_dialect_doc, +"register_dialect($module, name, /, dialect='excel', **fmtparams)\n" +"--\n\n" +"Create a mapping from a string name to a CVS dialect.\n" +"\n" +"The optional \"dialect\" argument specifies the base dialect instance\n" +"or the name of the registered dialect. The function also accepts\n" +"optional keyword arguments which override settings provided by the\n" +"dialect.\n"); +static struct PyMethodDef csv_methods[] = { +{ "reader", _PyCFunction_CAST(csv_reader), +METH_VARARGS | METH_KEYWORDS, csv_reader_doc}, +{ "writer", _PyCFunction_CAST(csv_writer), +METH_VARARGS | METH_KEYWORDS, csv_writer_doc}, +{ "register_dialect", _PyCFunction_CAST(csv_register_dialect), +METH_VARARGS | METH_KEYWORDS, csv_register_dialect_doc}, +_CSV_LIST_DIALECTS_METHODDEF +_CSV_UNREGISTER_DIALECT_METHODDEF +_CSV_GET_DIALECT_METHODDEF +_CSV_FIELD_SIZE_LIMIT_METHODDEF +{ NULL, NULL } +}; +static int +csv_exec(PyObject *module) { +const StyleDesc *style; +PyObject *temp; +_csvstate *module_state = get_csv_state(module); +temp = PyType_FromModuleAndSpec(module, &Dialect_Type_spec, NULL); +module_state->dialect_type = (PyTypeObject *)temp; +if (PyModule_AddObjectRef(module, "Dialect", temp) < 0) { +return -1; +} +temp = PyType_FromModuleAndSpec(module, &Reader_Type_spec, NULL); +module_state->reader_type = (PyTypeObject *)temp; +if (PyModule_AddObjectRef(module, "Reader", temp) < 0) { +return -1; +} +temp = PyType_FromModuleAndSpec(module, &Writer_Type_spec, NULL); +module_state->writer_type = (PyTypeObject *)temp; +if (PyModule_AddObjectRef(module, "Writer", temp) < 0) { +return -1; +} +/* Set the field limit */ +module_state->field_limit = 128 * 1024; +/* Add _dialects dictionary */ +module_state->dialects = PyDict_New(); +if (PyModule_AddObjectRef(module, "_dialects", module_state->dialects) < 0) { +return -1; +} +/* Add quote styles into dictionary */ +for (style = quote_styles; style->name; style++) { +if (PyModule_AddIntConstant(module, style->name, +style->style) == -1) +return -1; +} +/* Add the CSV exception object to the module. */ +PyObject *bases = PyTuple_Pack(1, PyExc_Exception); +if (bases == NULL) { +return -1; +} +module_state->error_obj = PyType_FromModuleAndSpec(module, &error_spec, +bases); +Py_DECREF(bases); +if (module_state->error_obj == NULL) { +return -1; +} +if (PyModule_AddType(module, (PyTypeObject *)module_state->error_obj) != 0) { +return -1; +} +module_state->str_write = PyUnicode_InternFromString("write"); +if (module_state->str_write == NULL) { +return -1; +} +return 0; +} +static PyModuleDef_Slot csv_slots[] = { +{Py_mod_exec, csv_exec}, +{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, +{Py_mod_gil, Py_MOD_GIL_NOT_USED}, +{0, NULL} +}; +static struct PyModuleDef _csvmodule = { +PyModuleDef_HEAD_INIT, +"_csv", +csv_module_doc, +sizeof(_csvstate), +csv_methods, +csv_slots, +_csv_traverse, +_csv_clear, +_csv_free +}; +PyMODINIT_FUNC +PyInit__csv(void) +{ +return PyModuleDef_Init(&_csvmodule); +} + +/* +* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* 3. Neither the name of the project nor the names of its contributors +* may be used to endorse or promote products derived from this software +* without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND +* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE +* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +* SUCH DAMAGE. +*/ +/* +* Issues to be discussed: +* - Thread safe-ness must be checked +* - Return values. There seems to be no standard for return value (RFC2133) +* but INRIA implementation returns EAI_xxx defined for getaddrinfo(). +*/ +#if 0 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "addrinfo.h" +#endif +#ifdef HAVE_NETDB_H +#define HAVE_GETNAMEINFO 1 +#define SUCCESS 0 +#define YES 1 +#define NO 0 +static struct gni_afd { +int a_af; +int a_addrlen; +int a_socklen; +int a_off; +} gni_afdl [] = { +#ifdef ENABLE_IPV6 +{PF_INET6, sizeof(struct in6_addr), sizeof(struct sockaddr_in6), +offsetof(struct sockaddr_in6, sin6_addr)}, +#endif +{PF_INET, sizeof(struct in_addr), sizeof(struct sockaddr_in), +offsetof(struct sockaddr_in, sin_addr)}, +{0, 0, 0}, +}; +struct gni_sockinet { +u_char si_len; +u_char si_family; +u_short si_port; +}; +#define ENI_NOSOCKET 0 +#define ENI_NOSERVNAME 1 +#define ENI_NOHOSTNAME 2 +#define ENI_MEMORY 3 +#define ENI_SYSTEM 4 +#define ENI_FAMILY 5 +#define ENI_SALEN 6 +int +getnameinfo(const struct sockaddr *sa, size_t salen, char *host, size_t hostlen, +char *serv, size_t servlen, int flags) +{ +struct gni_afd *gni_afd; +struct servent *sp; +struct hostent *hp; +u_short port; +int family, len, i; +char *addr, *p; +u_long v4a; +#ifdef ENABLE_IPV6 +u_char pfx; +int h_error; +#endif +char numserv[512]; +char numaddr[512]; +if (sa == NULL) +return ENI_NOSOCKET; +#ifdef HAVE_SOCKADDR_SA_LEN +len = sa->sa_len; +if (len != salen) return ENI_SALEN; +#else +len = salen; +#endif +family = sa->sa_family; +for (i = 0; gni_afdl[i].a_af; i++) +if (gni_afdl[i].a_af == family) { +gni_afd = &gni_afdl[i]; +goto found; +} +return ENI_FAMILY; +found: +if (len != gni_afd->a_socklen) return ENI_SALEN; +port = ((struct gni_sockinet *)sa)->si_port; /* network byte order */ +addr = (char *)sa + gni_afd->a_off; +if (serv == NULL || servlen == 0) { +/* what we should do? */ +} else if (flags & NI_NUMERICSERV) { +sprintf(numserv, "%d", ntohs(port)); +if (strlen(numserv) > servlen) +return ENI_MEMORY; +strcpy(serv, numserv); +} else { +sp = getservbyport(port, (flags & NI_DGRAM) ? "udp" : "tcp"); +if (sp) { +if (strlen(sp->s_name) > servlen) +return ENI_MEMORY; +strcpy(serv, sp->s_name); +} else +return ENI_NOSERVNAME; +} +switch (sa->sa_family) { +case AF_INET: +v4a = ((struct sockaddr_in *)sa)->sin_addr.s_addr; +if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a)) +flags |= NI_NUMERICHOST; +v4a >>= IN_CLASSA_NSHIFT; +if (v4a == 0 || v4a == IN_LOOPBACKNET) +flags |= NI_NUMERICHOST; +break; +#ifdef ENABLE_IPV6 +case AF_INET6: +pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[0]; +if (pfx == 0 || pfx == 0xfe || pfx == 0xff) +flags |= NI_NUMERICHOST; +break; +#endif +} +if (host == NULL || hostlen == 0) { +/* what should we do? */ +} else if (flags & NI_NUMERICHOST) { +if (inet_ntop(gni_afd->a_af, addr, numaddr, sizeof(numaddr)) +== NULL) +return ENI_SYSTEM; +if (strlen(numaddr) > hostlen) +return ENI_MEMORY; +strcpy(host, numaddr); +} else { +#ifdef ENABLE_IPV6 +hp = getipnodebyaddr(addr, gni_afd->a_addrlen, gni_afd->a_af, &h_error); +#else +hp = gethostbyaddr(addr, gni_afd->a_addrlen, gni_afd->a_af); +#endif +if (hp) { +if (flags & NI_NOFQDN) { +p = strchr(hp->h_name, '.'); +if (p) *p = '\0'; +} +if (strlen(hp->h_name) > hostlen) { +#ifdef ENABLE_IPV6 +freehostent(hp); +#endif +return ENI_MEMORY; +} +strcpy(host, hp->h_name); +#ifdef ENABLE_IPV6 +freehostent(hp); +#endif +} else { +if (flags & NI_NAMEREQD) +return ENI_NOHOSTNAME; +if (inet_ntop(gni_afd->a_af, addr, numaddr, sizeof(numaddr)) +== NULL) +return ENI_NOHOSTNAME; +if (strlen(numaddr) > hostlen) +return ENI_MEMORY; +strcpy(host, numaddr); +} +} +return SUCCESS; +} +#endif // HAVE_NETDB_H + + +"""