mypy-dev 1.9.0.dev0__py3-none-any.whl

mypyc/lib-rt/bytes_ops.c

@@ -0,0 +1,143 @@
+// Bytes primitive operations
+//
+// These are registered in mypyc.primitives.bytes_ops.
+
+#include <Python.h>
+#include "CPy.h"
+
+// Returns -1 on error, 0 on inequality, 1 on equality.
+//
+// Falls back to PyObject_RichCompareBool.
+int CPyBytes_Compare(PyObject *left, PyObject *right) {
+    if (PyBytes_CheckExact(left) && PyBytes_CheckExact(right)) {
+        if (left == right) {
+            return 1;
+        }
+
+        // Adapted from cpython internal implementation of bytes_compare.
+        Py_ssize_t len = Py_SIZE(left);
+        if (Py_SIZE(right) != len) {
+            return 0;
+        }
+        PyBytesObject *left_b = (PyBytesObject *)left;
+        PyBytesObject *right_b = (PyBytesObject *)right;
+        if (left_b->ob_sval[0] != right_b->ob_sval[0]) {
+            return 0;
+        }
+
+        return memcmp(left_b->ob_sval, right_b->ob_sval, len) == 0;
+    }
+    return PyObject_RichCompareBool(left, right, Py_EQ);
+}
+
+CPyTagged CPyBytes_GetItem(PyObject *o, CPyTagged index) {
+    if (CPyTagged_CheckShort(index)) {
+        Py_ssize_t n = CPyTagged_ShortAsSsize_t(index);
+        Py_ssize_t size = ((PyVarObject *)o)->ob_size;
+        if (n < 0)
+            n += size;
+        if (n < 0 || n >= size) {
+            PyErr_SetString(PyExc_IndexError, "index out of range");
+            return CPY_INT_TAG;
+        }
+        unsigned char num = PyBytes_Check(o) ? ((PyBytesObject *)o)->ob_sval[n]
+                                             : ((PyByteArrayObject *)o)->ob_bytes[n];
+        return num << 1;
+    } else {
+        PyErr_SetString(PyExc_OverflowError, CPYTHON_LARGE_INT_ERRMSG);
+        return CPY_INT_TAG;
+    }
+}
+
+PyObject *CPyBytes_Concat(PyObject *a, PyObject *b) {
+    if (PyBytes_Check(a) && PyBytes_Check(b)) {
+        Py_ssize_t a_len = ((PyVarObject *)a)->ob_size;
+        Py_ssize_t b_len = ((PyVarObject *)b)->ob_size;
+        PyBytesObject *ret = (PyBytesObject *)PyBytes_FromStringAndSize(NULL, a_len + b_len);
+        if (ret != NULL) {
+            memcpy(ret->ob_sval, ((PyBytesObject *)a)->ob_sval, a_len);
+            memcpy(ret->ob_sval + a_len, ((PyBytesObject *)b)->ob_sval, b_len);
+        }
+        return (PyObject *)ret;
+    } else if (PyByteArray_Check(a)) {
+        return PyByteArray_Concat(a, b);
+    } else {
+        PyBytes_Concat(&a, b);
+        return a;
+    }
+}
+
+static inline Py_ssize_t Clamp(Py_ssize_t a, Py_ssize_t b, Py_ssize_t c) {
+    return a < b ? b : (a >= c ? c : a);
+}
+
+PyObject *CPyBytes_GetSlice(PyObject *obj, CPyTagged start, CPyTagged end) {
+    if ((PyBytes_Check(obj) || PyByteArray_Check(obj))
+            && CPyTagged_CheckShort(start) && CPyTagged_CheckShort(end)) {
+        Py_ssize_t startn = CPyTagged_ShortAsSsize_t(start);
+        Py_ssize_t endn = CPyTagged_ShortAsSsize_t(end);
+        Py_ssize_t len = ((PyVarObject *)obj)->ob_size;
+        if (startn < 0) {
+            startn += len;
+        }
+        if (endn < 0) {
+            endn += len;
+        }
+        startn = Clamp(startn, 0, len);
+        endn = Clamp(endn, 0, len);
+        Py_ssize_t slice_len = endn - startn;
+        if (PyBytes_Check(obj)) {
+            return PyBytes_FromStringAndSize(PyBytes_AS_STRING(obj) + startn, slice_len);
+        } else {
+            return PyByteArray_FromStringAndSize(PyByteArray_AS_STRING(obj) + startn, slice_len);
+        }
+    }
+    return CPyObject_GetSlice(obj, start, end);
+}
+
+// Like _PyBytes_Join but fallback to dynamic call if 'sep' is not bytes
+// (mostly commonly, for bytearrays)
+PyObject *CPyBytes_Join(PyObject *sep, PyObject *iter) {
+    if (PyBytes_CheckExact(sep)) {
+        return _PyBytes_Join(sep, iter);
+    } else {
+        _Py_IDENTIFIER(join);
+        return _PyObject_CallMethodIdOneArg(sep, &PyId_join, iter);
+    }
+}
+
+PyObject *CPyBytes_Build(Py_ssize_t len, ...) {
+    Py_ssize_t i;
+    Py_ssize_t sz = 0;
+
+    va_list args;
+    va_start(args, len);
+    for (i = 0; i < len; i++) {
+        PyObject *item = va_arg(args, PyObject *);
+        size_t add_sz = ((PyVarObject *)item)->ob_size;
+        // Using size_t to avoid overflow during arithmetic calculation
+        if (add_sz > (size_t)(PY_SSIZE_T_MAX - sz)) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "join() result is too long for a Python bytes");
+            return NULL;
+        }
+        sz += add_sz;
+    }
+    va_end(args);
+
+    PyBytesObject *ret = (PyBytesObject *)PyBytes_FromStringAndSize(NULL, sz);
+    if (ret != NULL) {
+        char *res_data = ret->ob_sval;
+        va_start(args, len);
+        for (i = 0; i < len; i++) {
+            PyObject *item = va_arg(args, PyObject *);
+            Py_ssize_t item_sz = ((PyVarObject *)item)->ob_size;
+            memcpy(res_data, ((PyBytesObject *)item)->ob_sval, item_sz);
+            res_data += item_sz;
+        }
+        va_end(args);
+        assert(res_data == ret->ob_sval + ((PyVarObject *)ret)->ob_size);
+    }
+
+    return (PyObject *)ret;
+}

mypyc/lib-rt/dict_ops.c

@@ -0,0 +1,446 @@
+// Dict primitive operations
+//
+// These are registered in mypyc.primitives.dict_ops.
+
+#include <Python.h>
+#include "CPy.h"
+
+#ifndef Py_TPFLAGS_MAPPING
+#define Py_TPFLAGS_MAPPING (1 << 6)
+#endif
+
+// Dict subclasses like defaultdict override things in interesting
+// ways, so we don't want to just directly use the dict methods. Not
+// sure if it is actually worth doing all this stuff, but it saves
+// some indirections.
+PyObject *CPyDict_GetItem(PyObject *dict, PyObject *key) {
+    if (PyDict_CheckExact(dict)) {
+        PyObject *res = PyDict_GetItemWithError(dict, key);
+        if (!res) {
+            if (!PyErr_Occurred()) {
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
+        } else {
+            Py_INCREF(res);
+        }
+        return res;
+    } else {
+        return PyObject_GetItem(dict, key);
+    }
+}
+
+PyObject *CPyDict_Build(Py_ssize_t size, ...) {
+    Py_ssize_t i;
+
+    PyObject *res = _PyDict_NewPresized(size);
+    if (res == NULL) {
+        return NULL;
+    }
+
+    va_list args;
+    va_start(args, size);
+
+    for (i = 0; i < size; i++) {
+        PyObject *key = va_arg(args, PyObject *);
+        PyObject *value = va_arg(args, PyObject *);
+        if (PyDict_SetItem(res, key, value)) {
+            Py_DECREF(res);
+            return NULL;
+        }
+    }
+
+    va_end(args);
+    return res;
+}
+
+PyObject *CPyDict_Get(PyObject *dict, PyObject *key, PyObject *fallback) {
+    // We are dodgily assuming that get on a subclass doesn't have
+    // different behavior.
+    PyObject *res = PyDict_GetItemWithError(dict, key);
+    if (!res) {
+        if (PyErr_Occurred()) {
+            return NULL;
+        }
+        res = fallback;
+    }
+    Py_INCREF(res);
+    return res;
+}
+
+PyObject *CPyDict_GetWithNone(PyObject *dict, PyObject *key) {
+    return CPyDict_Get(dict, key, Py_None);
+}
+
+PyObject *CPyDict_SetDefault(PyObject *dict, PyObject *key, PyObject *value) {
+    if (PyDict_CheckExact(dict)) {
+        PyObject* ret = PyDict_SetDefault(dict, key, value);
+        Py_XINCREF(ret);
+        return ret;
+    }
+    _Py_IDENTIFIER(setdefault);
+    return _PyObject_CallMethodIdObjArgs(dict, &PyId_setdefault, key, value, NULL);
+}
+
+PyObject *CPyDict_SetDefaultWithNone(PyObject *dict, PyObject *key) {
+    return CPyDict_SetDefault(dict, key, Py_None);
+}
+
+PyObject *CPyDict_SetDefaultWithEmptyDatatype(PyObject *dict, PyObject *key,
+                                              int data_type) {
+    PyObject *res = CPyDict_GetItem(dict, key);
+    if (!res) {
+        // CPyDict_GetItem() would generates a PyExc_KeyError
+        // when key is not found.
+        PyErr_Clear();
+
+        PyObject *new_obj;
+        if (data_type == 1) {
+            new_obj = PyList_New(0);
+        } else if (data_type == 2) {
+            new_obj = PyDict_New();
+        } else if (data_type == 3) {
+            new_obj = PySet_New(NULL);
+        } else {
+            return NULL;
+        }
+
+        if (CPyDict_SetItem(dict, key, new_obj) == -1) {
+            return NULL;
+        } else {
+            return new_obj;
+        }
+    } else {
+        return res;
+    }
+}
+
+int CPyDict_SetItem(PyObject *dict, PyObject *key, PyObject *value) {
+    if (PyDict_CheckExact(dict)) {
+        return PyDict_SetItem(dict, key, value);
+    } else {
+        return PyObject_SetItem(dict, key, value);
+    }
+}
+
+static inline int CPy_ObjectToStatus(PyObject *obj) {
+    if (obj) {
+        Py_DECREF(obj);
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+static int CPyDict_UpdateGeneral(PyObject *dict, PyObject *stuff) {
+    _Py_IDENTIFIER(update);
+    PyObject *res = _PyObject_CallMethodIdOneArg(dict, &PyId_update, stuff);
+    return CPy_ObjectToStatus(res);
+}
+
+int CPyDict_UpdateInDisplay(PyObject *dict, PyObject *stuff) {
+    // from https://github.com/python/cpython/blob/55d035113dfb1bd90495c8571758f504ae8d4802/Python/ceval.c#L2710
+    int ret = PyDict_Update(dict, stuff);
+    if (ret < 0) {
+        if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            PyErr_Format(PyExc_TypeError,
+                         "'%.200s' object is not a mapping",
+                         Py_TYPE(stuff)->tp_name);
+        }
+    }
+    return ret;
+}
+
+int CPyDict_Update(PyObject *dict, PyObject *stuff) {
+    if (PyDict_CheckExact(dict)) {
+        return PyDict_Update(dict, stuff);
+    } else {
+        return CPyDict_UpdateGeneral(dict, stuff);
+    }
+}
+
+int CPyDict_UpdateFromAny(PyObject *dict, PyObject *stuff) {
+    if (PyDict_CheckExact(dict)) {
+        // Argh this sucks
+        _Py_IDENTIFIER(keys);
+        if (PyDict_Check(stuff) || _CPyObject_HasAttrId(stuff, &PyId_keys)) {
+            return PyDict_Update(dict, stuff);
+        } else {
+            return PyDict_MergeFromSeq2(dict, stuff, 1);
+        }
+    } else {
+        return CPyDict_UpdateGeneral(dict, stuff);
+    }
+}
+
+PyObject *CPyDict_FromAny(PyObject *obj) {
+    if (PyDict_Check(obj)) {
+        return PyDict_Copy(obj);
+    } else {
+        int res;
+        PyObject *dict = PyDict_New();
+        if (!dict) {
+            return NULL;
+        }
+        _Py_IDENTIFIER(keys);
+        if (_CPyObject_HasAttrId(obj, &PyId_keys)) {
+            res = PyDict_Update(dict, obj);
+        } else {
+            res = PyDict_MergeFromSeq2(dict, obj, 1);
+        }
+        if (res < 0) {
+            Py_DECREF(dict);
+            return NULL;
+        }
+        return dict;
+    }
+}
+
+PyObject *CPyDict_KeysView(PyObject *dict) {
+    if (PyDict_CheckExact(dict)){
+        return _CPyDictView_New(dict, &PyDictKeys_Type);
+    }
+    _Py_IDENTIFIER(keys);
+    return _PyObject_CallMethodIdNoArgs(dict, &PyId_keys);
+}
+
+PyObject *CPyDict_ValuesView(PyObject *dict) {
+    if (PyDict_CheckExact(dict)){
+        return _CPyDictView_New(dict, &PyDictValues_Type);
+    }
+    _Py_IDENTIFIER(values);
+    return _PyObject_CallMethodIdNoArgs(dict, &PyId_values);
+}
+
+PyObject *CPyDict_ItemsView(PyObject *dict) {
+    if (PyDict_CheckExact(dict)){
+        return _CPyDictView_New(dict, &PyDictItems_Type);
+    }
+    _Py_IDENTIFIER(items);
+    return _PyObject_CallMethodIdNoArgs(dict, &PyId_items);
+}
+
+PyObject *CPyDict_Keys(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        return PyDict_Keys(dict);
+    }
+    // Inline generic fallback logic to also return a list.
+    PyObject *list = PyList_New(0);
+    _Py_IDENTIFIER(keys);
+    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_keys);
+    if (view == NULL) {
+        return NULL;
+    }
+    PyObject *res = _PyList_Extend((PyListObject *)list, view);
+    Py_DECREF(view);
+    if (res == NULL) {
+        return NULL;
+    }
+    Py_DECREF(res);
+    return list;
+}
+
+PyObject *CPyDict_Values(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        return PyDict_Values(dict);
+    }
+    // Inline generic fallback logic to also return a list.
+    PyObject *list = PyList_New(0);
+    _Py_IDENTIFIER(values);
+    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_values);
+    if (view == NULL) {
+        return NULL;
+    }
+    PyObject *res = _PyList_Extend((PyListObject *)list, view);
+    Py_DECREF(view);
+    if (res == NULL) {
+        return NULL;
+    }
+    Py_DECREF(res);
+    return list;
+}
+
+PyObject *CPyDict_Items(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        return PyDict_Items(dict);
+    }
+    // Inline generic fallback logic to also return a list.
+    PyObject *list = PyList_New(0);
+    _Py_IDENTIFIER(items);
+    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_items);
+    if (view == NULL) {
+        return NULL;
+    }
+    PyObject *res = _PyList_Extend((PyListObject *)list, view);
+    Py_DECREF(view);
+    if (res == NULL) {
+        return NULL;
+    }
+    Py_DECREF(res);
+    return list;
+}
+
+char CPyDict_Clear(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        PyDict_Clear(dict);
+    } else {
+        _Py_IDENTIFIER(clear);
+        PyObject *res = _PyObject_CallMethodIdNoArgs(dict, &PyId_clear);
+        if (res == NULL) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+PyObject *CPyDict_Copy(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        return PyDict_Copy(dict);
+    }
+    _Py_IDENTIFIER(copy);
+    return _PyObject_CallMethodIdNoArgs(dict, &PyId_copy);
+}
+
+PyObject *CPyDict_GetKeysIter(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        // Return dict itself to indicate we can use fast path instead.
+        Py_INCREF(dict);
+        return dict;
+    }
+    return PyObject_GetIter(dict);
+}
+
+PyObject *CPyDict_GetItemsIter(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        // Return dict itself to indicate we can use fast path instead.
+        Py_INCREF(dict);
+        return dict;
+    }
+    _Py_IDENTIFIER(items);
+    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_items);
+    if (view == NULL) {
+        return NULL;
+    }
+    PyObject *iter = PyObject_GetIter(view);
+    Py_DECREF(view);
+    return iter;
+}
+
+PyObject *CPyDict_GetValuesIter(PyObject *dict) {
+    if (PyDict_CheckExact(dict)) {
+        // Return dict itself to indicate we can use fast path instead.
+        Py_INCREF(dict);
+        return dict;
+    }
+    _Py_IDENTIFIER(values);
+    PyObject *view = _PyObject_CallMethodIdNoArgs(dict, &PyId_values);
+    if (view == NULL) {
+        return NULL;
+    }
+    PyObject *iter = PyObject_GetIter(view);
+    Py_DECREF(view);
+    return iter;
+}
+
+static void _CPyDict_FromNext(tuple_T3CIO *ret, PyObject *dict_iter) {
+    // Get next item from iterator and set "should continue" flag.
+    ret->f2 = PyIter_Next(dict_iter);
+    if (ret->f2 == NULL) {
+        ret->f0 = 0;
+        Py_INCREF(Py_None);
+        ret->f2 = Py_None;
+    } else {
+        ret->f0 = 1;
+    }
+}
+
+// Helpers for fast dictionary iteration, return a single tuple
+// instead of writing to multiple registers, for exact dicts use
+// the fast path, and fall back to generic iterator logic for subclasses.
+tuple_T3CIO CPyDict_NextKey(PyObject *dict_or_iter, CPyTagged offset) {
+    tuple_T3CIO ret;
+    Py_ssize_t py_offset = CPyTagged_AsSsize_t(offset);
+    PyObject *dummy;
+
+    if (PyDict_CheckExact(dict_or_iter)) {
+        ret.f0 = PyDict_Next(dict_or_iter, &py_offset, &ret.f2, &dummy);
+        if (ret.f0) {
+            ret.f1 = CPyTagged_FromSsize_t(py_offset);
+        } else {
+            // Set key to None, so mypyc can manage refcounts.
+            ret.f1 = 0;
+            ret.f2 = Py_None;
+        }
+        // PyDict_Next() returns borrowed references.
+        Py_INCREF(ret.f2);
+    } else {
+        // offset is dummy in this case, just use the old value.
+        ret.f1 = offset;
+        _CPyDict_FromNext(&ret, dict_or_iter);
+    }
+    return ret;
+}
+
+tuple_T3CIO CPyDict_NextValue(PyObject *dict_or_iter, CPyTagged offset) {
+    tuple_T3CIO ret;
+    Py_ssize_t py_offset = CPyTagged_AsSsize_t(offset);
+    PyObject *dummy;
+
+    if (PyDict_CheckExact(dict_or_iter)) {
+        ret.f0 = PyDict_Next(dict_or_iter, &py_offset, &dummy, &ret.f2);
+        if (ret.f0) {
+            ret.f1 = CPyTagged_FromSsize_t(py_offset);
+        } else {
+            // Set value to None, so mypyc can manage refcounts.
+            ret.f1 = 0;
+            ret.f2 = Py_None;
+        }
+        // PyDict_Next() returns borrowed references.
+        Py_INCREF(ret.f2);
+    } else {
+        // offset is dummy in this case, just use the old value.
+        ret.f1 = offset;
+        _CPyDict_FromNext(&ret, dict_or_iter);
+    }
+    return ret;
+}
+
+tuple_T4CIOO CPyDict_NextItem(PyObject *dict_or_iter, CPyTagged offset) {
+    tuple_T4CIOO ret;
+    Py_ssize_t py_offset = CPyTagged_AsSsize_t(offset);
+
+    if (PyDict_CheckExact(dict_or_iter)) {
+        ret.f0 = PyDict_Next(dict_or_iter, &py_offset, &ret.f2, &ret.f3);
+        if (ret.f0) {
+            ret.f1 = CPyTagged_FromSsize_t(py_offset);
+        } else {
+            // Set key and value to None, so mypyc can manage refcounts.
+            ret.f1 = 0;
+            ret.f2 = Py_None;
+            ret.f3 = Py_None;
+        }
+    } else {
+        ret.f1 = offset;
+        PyObject *item = PyIter_Next(dict_or_iter);
+        if (item == NULL || !PyTuple_Check(item) || PyTuple_GET_SIZE(item) != 2) {
+            if (item != NULL) {
+                PyErr_SetString(PyExc_TypeError, "a tuple of length 2 expected");
+            }
+            ret.f0 = 0;
+            ret.f2 = Py_None;
+            ret.f3 = Py_None;
+        } else {
+            ret.f0 = 1;
+            ret.f2 = PyTuple_GET_ITEM(item, 0);
+            ret.f3 = PyTuple_GET_ITEM(item, 1);
+            Py_DECREF(item);
+        }
+    }
+    // PyDict_Next() returns borrowed references.
+    Py_INCREF(ret.f2);
+    Py_INCREF(ret.f3);
+    return ret;
+}
+
+int CPyMapping_Check(PyObject *obj) {
+    return Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MAPPING;
+}