From 57bf7d764e2ac46bfbb82587551da19f1bc7d088 Mon Sep 17 00:00:00 2001 From: Jukka Lehtosalo Date: Wed, 4 Nov 2026 17:22:43 +0000 Subject: [PATCH] [mypyc] Support i8, u16, u32 and u64 as vec item types Add specialized vec types with packed item buffers for the new native integer types, similar to vec[i16] and vec[u8]. Previously mypyc crashed when compiling code that used these as vec item types, and they failed at runtime in interpreted code. Append the new item type APIs to the end of the capsule struct, and bump the librt.vecs API version to 2. librt.vecs now requires mypy-extensions 1.2.0 or newer, since older versions don't define the new native integer types. --- mypyc/build.py | 4 + mypyc/codegen/emit.py | 4 + mypyc/codegen/emitfunc.py | 4 + mypyc/doc/librt_vecs.rst | 4 + mypyc/ir/rtypes.py | 42 +++ mypyc/lib-rt/setup.py | 4 + mypyc/lib-rt/vecs/librt_vecs.c | 287 ++++++++++++++- mypyc/lib-rt/vecs/librt_vecs.h | 418 +++++++++++++++++++++- mypyc/lib-rt/vecs/librt_vecs_api.c | 8 + mypyc/lib-rt/vecs/librt_vecs_api.h | 4 + mypyc/lib-rt/vecs/vec_i8.c | 19 + mypyc/lib-rt/vecs/vec_u16.c | 19 + mypyc/lib-rt/vecs/vec_u32.c | 19 + mypyc/lib-rt/vecs/vec_u64.c | 19 + mypyc/test-data/irbuild-vec-misc.test | 102 ++++++ mypyc/test-data/run-vecs-misc-interp.test | 172 ++++++++- mypyc/test-data/run-vecs-misc.test | 359 +++++++++++++++++++ 17 files changed, 1476 insertions(+), 12 deletions(-) create mode 100644 mypyc/lib-rt/vecs/vec_i8.c create mode 100644 mypyc/lib-rt/vecs/vec_u16.c create mode 100644 mypyc/lib-rt/vecs/vec_u32.c create mode 100644 mypyc/lib-rt/vecs/vec_u64.c diff --git a/mypyc/build.py b/mypyc/build.py index 9050eef18d270..8cb71c69c3f27 100644 --- a/mypyc/build.py +++ b/mypyc/build.py @@ -119,6 +119,10 @@ class ModDesc(NamedTuple): "vecs/vec_i64.c", "vecs/vec_i32.c", "vecs/vec_i16.c", + "vecs/vec_i8.c", + "vecs/vec_u64.c", + "vecs/vec_u32.c", + "vecs/vec_u16.c", "vecs/vec_u8.c", "vecs/vec_float.c", "vecs/vec_bool.c", diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py index 3fd0f44acead2..c018307d56450 100644 --- a/mypyc/codegen/emit.py +++ b/mypyc/codegen/emit.py @@ -95,6 +95,10 @@ "VecI64": "VEC_I64", "VecI32": "VEC_I32", "VecI16": "VEC_I16", + "VecI8": "VEC_I8", + "VecU64": "VEC_U64", + "VecU32": "VEC_U32", + "VecU16": "VEC_U16", "VecU8": "VEC_U8", "VecFloat": "VEC_FLOAT", "VecBool": "VEC_BOOL", diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py index 14be734866f8a..62013e0c34990 100644 --- a/mypyc/codegen/emitfunc.py +++ b/mypyc/codegen/emitfunc.py @@ -98,6 +98,10 @@ "VecI64": "int64_t *", "VecI32": "int32_t *", "VecI16": "int16_t *", + "VecI8": "int8_t *", + "VecU64": "uint64_t *", + "VecU32": "uint32_t *", + "VecU16": "uint16_t *", "VecU8": "uint8_t *", "VecFloat": "double *", "VecBool": "char *", diff --git a/mypyc/doc/librt_vecs.rst b/mypyc/doc/librt_vecs.rst index a7f5bc3ffbd96..fb7b9ba4ce462 100644 --- a/mypyc/doc/librt_vecs.rst +++ b/mypyc/doc/librt_vecs.rst @@ -32,6 +32,10 @@ for these *value item types*: * ``mypy_extensions.i64`` (signed 64-bit integer) * ``mypy_extensions.i32`` (signed 32-bit integer) * ``mypy_extensions.i16`` (signed 16-bit integer) +* ``mypy_extensions.i8`` (signed 8-bit integer) +* ``mypy_extensions.u64`` (unsigned 64-bit integer) +* ``mypy_extensions.u32`` (unsigned 32-bit integer) +* ``mypy_extensions.u16`` (unsigned 16-bit integer) * ``mypy_extensions.u8`` (unsigned byte) * ``float`` (64-bit float) * ``bool`` diff --git a/mypyc/ir/rtypes.py b/mypyc/ir/rtypes.py index 18b37f0fcb641..9bfd333cc8900 100644 --- a/mypyc/ir/rtypes.py +++ b/mypyc/ir/rtypes.py @@ -1439,6 +1439,28 @@ def check_native_int_range(rtype: RPrimitive, n: int) -> bool: types=[PyVarObject, int64_rprimitive], ) +VecI8BufObject = RStruct( + name="VecI8BufObject", names=["ob_base", "len", "items"], types=[PyVarObject, int64_rprimitive] +) + +VecU64BufObject = RStruct( + name="VecU64BufObject", + names=["ob_base", "len", "items"], + types=[PyVarObject, int64_rprimitive], +) + +VecU32BufObject = RStruct( + name="VecU32BufObject", + names=["ob_base", "len", "items"], + types=[PyVarObject, int64_rprimitive], +) + +VecU16BufObject = RStruct( + name="VecU16BufObject", + names=["ob_base", "len", "items"], + types=[PyVarObject, int64_rprimitive], +) + VecU8BufObject = RStruct( name="VecU8BufObject", names=["ob_base", "len", "items"], types=[PyVarObject, int64_rprimitive] ) @@ -1511,6 +1533,10 @@ def check_native_int_range(rtype: RPrimitive, n: int) -> bool: int64_rprimitive: VecI64BufObject, int32_rprimitive: VecI32BufObject, int16_rprimitive: VecI16BufObject, + int8_rprimitive: VecI8BufObject, + uint64_rprimitive: VecU64BufObject, + uint32_rprimitive: VecU32BufObject, + uint16_rprimitive: VecU16BufObject, uint8_rprimitive: VecU8BufObject, float_rprimitive: VecFloatBufObject, bool_rprimitive: VecBoolBufObject, @@ -1520,6 +1546,10 @@ def check_native_int_range(rtype: RPrimitive, n: int) -> bool: int64_rprimitive: "VecI64", int32_rprimitive: "VecI32", int16_rprimitive: "VecI16", + int8_rprimitive: "VecI8", + uint64_rprimitive: "VecU64", + uint32_rprimitive: "VecU32", + uint16_rprimitive: "VecU16", uint8_rprimitive: "VecU8", float_rprimitive: "VecFloat", bool_rprimitive: "VecBool", @@ -1529,6 +1559,10 @@ def check_native_int_range(rtype: RPrimitive, n: int) -> bool: int64_rprimitive: "i64", int32_rprimitive: "i32", int16_rprimitive: "i16", + int8_rprimitive: "i8", + uint64_rprimitive: "u64", + uint32_rprimitive: "u32", + uint16_rprimitive: "u16", uint8_rprimitive: "u8", float_rprimitive: "float_", bool_rprimitive: "bool_", @@ -1538,6 +1572,10 @@ def check_native_int_range(rtype: RPrimitive, n: int) -> bool: int64_rprimitive: "VecI64Api", int32_rprimitive: "VecI32Api", int16_rprimitive: "VecI16Api", + int8_rprimitive: "VecI8Api", + uint64_rprimitive: "VecU64Api", + uint32_rprimitive: "VecU32Api", + uint16_rprimitive: "VecU16Api", uint8_rprimitive: "VecU8Api", float_rprimitive: "VecFloatApi", bool_rprimitive: "VecBoolApi", @@ -1550,6 +1588,10 @@ def check_native_int_range(rtype: RPrimitive, n: int) -> bool: int64_rprimitive: 2, int32_rprimitive: 6, int16_rprimitive: 10, + int8_rprimitive: 26, + uint64_rprimitive: 30, + uint32_rprimitive: 34, + uint16_rprimitive: 38, uint8_rprimitive: 14, float_rprimitive: 18, bool_rprimitive: 22, diff --git a/mypyc/lib-rt/setup.py b/mypyc/lib-rt/setup.py index 15d31a443ff86..4c479f5bfc7e6 100644 --- a/mypyc/lib-rt/setup.py +++ b/mypyc/lib-rt/setup.py @@ -139,6 +139,10 @@ def run(self) -> None: "vecs/vec_i64.c", "vecs/vec_i32.c", "vecs/vec_i16.c", + "vecs/vec_i8.c", + "vecs/vec_u64.c", + "vecs/vec_u32.c", + "vecs/vec_u16.c", "vecs/vec_u8.c", "vecs/vec_float.c", "vecs/vec_bool.c", diff --git a/mypyc/lib-rt/vecs/librt_vecs.c b/mypyc/lib-rt/vecs/librt_vecs.c index 88ff47fdda807..5db20effc26e2 100644 --- a/mypyc/lib-rt/vecs/librt_vecs.c +++ b/mypyc/lib-rt/vecs/librt_vecs.c @@ -77,6 +77,10 @@ PyTypeObject *LibRTVecs_I64TypeObj; PyTypeObject *LibRTVecs_I32TypeObj; PyTypeObject *LibRTVecs_I16TypeObj; +PyTypeObject *LibRTVecs_I8TypeObj; +PyTypeObject *LibRTVecs_U64TypeObj; +PyTypeObject *LibRTVecs_U32TypeObj; +PyTypeObject *LibRTVecs_U16TypeObj; PyTypeObject *LibRTVecs_U8TypeObj; @@ -155,6 +159,12 @@ PyObject *Vec_TypeToStr(size_t item_type, size_t depth) { if (depth == 0) { if ((item_type & ~1) == VEC_ITEM_TYPE_I64) { item = PyUnicode_FromFormat("i64"); + } else if ((item_type & ~1) == VEC_ITEM_TYPE_U64) { + item = PyUnicode_FromFormat("u64"); + } else if ((item_type & ~1) == VEC_ITEM_TYPE_U32) { + item = PyUnicode_FromFormat("u32"); + } else if ((item_type & ~1) == VEC_ITEM_TYPE_U16) { + item = PyUnicode_FromFormat("u16"); } else if ((item_type & ~1) == VEC_ITEM_TYPE_U8) { item = PyUnicode_FromFormat("u8"); } else if ((item_type & ~1) == VEC_ITEM_TYPE_FLOAT) { @@ -163,6 +173,8 @@ PyObject *Vec_TypeToStr(size_t item_type, size_t depth) { item = PyUnicode_FromFormat("i32"); } else if ((item_type & ~1) == VEC_ITEM_TYPE_I16) { item = PyUnicode_FromFormat("i16"); + } else if ((item_type & ~1) == VEC_ITEM_TYPE_I8) { + item = PyUnicode_FromFormat("i8"); } else if ((item_type & ~1) == VEC_ITEM_TYPE_BOOL) { item = PyUnicode_FromFormat("bool"); } else { @@ -285,6 +297,15 @@ static PyObject *vec_class_getitem(PyObject *type, PyObject *item) if (item == (PyObject *)LibRTVecs_I64TypeObj) { Py_INCREF(&VecI64Type); return (PyObject *)&VecI64Type; + } else if (item == (PyObject *)LibRTVecs_U64TypeObj) { + Py_INCREF(&VecU64Type); + return (PyObject *)&VecU64Type; + } else if (item == (PyObject *)LibRTVecs_U32TypeObj) { + Py_INCREF(&VecU32Type); + return (PyObject *)&VecU32Type; + } else if (item == (PyObject *)LibRTVecs_U16TypeObj) { + Py_INCREF(&VecU16Type); + return (PyObject *)&VecU16Type; } else if (item == (PyObject *)LibRTVecs_U8TypeObj) { Py_INCREF(&VecU8Type); return (PyObject *)&VecU8Type; @@ -297,6 +318,9 @@ static PyObject *vec_class_getitem(PyObject *type, PyObject *item) } else if (item == (PyObject *)LibRTVecs_I16TypeObj) { Py_INCREF(&VecI16Type); return (PyObject *)&VecI16Type; + } else if (item == (PyObject *)LibRTVecs_I8TypeObj) { + Py_INCREF(&VecI8Type); + return (PyObject *)&VecI8Type; } else if (item == (PyObject *)&PyBool_Type) { Py_INCREF(&VecBoolType); return (PyObject *)&VecBoolType; @@ -316,10 +340,14 @@ static PyObject *vec_class_getitem(PyObject *type, PyObject *item) item = it; // Check if this is a specialized value type that doesn't support None if (item == (PyObject *)LibRTVecs_I64TypeObj || + item == (PyObject *)LibRTVecs_U64TypeObj || + item == (PyObject *)LibRTVecs_U32TypeObj || + item == (PyObject *)LibRTVecs_U16TypeObj || item == (PyObject *)LibRTVecs_U8TypeObj || item == (PyObject *)&PyFloat_Type || item == (PyObject *)LibRTVecs_I32TypeObj || item == (PyObject *)LibRTVecs_I16TypeObj || + item == (PyObject *)LibRTVecs_I8TypeObj || item == (PyObject *)&PyBool_Type) { PyErr_SetString(PyExc_TypeError, "vec does not support optional value types (use vec[object] instead)"); @@ -344,6 +372,15 @@ static PyObject *vec_class_getitem(PyObject *type, PyObject *item) if (item == (PyObject *)&VecI64Type) { item_type = VEC_ITEM_TYPE_I64; depth = 1; + } else if (item == (PyObject *)&VecU64Type) { + item_type = VEC_ITEM_TYPE_U64; + depth = 1; + } else if (item == (PyObject *)&VecU32Type) { + item_type = VEC_ITEM_TYPE_U32; + depth = 1; + } else if (item == (PyObject *)&VecU16Type) { + item_type = VEC_ITEM_TYPE_U16; + depth = 1; } else if (item == (PyObject *)&VecU8Type) { item_type = VEC_ITEM_TYPE_U8; depth = 1; @@ -356,6 +393,9 @@ static PyObject *vec_class_getitem(PyObject *type, PyObject *item) } else if (item == (PyObject *)&VecI16Type) { item_type = VEC_ITEM_TYPE_I16; depth = 1; + } else if (item == (PyObject *)&VecI8Type) { + item_type = VEC_ITEM_TYPE_I8; + depth = 1; } else if (item == (PyObject *)&VecBoolType) { item_type = VEC_ITEM_TYPE_BOOL; depth = 1; @@ -364,7 +404,7 @@ static PyObject *vec_class_getitem(PyObject *type, PyObject *item) } } if (item == (PyObject *)&PyLong_Type) { - PyErr_Format(PyExc_ValueError, "unsupported type in vec[%s] (use i64, i32, i16, or u8)", + PyErr_Format(PyExc_ValueError, "unsupported type in vec[%s] (use a native integer type such as i64)", ((PyTypeObject *)item)->tp_name); goto error; } @@ -592,6 +632,39 @@ static PyObject *vec_append(PyObject *self, PyObject *args) if (VEC_IS_ERROR(v)) return NULL; return VecI64_Box(v); + } else if (VecU64_Check(vec)) { + uint64_t x = VecU64_UnboxItem(item); + if (VecU64_IsUnboxError(x)) { + return NULL; + } + VecU64 v = ((VecU64Object *)vec)->vec; + VEC_U64_INCREF(v); + v = VecU64_Append(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU64_Box(v); + } else if (VecU32_Check(vec)) { + uint32_t x = VecU32_UnboxItem(item); + if (VecU32_IsUnboxError(x)) { + return NULL; + } + VecU32 v = ((VecU32Object *)vec)->vec; + VEC_U32_INCREF(v); + v = VecU32_Append(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU32_Box(v); + } else if (VecU16_Check(vec)) { + uint16_t x = VecU16_UnboxItem(item); + if (VecU16_IsUnboxError(x)) { + return NULL; + } + VecU16 v = ((VecU16Object *)vec)->vec; + VEC_U16_INCREF(v); + v = VecU16_Append(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU16_Box(v); } else if (VecU8_Check(vec)) { uint8_t x = VecU8_UnboxItem(item); if (VecU8_IsUnboxError(x)) { @@ -636,6 +709,17 @@ static PyObject *vec_append(PyObject *self, PyObject *args) if (VEC_IS_ERROR(v)) return NULL; return VecI16_Box(v); + } else if (VecI8_Check(vec)) { + int8_t x = VecI8_UnboxItem(item); + if (VecI8_IsUnboxError(x)) { + return NULL; + } + VecI8 v = ((VecI8Object *)vec)->vec; + VEC_I8_INCREF(v); + v = VecI8_Append(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecI8_Box(v); } else if (VecBool_Check(vec)) { double x = VecBool_UnboxItem(item); if (VecBool_IsUnboxError(x)) { @@ -693,6 +777,39 @@ static PyObject *vec_remove(PyObject *self, PyObject *args) if (VEC_IS_ERROR(v)) return NULL; return VecI64_Box(v); + } else if (VecU64_Check(vec)) { + uint64_t x = VecU64_UnboxItem(item); + if (VecU64_IsUnboxError(x)) { + return NULL; + } + VecU64 v = ((VecU64Object *)vec)->vec; + VEC_U64_INCREF(v); + v = VecU64_Remove(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU64_Box(v); + } else if (VecU32_Check(vec)) { + uint32_t x = VecU32_UnboxItem(item); + if (VecU32_IsUnboxError(x)) { + return NULL; + } + VecU32 v = ((VecU32Object *)vec)->vec; + VEC_U32_INCREF(v); + v = VecU32_Remove(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU32_Box(v); + } else if (VecU16_Check(vec)) { + uint16_t x = VecU16_UnboxItem(item); + if (VecU16_IsUnboxError(x)) { + return NULL; + } + VecU16 v = ((VecU16Object *)vec)->vec; + VEC_U16_INCREF(v); + v = VecU16_Remove(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU16_Box(v); } else if (VecU8_Check(vec)) { uint8_t x = VecU8_UnboxItem(item); if (VecU8_IsUnboxError(x)) { @@ -737,6 +854,17 @@ static PyObject *vec_remove(PyObject *self, PyObject *args) if (VEC_IS_ERROR(v)) return NULL; return VecI16_Box(v); + } else if (VecI8_Check(vec)) { + int8_t x = VecI8_UnboxItem(item); + if (VecI8_IsUnboxError(x)) { + return NULL; + } + VecI8 v = ((VecI8Object *)vec)->vec; + VEC_I8_INCREF(v); + v = VecI8_Remove(v, x); + if (VEC_IS_ERROR(v)) + return NULL; + return VecI8_Box(v); } else if (VecBool_Check(vec)) { char x = VecBool_UnboxItem(item); if (VecBool_IsUnboxError(x)) { @@ -796,6 +924,36 @@ static PyObject *vec_pop(PyObject *self, PyObject *args) if ((result_item0 = VecI64_Box(r.f0)) == NULL) return NULL; result_item1 = VecI64_BoxItem(r.f1); + } else if (VecU64_Check(vec)) { + VecU64 v = ((VecU64Object *)vec)->vec; + VEC_U64_INCREF(v); + VecU64PopResult r; + r = VecU64_Pop(v, index); + if (VEC_IS_ERROR(r.f0)) + return NULL; + if ((result_item0 = VecU64_Box(r.f0)) == NULL) + return NULL; + result_item1 = VecU64_BoxItem(r.f1); + } else if (VecU32_Check(vec)) { + VecU32 v = ((VecU32Object *)vec)->vec; + VEC_U32_INCREF(v); + VecU32PopResult r; + r = VecU32_Pop(v, index); + if (VEC_IS_ERROR(r.f0)) + return NULL; + if ((result_item0 = VecU32_Box(r.f0)) == NULL) + return NULL; + result_item1 = VecU32_BoxItem(r.f1); + } else if (VecU16_Check(vec)) { + VecU16 v = ((VecU16Object *)vec)->vec; + VEC_U16_INCREF(v); + VecU16PopResult r; + r = VecU16_Pop(v, index); + if (VEC_IS_ERROR(r.f0)) + return NULL; + if ((result_item0 = VecU16_Box(r.f0)) == NULL) + return NULL; + result_item1 = VecU16_BoxItem(r.f1); } else if (VecU8_Check(vec)) { VecU8 v = ((VecU8Object *)vec)->vec; VEC_U8_INCREF(v); @@ -836,6 +994,16 @@ static PyObject *vec_pop(PyObject *self, PyObject *args) if ((result_item0 = VecI16_Box(r.f0)) == NULL) return NULL; result_item1 = VecI16_BoxItem(r.f1); + } else if (VecI8_Check(vec)) { + VecI8 v = ((VecI8Object *)vec)->vec; + VEC_I8_INCREF(v); + VecI8PopResult r; + r = VecI8_Pop(v, index); + if (VEC_IS_ERROR(r.f0)) + return NULL; + if ((result_item0 = VecI8_Box(r.f0)) == NULL) + return NULL; + result_item1 = VecI8_BoxItem(r.f1); } else if (VecBool_Check(vec)) { VecBool v = ((VecBoolObject *)vec)->vec; VEC_BOOL_INCREF(v); @@ -917,6 +1085,27 @@ static PyObject *vec_extend(PyObject *self, PyObject *args) if (VEC_IS_ERROR(v)) return NULL; return VecI64_Box(v); + } else if (VecU64_Check(vec)) { + VecU64 v = ((VecU64Object *)vec)->vec; + VEC_U64_INCREF(v); + v = VecU64_Extend(v, iterable); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU64_Box(v); + } else if (VecU32_Check(vec)) { + VecU32 v = ((VecU32Object *)vec)->vec; + VEC_U32_INCREF(v); + v = VecU32_Extend(v, iterable); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU32_Box(v); + } else if (VecU16_Check(vec)) { + VecU16 v = ((VecU16Object *)vec)->vec; + VEC_U16_INCREF(v); + v = VecU16_Extend(v, iterable); + if (VEC_IS_ERROR(v)) + return NULL; + return VecU16_Box(v); } else if (VecU8_Check(vec)) { VecU8 v = ((VecU8Object *)vec)->vec; VEC_U8_INCREF(v); @@ -945,6 +1134,13 @@ static PyObject *vec_extend(PyObject *self, PyObject *args) if (VEC_IS_ERROR(v)) return NULL; return VecI16_Box(v); + } else if (VecI8_Check(vec)) { + VecI8 v = ((VecI8Object *)vec)->vec; + VEC_I8_INCREF(v); + v = VecI8_Extend(v, iterable); + if (VEC_IS_ERROR(v)) + return NULL; + return VecI8_Box(v); } else if (VecBool_Check(vec)) { VecBool v = ((VecBoolObject *)vec)->vec; VEC_BOOL_INCREF(v); @@ -1001,6 +1197,10 @@ static VecCapsule Capsule = { &Vec_FloatAPI, &Vec_BoolAPI, get_vec_type, + &Vec_I8API, + &Vec_U64API, + &Vec_U32API, + &Vec_U16API, }; static PyMethodDef VecsMethods[] = { @@ -1020,6 +1220,7 @@ librt_vecs_module_exec(PyObject *m) } PyTypeObject *i64 = NULL, *i32 = NULL, *i16 = NULL, *u8 = NULL; + PyTypeObject *i8 = NULL, *u64 = NULL, *u32 = NULL, *u16 = NULL; i64 = (PyTypeObject *)PyObject_GetAttrString(ext, "i64"); if (i64 == NULL) { @@ -1045,6 +1246,58 @@ librt_vecs_module_exec(PyObject *m) PyErr_SetString(PyExc_TypeError, "mypy_extensions.i16 is not a type"); goto error; } + i8 = (PyTypeObject *)PyObject_GetAttrString(ext, "i8"); + if (i8 == NULL) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_SetString(PyExc_ImportError, + "mypy_extensions.i8 not found " + "(hint: upgrade to mypy-extensions 1.2.0 or newer)"); + } + goto error; + } + if (!PyType_Check(i8)) { + PyErr_SetString(PyExc_TypeError, "mypy_extensions.i8 is not a type"); + goto error; + } + u64 = (PyTypeObject *)PyObject_GetAttrString(ext, "u64"); + if (u64 == NULL) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_SetString(PyExc_ImportError, + "mypy_extensions.u64 not found " + "(hint: upgrade to mypy-extensions 1.2.0 or newer)"); + } + goto error; + } + if (!PyType_Check(u64)) { + PyErr_SetString(PyExc_TypeError, "mypy_extensions.u64 is not a type"); + goto error; + } + u32 = (PyTypeObject *)PyObject_GetAttrString(ext, "u32"); + if (u32 == NULL) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_SetString(PyExc_ImportError, + "mypy_extensions.u32 not found " + "(hint: upgrade to mypy-extensions 1.2.0 or newer)"); + } + goto error; + } + if (!PyType_Check(u32)) { + PyErr_SetString(PyExc_TypeError, "mypy_extensions.u32 is not a type"); + goto error; + } + u16 = (PyTypeObject *)PyObject_GetAttrString(ext, "u16"); + if (u16 == NULL) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_SetString(PyExc_ImportError, + "mypy_extensions.u16 not found " + "(hint: upgrade to mypy-extensions 1.2.0 or newer)"); + } + goto error; + } + if (!PyType_Check(u16)) { + PyErr_SetString(PyExc_TypeError, "mypy_extensions.u16 is not a type"); + goto error; + } u8 = (PyTypeObject *)PyObject_GetAttrString(ext, "u8"); if (u8 == NULL) { goto error; @@ -1091,6 +1344,30 @@ librt_vecs_module_exec(PyObject *m) goto error; if (PyType_Ready(&VecI16IterType) < 0) goto error; + if (PyType_Ready(&VecI8Type) < 0) + goto error; + if (PyType_Ready(&VecI8BufType) < 0) + goto error; + if (PyType_Ready(&VecI8IterType) < 0) + goto error; + if (PyType_Ready(&VecU64Type) < 0) + goto error; + if (PyType_Ready(&VecU64BufType) < 0) + goto error; + if (PyType_Ready(&VecU64IterType) < 0) + goto error; + if (PyType_Ready(&VecU32Type) < 0) + goto error; + if (PyType_Ready(&VecU32BufType) < 0) + goto error; + if (PyType_Ready(&VecU32IterType) < 0) + goto error; + if (PyType_Ready(&VecU16Type) < 0) + goto error; + if (PyType_Ready(&VecU16BufType) < 0) + goto error; + if (PyType_Ready(&VecU16IterType) < 0) + goto error; if (PyType_Ready(&VecU8Type) < 0) goto error; if (PyType_Ready(&VecU8BufType) < 0) @@ -1128,6 +1405,10 @@ librt_vecs_module_exec(PyObject *m) Py_XSETREF(LibRTVecs_I64TypeObj, i64); Py_XSETREF(LibRTVecs_I32TypeObj, i32); Py_XSETREF(LibRTVecs_I16TypeObj, i16); + Py_XSETREF(LibRTVecs_I8TypeObj, i8); + Py_XSETREF(LibRTVecs_U64TypeObj, u64); + Py_XSETREF(LibRTVecs_U32TypeObj, u32); + Py_XSETREF(LibRTVecs_U16TypeObj, u16); Py_XSETREF(LibRTVecs_U8TypeObj, u8); Py_DECREF(ext); return 0; @@ -1136,6 +1417,10 @@ librt_vecs_module_exec(PyObject *m) Py_XDECREF(i64); Py_XDECREF(i32); Py_XDECREF(i16); + Py_XDECREF(i8); + Py_XDECREF(u64); + Py_XDECREF(u32); + Py_XDECREF(u16); Py_XDECREF(u8); Py_DECREF(ext); return -1; diff --git a/mypyc/lib-rt/vecs/librt_vecs.h b/mypyc/lib-rt/vecs/librt_vecs.h index 66aa4087b306b..cedc774331795 100644 --- a/mypyc/lib-rt/vecs/librt_vecs.h +++ b/mypyc/lib-rt/vecs/librt_vecs.h @@ -18,7 +18,7 @@ // API version -- more recent versions must maintain backward compatibility, i.e. // we can add new features but not remove or change existing features (unless // ABI version is changed, but see the comment above). -#define LIBRT_VECS_API_VERSION 1 +#define LIBRT_VECS_API_VERSION 2 // Magic (native) integer return value on exception. Caller must also // use PyErr_Occurred() since this overlaps with valid integer values. @@ -35,6 +35,10 @@ #define VEC_ITEM_TYPE_U8 14 #define VEC_ITEM_TYPE_FLOAT 18 #define VEC_ITEM_TYPE_BOOL 22 +#define VEC_ITEM_TYPE_I8 26 +#define VEC_ITEM_TYPE_U64 30 +#define VEC_ITEM_TYPE_U32 34 +#define VEC_ITEM_TYPE_U16 38 static inline size_t Vec_IsMagicItemType(size_t item_type) { return item_type & 2; @@ -62,6 +66,30 @@ typedef struct _VecI16BufObject { int16_t items[1]; } VecI16BufObject; +// vecbuf[i8] +typedef struct _VecI8BufObject { + PyObject_VAR_HEAD + int8_t items[1]; +} VecI8BufObject; + +// vecbuf[u64] +typedef struct _VecU64BufObject { + PyObject_VAR_HEAD + uint64_t items[1]; +} VecU64BufObject; + +// vecbuf[u32] +typedef struct _VecU32BufObject { + PyObject_VAR_HEAD + uint32_t items[1]; +} VecU32BufObject; + +// vecbuf[u16] +typedef struct _VecU16BufObject { + PyObject_VAR_HEAD + uint16_t items[1]; +} VecU16BufObject; + // vecbuf[u8] typedef struct _VecU8BufObject { PyObject_VAR_HEAD @@ -128,6 +156,26 @@ typedef struct _VecI16 { int16_t *items; } VecI16; +typedef struct _VecI8 { + Py_ssize_t len; + int8_t *items; +} VecI8; + +typedef struct _VecU64 { + Py_ssize_t len; + uint64_t *items; +} VecU64; + +typedef struct _VecU32 { + Py_ssize_t len; + uint32_t *items; +} VecU32; + +typedef struct _VecU16 { + Py_ssize_t len; + uint16_t *items; +} VecU16; + typedef struct _VecU8 { Py_ssize_t len; uint8_t *items; @@ -160,6 +208,14 @@ typedef struct _VecNested { ((VecI32BufObject *)((char *)(items_) - offsetof(VecI32BufObject, items))) #define VEC_I16_BUF_FROM_ITEMS(items_) \ ((VecI16BufObject *)((char *)(items_) - offsetof(VecI16BufObject, items))) +#define VEC_I8_BUF_FROM_ITEMS(items_) \ + ((VecI8BufObject *)((char *)(items_) - offsetof(VecI8BufObject, items))) +#define VEC_U64_BUF_FROM_ITEMS(items_) \ + ((VecU64BufObject *)((char *)(items_) - offsetof(VecU64BufObject, items))) +#define VEC_U32_BUF_FROM_ITEMS(items_) \ + ((VecU32BufObject *)((char *)(items_) - offsetof(VecU32BufObject, items))) +#define VEC_U16_BUF_FROM_ITEMS(items_) \ + ((VecU16BufObject *)((char *)(items_) - offsetof(VecU16BufObject, items))) #define VEC_U8_BUF_FROM_ITEMS(items_) \ ((VecU8BufObject *)((char *)(items_) - offsetof(VecU8BufObject, items))) #define VEC_FLOAT_BUF_FROM_ITEMS(items_) \ @@ -174,6 +230,10 @@ typedef struct _VecNested { #define VEC_I64_BUF(v) VEC_I64_BUF_FROM_ITEMS((v).items) #define VEC_I32_BUF(v) VEC_I32_BUF_FROM_ITEMS((v).items) #define VEC_I16_BUF(v) VEC_I16_BUF_FROM_ITEMS((v).items) +#define VEC_I8_BUF(v) VEC_I8_BUF_FROM_ITEMS((v).items) +#define VEC_U64_BUF(v) VEC_U64_BUF_FROM_ITEMS((v).items) +#define VEC_U32_BUF(v) VEC_U32_BUF_FROM_ITEMS((v).items) +#define VEC_U16_BUF(v) VEC_U16_BUF_FROM_ITEMS((v).items) #define VEC_U8_BUF(v) VEC_U8_BUF_FROM_ITEMS((v).items) #define VEC_FLOAT_BUF(v) VEC_FLOAT_BUF_FROM_ITEMS((v).items) #define VEC_BOOL_BUF(v) VEC_BOOL_BUF_FROM_ITEMS((v).items) @@ -187,6 +247,14 @@ typedef struct _VecNested { #define VEC_I32_DECREF(v) do { if ((v).items) Py_DECREF(VEC_I32_BUF(v)); } while (0) #define VEC_I16_INCREF(v) do { if ((v).items) Py_INCREF(VEC_I16_BUF(v)); } while (0) #define VEC_I16_DECREF(v) do { if ((v).items) Py_DECREF(VEC_I16_BUF(v)); } while (0) +#define VEC_I8_INCREF(v) do { if ((v).items) Py_INCREF(VEC_I8_BUF(v)); } while (0) +#define VEC_I8_DECREF(v) do { if ((v).items) Py_DECREF(VEC_I8_BUF(v)); } while (0) +#define VEC_U64_INCREF(v) do { if ((v).items) Py_INCREF(VEC_U64_BUF(v)); } while (0) +#define VEC_U64_DECREF(v) do { if ((v).items) Py_DECREF(VEC_U64_BUF(v)); } while (0) +#define VEC_U32_INCREF(v) do { if ((v).items) Py_INCREF(VEC_U32_BUF(v)); } while (0) +#define VEC_U32_DECREF(v) do { if ((v).items) Py_DECREF(VEC_U32_BUF(v)); } while (0) +#define VEC_U16_INCREF(v) do { if ((v).items) Py_INCREF(VEC_U16_BUF(v)); } while (0) +#define VEC_U16_DECREF(v) do { if ((v).items) Py_DECREF(VEC_U16_BUF(v)); } while (0) #define VEC_U8_INCREF(v) do { if ((v).items) Py_INCREF(VEC_U8_BUF(v)); } while (0) #define VEC_U8_DECREF(v) do { if ((v).items) Py_DECREF(VEC_U8_BUF(v)); } while (0) #define VEC_FLOAT_INCREF(v) do { if ((v).items) Py_INCREF(VEC_FLOAT_BUF(v)); } while (0) @@ -233,6 +301,30 @@ typedef struct _VecI16Object { VecI16 vec; } VecI16Object; +// Boxed vec[i8] +typedef struct _VecI8Object { + PyObject_HEAD + VecI8 vec; +} VecI8Object; + +// Boxed vec[u64] +typedef struct _VecU64Object { + PyObject_HEAD + VecU64 vec; +} VecU64Object; + +// Boxed vec[u32] +typedef struct _VecU32Object { + PyObject_HEAD + VecU32 vec; +} VecU32Object; + +// Boxed vec[u16] +typedef struct _VecU16Object { + PyObject_HEAD + VecU16 vec; +} VecU16Object; + // Boxed vec[u8] typedef struct _VecU8Object { PyObject_HEAD @@ -291,6 +383,42 @@ typedef struct tuple_T2V22 { static tuple_T2V22 tuple_undefined_T2V22 = { { -1, NULL } , 0 }; #endif +#ifndef MYPYC_DECLARED_tuple_T2V11 +#define MYPYC_DECLARED_tuple_T2V11 +typedef struct tuple_T2V11 { + VecI8 f0; + int8_t f1; +} tuple_T2V11; +static tuple_T2V11 tuple_undefined_T2V11 = { { -1, NULL } , 0 }; +#endif + +#ifndef MYPYC_DECLARED_tuple_T2VU8U8 +#define MYPYC_DECLARED_tuple_T2VU8U8 +typedef struct tuple_T2VU8U8 { + VecU64 f0; + uint64_t f1; +} tuple_T2VU8U8; +static tuple_T2VU8U8 tuple_undefined_T2VU8U8 = { { -1, NULL } , 0 }; +#endif + +#ifndef MYPYC_DECLARED_tuple_T2VU4U4 +#define MYPYC_DECLARED_tuple_T2VU4U4 +typedef struct tuple_T2VU4U4 { + VecU32 f0; + uint32_t f1; +} tuple_T2VU4U4; +static tuple_T2VU4U4 tuple_undefined_T2VU4U4 = { { -1, NULL } , 0 }; +#endif + +#ifndef MYPYC_DECLARED_tuple_T2VU2U2 +#define MYPYC_DECLARED_tuple_T2VU2U2 +typedef struct tuple_T2VU2U2 { + VecU16 f0; + uint16_t f1; +} tuple_T2VU2U2; +static tuple_T2VU2U2 tuple_undefined_T2VU2U2 = { { -1, NULL } , 0 }; +#endif + #ifndef MYPYC_DECLARED_tuple_T2VU1U1 #define MYPYC_DECLARED_tuple_T2VU1U1 typedef struct tuple_T2VU1U1 { @@ -321,6 +449,10 @@ static tuple_T2VCC tuple_undefined_T2VCC = { { -1, NULL } , 0 }; typedef tuple_T2V88 VecI64PopResult; typedef tuple_T2V44 VecI32PopResult; typedef tuple_T2V22 VecI16PopResult; +typedef tuple_T2V11 VecI8PopResult; +typedef tuple_T2VU8U8 VecU64PopResult; +typedef tuple_T2VU4U4 VecU32PopResult; +typedef tuple_T2VU2U2 VecU16PopResult; typedef tuple_T2VU1U1 VecU8PopResult; typedef tuple_T2VFF VecFloatPopResult; typedef tuple_T2VCC VecBoolPopResult; @@ -385,6 +517,86 @@ typedef struct _VecI16API { PyObject *(*to_tuple)(VecI16); } VecI16API; +// vec[i8] operations + type objects (stored in a capsule) +typedef struct _VecI8API { + PyTypeObject *boxed_type; + PyTypeObject *buf_type; + VecI8 (*alloc)(Py_ssize_t, Py_ssize_t); + PyObject *(*box)(VecI8); + VecI8 (*unbox)(PyObject *); + VecI8 (*convert_from_nested)(VecNestedBufItem); + VecI8 (*append)(VecI8, int8_t); + VecI8PopResult (*pop)(VecI8, Py_ssize_t); + VecI8 (*remove)(VecI8, int8_t); + // TODO: Py_ssize_t + VecI8 (*slice)(VecI8, int64_t, int64_t); + VecI8 (*from_iterable)(PyObject *, int64_t); + VecI8 (*extend)(VecI8, PyObject *); + VecI8 (*extend_vec)(VecI8, VecI8); + PyObject *(*to_list)(VecI8); + PyObject *(*to_tuple)(VecI8); +} VecI8API; + +// vec[u64] operations + type objects (stored in a capsule) +typedef struct _VecU64API { + PyTypeObject *boxed_type; + PyTypeObject *buf_type; + VecU64 (*alloc)(Py_ssize_t, Py_ssize_t); + PyObject *(*box)(VecU64); + VecU64 (*unbox)(PyObject *); + VecU64 (*convert_from_nested)(VecNestedBufItem); + VecU64 (*append)(VecU64, uint64_t); + VecU64PopResult (*pop)(VecU64, Py_ssize_t); + VecU64 (*remove)(VecU64, uint64_t); + // TODO: Py_ssize_t + VecU64 (*slice)(VecU64, int64_t, int64_t); + VecU64 (*from_iterable)(PyObject *, int64_t); + VecU64 (*extend)(VecU64, PyObject *); + VecU64 (*extend_vec)(VecU64, VecU64); + PyObject *(*to_list)(VecU64); + PyObject *(*to_tuple)(VecU64); +} VecU64API; + +// vec[u32] operations + type objects (stored in a capsule) +typedef struct _VecU32API { + PyTypeObject *boxed_type; + PyTypeObject *buf_type; + VecU32 (*alloc)(Py_ssize_t, Py_ssize_t); + PyObject *(*box)(VecU32); + VecU32 (*unbox)(PyObject *); + VecU32 (*convert_from_nested)(VecNestedBufItem); + VecU32 (*append)(VecU32, uint32_t); + VecU32PopResult (*pop)(VecU32, Py_ssize_t); + VecU32 (*remove)(VecU32, uint32_t); + // TODO: Py_ssize_t + VecU32 (*slice)(VecU32, int64_t, int64_t); + VecU32 (*from_iterable)(PyObject *, int64_t); + VecU32 (*extend)(VecU32, PyObject *); + VecU32 (*extend_vec)(VecU32, VecU32); + PyObject *(*to_list)(VecU32); + PyObject *(*to_tuple)(VecU32); +} VecU32API; + +// vec[u16] operations + type objects (stored in a capsule) +typedef struct _VecU16API { + PyTypeObject *boxed_type; + PyTypeObject *buf_type; + VecU16 (*alloc)(Py_ssize_t, Py_ssize_t); + PyObject *(*box)(VecU16); + VecU16 (*unbox)(PyObject *); + VecU16 (*convert_from_nested)(VecNestedBufItem); + VecU16 (*append)(VecU16, uint16_t); + VecU16PopResult (*pop)(VecU16, Py_ssize_t); + VecU16 (*remove)(VecU16, uint16_t); + // TODO: Py_ssize_t + VecU16 (*slice)(VecU16, int64_t, int64_t); + VecU16 (*from_iterable)(PyObject *, int64_t); + VecU16 (*extend)(VecU16, PyObject *); + VecU16 (*extend_vec)(VecU16, VecU16); + PyObject *(*to_list)(VecU16); + PyObject *(*to_tuple)(VecU16); +} VecU16API; + // vec[u8] operations + type objects (stored in a capsule) typedef struct _VecU8API { PyTypeObject *boxed_type; @@ -519,6 +731,11 @@ typedef struct { VecFloatAPI *float_; VecBoolAPI *bool_; PyTypeObject *(*get_vec_type)(void); // Function to get base VecType for isinstance checks + // Added in API version 2 + VecI8API *i8; + VecU64API *u64; + VecU32API *u32; + VecU16API *u16; } VecCapsule; #define VEC_BUF_SIZE(b) ((b)->ob_base.ob_size) @@ -532,6 +749,10 @@ typedef struct { extern PyTypeObject VecI64BufType; extern PyTypeObject VecI32BufType; extern PyTypeObject VecI16BufType; +extern PyTypeObject VecI8BufType; +extern PyTypeObject VecU64BufType; +extern PyTypeObject VecU32BufType; +extern PyTypeObject VecU16BufType; extern PyTypeObject VecU8BufType; extern PyTypeObject VecFloatBufType; extern PyTypeObject VecBoolBufType; @@ -542,6 +763,10 @@ extern PyTypeObject VecNestedBufType; extern PyTypeObject VecI64Type; extern PyTypeObject VecI32Type; extern PyTypeObject VecI16Type; +extern PyTypeObject VecI8Type; +extern PyTypeObject VecU64Type; +extern PyTypeObject VecU32Type; +extern PyTypeObject VecU16Type; extern PyTypeObject VecU8Type; extern PyTypeObject VecFloatType; extern PyTypeObject VecBoolType; @@ -552,21 +777,33 @@ extern PyTypeObject VecNestedType; extern PyTypeObject VecI64IterType; extern PyTypeObject VecI32IterType; extern PyTypeObject VecI16IterType; +extern PyTypeObject VecI8IterType; +extern PyTypeObject VecU64IterType; +extern PyTypeObject VecU32IterType; +extern PyTypeObject VecU16IterType; extern PyTypeObject VecU8IterType; extern PyTypeObject VecFloatIterType; extern PyTypeObject VecBoolIterType; extern PyTypeObject VecTIterType; extern PyTypeObject VecNestedIterType; -// Type objects corresponding to the 'i64', 'i32', 'i16, and 'u8' types +// Type objects corresponding to native integer types such as 'i64' and 'u8' extern PyTypeObject *LibRTVecs_I64TypeObj; extern PyTypeObject *LibRTVecs_I32TypeObj; extern PyTypeObject *LibRTVecs_I16TypeObj; +extern PyTypeObject *LibRTVecs_I8TypeObj; +extern PyTypeObject *LibRTVecs_U64TypeObj; +extern PyTypeObject *LibRTVecs_U32TypeObj; +extern PyTypeObject *LibRTVecs_U16TypeObj; extern PyTypeObject *LibRTVecs_U8TypeObj; extern VecI64API Vec_I64API; extern VecI32API Vec_I32API; extern VecI16API Vec_I16API; +extern VecI8API Vec_I8API; +extern VecU64API Vec_U64API; +extern VecU32API Vec_U32API; +extern VecU16API Vec_U16API; extern VecU8API Vec_U8API; extern VecFloatAPI Vec_FloatAPI; extern VecBoolAPI Vec_BoolAPI; @@ -672,6 +909,139 @@ VecI16 VecI16_ExtendVec(VecI16 dst, VecI16 src); VecI16 VecI16_Remove(VecI16, int16_t x); VecI16PopResult VecI16_Pop(VecI16 v, Py_ssize_t index); +// vec[i8] operations + +static inline int VecI8_Check(PyObject *o) { + return o->ob_type == &VecI8Type; +} + +static inline PyObject *VecI8_BoxItem(int8_t x) { + return PyLong_FromLong(x); +} + +static inline int8_t VecI8_UnboxItem(PyObject *o) { + if (Vec_CheckFloatError(o)) + return -1; + long x = PyLong_AsLong(o); + if (x >= 128 || x < -128) { + PyErr_SetString(PyExc_OverflowError, "Python int too large to convert to i8"); + return -1; + } + return x; +} + +static inline int VecI8_IsUnboxError(int8_t x) { + return x == -1 && PyErr_Occurred(); +} + +PyObject *VecI8_Box(VecI8); +VecI8 VecI8_Append(VecI8, int8_t x); +VecI8 VecI8_Extend(VecI8, PyObject *iterable); +VecI8 VecI8_ExtendVec(VecI8 dst, VecI8 src); +VecI8 VecI8_Remove(VecI8, int8_t x); +VecI8PopResult VecI8_Pop(VecI8 v, Py_ssize_t index); + +// vec[u64] operations + +static inline int VecU64_Check(PyObject *o) { + return o->ob_type == &VecU64Type; +} + +static inline PyObject *VecU64_BoxItem(uint64_t x) { + return PyLong_FromUnsignedLongLong(x); +} + +static inline uint64_t VecU64_UnboxItem(PyObject *o) { + if (Vec_CheckFloatError(o)) + return 239; + unsigned long long x = PyLong_AsUnsignedLongLong(o); + if (x == (unsigned long long)-1 && PyErr_Occurred()) + return 239; + return x; +} + +static inline int VecU64_IsUnboxError(uint64_t x) { + return x == 239 && PyErr_Occurred(); +} + +PyObject *VecU64_Box(VecU64); +VecU64 VecU64_Append(VecU64, uint64_t x); +VecU64 VecU64_Extend(VecU64, PyObject *iterable); +VecU64 VecU64_ExtendVec(VecU64 dst, VecU64 src); +VecU64 VecU64_Remove(VecU64, uint64_t x); +VecU64PopResult VecU64_Pop(VecU64 v, Py_ssize_t index); + +// vec[u32] operations + +static inline int VecU32_Check(PyObject *o) { + return o->ob_type == &VecU32Type; +} + +static inline PyObject *VecU32_BoxItem(uint32_t x) { + return PyLong_FromUnsignedLong(x); +} + +static inline uint32_t VecU32_UnboxItem(PyObject *o) { + if (Vec_CheckFloatError(o)) + return 239; + // Use unsigned long long, since unsigned long may only have 32 bits + unsigned long long x = PyLong_AsUnsignedLongLong(o); + if (x <= UINT32_MAX) + return (uint32_t)x; + else if (x == (unsigned long long)-1 && PyErr_Occurred()) + return 239; + else { + PyErr_SetString(PyExc_OverflowError, "Python int too large to convert to u32"); + return 239; + } +} + +static inline int VecU32_IsUnboxError(uint32_t x) { + return x == 239 && PyErr_Occurred(); +} + +PyObject *VecU32_Box(VecU32); +VecU32 VecU32_Append(VecU32, uint32_t x); +VecU32 VecU32_Extend(VecU32, PyObject *iterable); +VecU32 VecU32_ExtendVec(VecU32 dst, VecU32 src); +VecU32 VecU32_Remove(VecU32, uint32_t x); +VecU32PopResult VecU32_Pop(VecU32 v, Py_ssize_t index); + +// vec[u16] operations + +static inline int VecU16_Check(PyObject *o) { + return o->ob_type == &VecU16Type; +} + +static inline PyObject *VecU16_BoxItem(uint16_t x) { + return PyLong_FromUnsignedLong(x); +} + +static inline uint16_t VecU16_UnboxItem(PyObject *o) { + if (Vec_CheckFloatError(o)) + return 239; + unsigned long x = PyLong_AsUnsignedLong(o); + if (x <= 65535) + return x; + else if (x == (unsigned long)-1 && PyErr_Occurred()) + return 239; + else { + PyErr_SetString(PyExc_OverflowError, "Python int too large to convert to u16"); + return 239; + } +} + +static inline int VecU16_IsUnboxError(uint16_t x) { + return x == 239 && PyErr_Occurred(); +} + +PyObject *VecU16_Box(VecU16); +VecU16 VecU16_Append(VecU16, uint16_t x); +VecU16 VecU16_Extend(VecU16, PyObject *iterable); +VecU16 VecU16_ExtendVec(VecU16 dst, VecU16 src); +VecU16 VecU16_Remove(VecU16, uint16_t x); +VecU16PopResult VecU16_Pop(VecU16 v, Py_ssize_t index); + // vec[u8] operations static inline int VecU8_Check(PyObject *o) { @@ -819,6 +1189,12 @@ static inline PyObject *VecNested_ItemBuf(VecNestedBufObject *parent, VecNestedB return (PyObject *)VEC_NESTED_BUF_FROM_ITEMS(item.items); if (parent->item_type == VEC_ITEM_TYPE_I64) return (PyObject *)VEC_I64_BUF_FROM_ITEMS(item.items); + if (parent->item_type == VEC_ITEM_TYPE_U64) + return (PyObject *)VEC_U64_BUF_FROM_ITEMS(item.items); + if (parent->item_type == VEC_ITEM_TYPE_U32) + return (PyObject *)VEC_U32_BUF_FROM_ITEMS(item.items); + if (parent->item_type == VEC_ITEM_TYPE_U16) + return (PyObject *)VEC_U16_BUF_FROM_ITEMS(item.items); if (parent->item_type == VEC_ITEM_TYPE_U8) return (PyObject *)VEC_U8_BUF_FROM_ITEMS(item.items); if (parent->item_type == VEC_ITEM_TYPE_FLOAT) @@ -827,6 +1203,8 @@ static inline PyObject *VecNested_ItemBuf(VecNestedBufObject *parent, VecNestedB return (PyObject *)VEC_I32_BUF_FROM_ITEMS(item.items); if (parent->item_type == VEC_ITEM_TYPE_I16) return (PyObject *)VEC_I16_BUF_FROM_ITEMS(item.items); + if (parent->item_type == VEC_ITEM_TYPE_I8) + return (PyObject *)VEC_I8_BUF_FROM_ITEMS(item.items); if (parent->item_type == VEC_ITEM_TYPE_BOOL) return (PyObject *)VEC_BOOL_BUF_FROM_ITEMS(item.items); return (PyObject *)VEC_T_BUF_FROM_ITEMS(item.items); @@ -876,6 +1254,21 @@ static inline int VecNested_UnboxItem(VecNested v, PyObject *item, VecNestedBufI unboxed->len = o->vec.len; unboxed->items = o->vec.items; return 0; + } else if (item->ob_type == &VecU64Type && v_buf->item_type == VEC_ITEM_TYPE_U64) { + VecU64Object *o = (VecU64Object *)item; + unboxed->len = o->vec.len; + unboxed->items = o->vec.items; + return 0; + } else if (item->ob_type == &VecU32Type && v_buf->item_type == VEC_ITEM_TYPE_U32) { + VecU32Object *o = (VecU32Object *)item; + unboxed->len = o->vec.len; + unboxed->items = o->vec.items; + return 0; + } else if (item->ob_type == &VecU16Type && v_buf->item_type == VEC_ITEM_TYPE_U16) { + VecU16Object *o = (VecU16Object *)item; + unboxed->len = o->vec.len; + unboxed->items = o->vec.items; + return 0; } else if (item->ob_type == &VecU8Type && v_buf->item_type == VEC_ITEM_TYPE_U8) { VecU8Object *o = (VecU8Object *)item; unboxed->len = o->vec.len; @@ -896,6 +1289,11 @@ static inline int VecNested_UnboxItem(VecNested v, PyObject *item, VecNestedBufI unboxed->len = o->vec.len; unboxed->items = o->vec.items; return 0; + } else if (item->ob_type == &VecI8Type && v_buf->item_type == VEC_ITEM_TYPE_I8) { + VecI8Object *o = (VecI8Object *)item; + unboxed->len = o->vec.len; + unboxed->items = o->vec.items; + return 0; } else if (item->ob_type == &VecBoolType && v_buf->item_type == VEC_ITEM_TYPE_BOOL) { VecBoolObject *o = (VecBoolObject *)item; unboxed->len = o->vec.len; @@ -934,6 +1332,18 @@ static inline PyObject *VecNested_BoxItem(VecNested v, VecNestedBufItem item) { VecI64 iv = { .len = item.len, .items = (int64_t *)item.items }; return VecI64_Box(iv); + } else if (item_type == VEC_ITEM_TYPE_U64) { + VecU64 iv = { .len = item.len, + .items = (uint64_t *)item.items }; + return VecU64_Box(iv); + } else if (item_type == VEC_ITEM_TYPE_U32) { + VecU32 iv = { .len = item.len, + .items = (uint32_t *)item.items }; + return VecU32_Box(iv); + } else if (item_type == VEC_ITEM_TYPE_U16) { + VecU16 iv = { .len = item.len, + .items = (uint16_t *)item.items }; + return VecU16_Box(iv); } else if (item_type == VEC_ITEM_TYPE_U8) { VecU8 iv = { .len = item.len, .items = (uint8_t *)item.items }; @@ -950,6 +1360,10 @@ static inline PyObject *VecNested_BoxItem(VecNested v, VecNestedBufItem item) { VecI16 iv = { .len = item.len, .items = (int16_t *)item.items }; return VecI16_Box(iv); + } else if (item_type == VEC_ITEM_TYPE_I8) { + VecI8 iv = { .len = item.len, + .items = (int8_t *)item.items }; + return VecI8_Box(iv); } else if (item_type == VEC_ITEM_TYPE_BOOL) { VecBool iv = { .len = item.len, .items = (char *)item.items }; diff --git a/mypyc/lib-rt/vecs/librt_vecs_api.c b/mypyc/lib-rt/vecs/librt_vecs_api.c index 8c45874f1bfd2..dc30daa53ae19 100644 --- a/mypyc/lib-rt/vecs/librt_vecs_api.c +++ b/mypyc/lib-rt/vecs/librt_vecs_api.c @@ -4,6 +4,10 @@ VecCapsule *VecApi = NULL; VecI64API VecI64Api = {0}; VecI32API VecI32Api = {0}; VecI16API VecI16Api = {0}; +VecI8API VecI8Api = {0}; +VecU64API VecU64Api = {0}; +VecU32API VecU32Api = {0}; +VecU16API VecU16Api = {0}; VecU8API VecU8Api = {0}; VecFloatAPI VecFloatApi = {0}; VecBoolAPI VecBoolApi = {0}; @@ -42,6 +46,10 @@ import_librt_vecs(void) VecI64Api = *VecApi->i64; VecI32Api = *VecApi->i32; VecI16Api = *VecApi->i16; + VecI8Api = *VecApi->i8; + VecU64Api = *VecApi->u64; + VecU32Api = *VecApi->u32; + VecU16Api = *VecApi->u16; VecU8Api = *VecApi->u8; VecFloatApi = *VecApi->float_; VecBoolApi = *VecApi->bool_; diff --git a/mypyc/lib-rt/vecs/librt_vecs_api.h b/mypyc/lib-rt/vecs/librt_vecs_api.h index 6f42c0b7251d0..72192055192ba 100644 --- a/mypyc/lib-rt/vecs/librt_vecs_api.h +++ b/mypyc/lib-rt/vecs/librt_vecs_api.h @@ -15,6 +15,10 @@ extern VecCapsule *VecApi; extern VecI64API VecI64Api; extern VecI32API VecI32Api; extern VecI16API VecI16Api; +extern VecI8API VecI8Api; +extern VecU64API VecU64Api; +extern VecU32API VecU32Api; +extern VecU16API VecU16Api; extern VecU8API VecU8Api; extern VecFloatAPI VecFloatApi; extern VecBoolAPI VecBoolApi; diff --git a/mypyc/lib-rt/vecs/vec_i8.c b/mypyc/lib-rt/vecs/vec_i8.c new file mode 100644 index 0000000000000..0f2f1c5b46392 --- /dev/null +++ b/mypyc/lib-rt/vecs/vec_i8.c @@ -0,0 +1,19 @@ +#define VEC VecI8 +#define VEC_TYPE VecI8Type +#define VEC_OBJECT VecI8Object +#define BUF_OBJECT VecI8BufObject +#define BUF_TYPE VecI8BufType +#define NAME(suffix) VecI8##suffix +#define FUNC(suffix) VecI8_##suffix +#define ITEM_TYPE_STR "i8" +#define ITEM_TYPE_MAGIC VEC_ITEM_TYPE_I8 +#define ITEM_C_TYPE int8_t +#define FEATURES Vec_I8API + +#define BOX_ITEM VecI8_BoxItem +#define UNBOX_ITEM VecI8_UnboxItem +#define IS_UNBOX_ERROR VecI8_IsUnboxError +#define BUFFER_FORMAT_CHAR_OK(c) ((c) == 'b') +#define BUFFER_FORMAT "b" + +#include "vec_template.c" diff --git a/mypyc/lib-rt/vecs/vec_u16.c b/mypyc/lib-rt/vecs/vec_u16.c new file mode 100644 index 0000000000000..82cb9150bb96b --- /dev/null +++ b/mypyc/lib-rt/vecs/vec_u16.c @@ -0,0 +1,19 @@ +#define VEC VecU16 +#define VEC_TYPE VecU16Type +#define VEC_OBJECT VecU16Object +#define BUF_OBJECT VecU16BufObject +#define BUF_TYPE VecU16BufType +#define NAME(suffix) VecU16##suffix +#define FUNC(suffix) VecU16_##suffix +#define ITEM_TYPE_STR "u16" +#define ITEM_TYPE_MAGIC VEC_ITEM_TYPE_U16 +#define ITEM_C_TYPE uint16_t +#define FEATURES Vec_U16API + +#define BOX_ITEM VecU16_BoxItem +#define UNBOX_ITEM VecU16_UnboxItem +#define IS_UNBOX_ERROR VecU16_IsUnboxError +#define BUFFER_FORMAT_CHAR_OK(c) ((c) == 'H') +#define BUFFER_FORMAT "H" + +#include "vec_template.c" diff --git a/mypyc/lib-rt/vecs/vec_u32.c b/mypyc/lib-rt/vecs/vec_u32.c new file mode 100644 index 0000000000000..da1942f76a478 --- /dev/null +++ b/mypyc/lib-rt/vecs/vec_u32.c @@ -0,0 +1,19 @@ +#define VEC VecU32 +#define VEC_TYPE VecU32Type +#define VEC_OBJECT VecU32Object +#define BUF_OBJECT VecU32BufObject +#define BUF_TYPE VecU32BufType +#define NAME(suffix) VecU32##suffix +#define FUNC(suffix) VecU32_##suffix +#define ITEM_TYPE_STR "u32" +#define ITEM_TYPE_MAGIC VEC_ITEM_TYPE_U32 +#define ITEM_C_TYPE uint32_t +#define FEATURES Vec_U32API + +#define BOX_ITEM VecU32_BoxItem +#define UNBOX_ITEM VecU32_UnboxItem +#define IS_UNBOX_ERROR VecU32_IsUnboxError +#define BUFFER_FORMAT_CHAR_OK(c) ((c) == 'I' || ((c) == 'L' && sizeof(unsigned long) == 4)) +#define BUFFER_FORMAT "I" + +#include "vec_template.c" diff --git a/mypyc/lib-rt/vecs/vec_u64.c b/mypyc/lib-rt/vecs/vec_u64.c new file mode 100644 index 0000000000000..4b05caf066d9c --- /dev/null +++ b/mypyc/lib-rt/vecs/vec_u64.c @@ -0,0 +1,19 @@ +#define VEC VecU64 +#define VEC_TYPE VecU64Type +#define VEC_OBJECT VecU64Object +#define BUF_OBJECT VecU64BufObject +#define BUF_TYPE VecU64BufType +#define NAME(suffix) VecU64##suffix +#define FUNC(suffix) VecU64_##suffix +#define ITEM_TYPE_STR "u64" +#define ITEM_TYPE_MAGIC VEC_ITEM_TYPE_U64 +#define ITEM_C_TYPE uint64_t +#define FEATURES Vec_U64API + +#define BOX_ITEM VecU64_BoxItem +#define UNBOX_ITEM VecU64_UnboxItem +#define IS_UNBOX_ERROR VecU64_IsUnboxError +#define BUFFER_FORMAT_CHAR_OK(c) ((c) == 'Q' || ((c) == 'L' && sizeof(unsigned long) == 8)) +#define BUFFER_FORMAT "Q" + +#include "vec_template.c" diff --git a/mypyc/test-data/irbuild-vec-misc.test b/mypyc/test-data/irbuild-vec-misc.test index 22037d8597a73..bea5cef0eda29 100644 --- a/mypyc/test-data/irbuild-vec-misc.test +++ b/mypyc/test-data/irbuild-vec-misc.test @@ -334,3 +334,105 @@ def to_bytes(v): L0: r0 = CPyVecU8_ToBytes(v) return r0 + +[case testVecMiscNewNativeIntTypes_64bit] +from typing import Any +from librt.vecs import vec, append, pop + +from mypy_extensions import i8, u16, u32, u64, i64 + +def append_i8(v: vec[i8]) -> vec[i8]: + return append(v, -5) + +def append_u16(v: vec[u16]) -> vec[u16]: + return append(v, 65535) + +def append_u32(v: vec[u32], x: u32) -> vec[u32]: + return append(v, x) + +def append_u64(v: vec[u64]) -> vec[u64]: + return append(v, 18446744073709551615) + +def get_u64(v: vec[u64], i: i64) -> u64: + return v[i] + +def pop_u16(v: vec[u16]) -> tuple[vec[u16], u16]: + return pop(v) + +def unbox_u32(a: Any) -> vec[u32]: + return a + +def nested_i8() -> vec[vec[i8]]: + return vec[vec[i8]]() +[out] +def append_i8(v): + v, r0 :: vec[i8] +L0: + r0 = VecI8Api.append(v, -5) + return r0 +def append_u16(v): + v, r0 :: vec[u16] +L0: + r0 = VecU16Api.append(v, 65535) + return r0 +def append_u32(v, x): + v :: vec[u32] + x :: u32 + r0 :: vec[u32] +L0: + r0 = VecU32Api.append(v, x) + return r0 +def append_u64(v): + v :: vec[u64] + r0 :: int + r1 :: vec[u64] +L0: + r0 = object 18446744073709551615 + r1 = VecU64Api.append(v, 18446744073709551615) + return r1 +def get_u64(v, i): + v :: vec[u64] + i :: i64 + r0 :: native_int + r1 :: bit + r2 :: i64 + r3 :: bit + r4 :: bool + r5 :: i64 + r6 :: u64 +L0: + r0 = v.len + r1 = i < r0 :: unsigned + if r1 goto L4 else goto L1 :: bool +L1: + r2 = i + r0 + r3 = r2 < r0 :: unsigned + if r3 goto L3 else goto L2 :: bool +L2: + r4 = raise IndexError + unreachable +L3: + r5 = r2 + goto L5 +L4: + r5 = i +L5: + r6 = vec_get_item_unsafe[u64] v, r5 + return r6 +def pop_u16(v): + v :: vec[u16] + r0 :: tuple[vec[u16], u16] +L0: + r0 = VecU16Api.pop(v, -1) + return r0 +def unbox_u32(a): + a :: object + r0 :: vec[u32] +L0: + r0 = unbox(vec[u32], a) + return r0 +def nested_i8(): + r0 :: vec[vec[i8]] +L0: + r0 = VecNestedApi.alloc(0, 0, 26, 1) + return r0 diff --git a/mypyc/test-data/run-vecs-misc-interp.test b/mypyc/test-data/run-vecs-misc-interp.test index 8cce013cb7133..78363a9f9ef9a 100644 --- a/mypyc/test-data/run-vecs-misc-interp.test +++ b/mypyc/test-data/run-vecs-misc-interp.test @@ -22,17 +22,21 @@ append: Any = librt.vecs.append remove: Any = librt.vecs.remove pop: Any = librt.vecs.pop extend: Any = librt.vecs.extend -u8: Any = mypy_extensions.u8 -i16: Any = mypy_extensions.i16 -i32: Any = mypy_extensions.i32 i64: Any = mypy_extensions.i64 +i32: Any = mypy_extensions.i32 +i16: Any = mypy_extensions.i16 +i8: Any = mypy_extensions.i8 +u64: Any = mypy_extensions.u64 +u32: Any = mypy_extensions.u32 +u16: Any = mypy_extensions.u16 +u8: Any = mypy_extensions.u8 # Work around test stub limitations Optional: Any = getattr(getattr(sys, "modules")["typing"], "Optional") # TODO: Add some nested vec tests -ITEM_TYPES = [i64, u8, i16, i32, float, bool] +ITEM_TYPES = [i64, i32, i16, i8, u64, u32, u16, u8, float, bool] # Common tests for all item types @@ -97,16 +101,18 @@ def test_isinstance() -> None: assert not isinstance(vec, vec) def test_basic_int_operations() -> None: - # All of the non-bool item types support int values 0 to 255 + # All of the non-bool item types support int values 0 to 127, and all + # except i8 support 0 to 255 for t in ITEM_TYPES: if t is bool: continue - v = vec[t]([0, 4, 255]) + hi = 127 if t is i8 else 255 + v = vec[t]([0, 4, hi]) assert len(v) == 3 assert v[0] == 0 assert v[1] == 4 - assert v[2] == 255 - assert v[-1] == 255 + assert v[2] == hi + assert v[-1] == hi assert v[-2] == 4 assert v[-3] == 0 for bad_index in 3, -4, 1 << 100, -1 << 100: @@ -584,7 +590,7 @@ def test_extend_bool() -> None: assert v == vec[bool]([True, False, True]) def test_construct_from_list_modified_during_unboxing() -> None: - for t in [i64, i32, i16, float]: + for t in [i64, i32, i16, i8, float]: lst: list[Any] = [] lst.append(ClearListOnUnbox(lst)) lst.extend([7] * 100) @@ -706,3 +712,151 @@ def test_buffer_extend_from_shared_buffer() -> None: v = extend(old, memoryview_(new)) assert v == vec[u8]([1, 2, 1, 2, 3]) assert new == vec[u8]([1, 2, 3]) + +[case testLibrtVecsNewNativeIntItemTypesInterpreted_librt] +# Test vec[i8], vec[u16], vec[u32] and vec[u64] using generic operations, which +# simulates use from interpreted code. + +import array +import struct +from typing import Any + +import librt.vecs +import mypy_extensions + +from testutil import assertRaises + +vec: Any = librt.vecs.vec +append: Any = librt.vecs.append +remove: Any = librt.vecs.remove +pop: Any = librt.vecs.pop +extend: Any = librt.vecs.extend +i64: Any = mypy_extensions.i64 +i16: Any = mypy_extensions.i16 +u8: Any = mypy_extensions.u8 + +# (item type, min value, max value, mypyc error value, buffer format) +TYPES: list[tuple[Any, int, int, int, str]] = [ + (mypy_extensions.i8, -128, 127, -113, "b"), + (mypy_extensions.u16, 0, 65535, 239, "H"), + (mypy_extensions.u32, 0, 4294967295, 239, "I"), + (mypy_extensions.u64, 0, 18446744073709551615, 239, "Q"), +] + +def test_basics() -> None: + for t, lo, hi, err, _ in TYPES: + name = t.__name__ + v = vec[t]() + assert str(v) == f"vec[{name}]([])" + assert type(v).__name__ == f"vec[{name}]" + assert isinstance(v, librt.vecs.vec) + v = vec[t]([lo, hi, err]) + assert str(v) == f"vec[{name}]([{lo}, {hi}, {err}])" + assert repr(v) == str(v) + assert len(v) == 3 + assert list(v) == [lo, hi, err] + assert v[0] == lo and v[-1] == err + assert type(v[1]) is int + v[0] = hi + assert v[0] == hi + assert v == vec[t]([hi, hi, err]) + assert v != vec[t]([hi, hi]) + v = append(v, 5) + assert v[3] == 5 + v, x = pop(v) + assert x == 5 and len(v) == 3 + v, x = pop(v, 0) + assert x == hi and list(v) == [hi, err] + v = remove(v, err) + assert list(v) == [hi] + with assertRaises(ValueError): + remove(v, err) + v = extend(v, [1, 2]) + v = extend(v, vec[t]([3])) + v = extend(v, iter([lo])) + assert list(v) == [hi, 1, 2, 3, lo] + assert list(v[1:3]) == [1, 2] + assert list(v[::-2]) == [lo, 2, hi] + with assertRaises(IndexError): + v[5] + with assertRaises(IndexError): + v[-6] = 1 + +def test_contains() -> None: + for t, lo, hi, err, _ in TYPES: + v = vec[t]([lo, hi, 1]) + assert lo in v and hi in v and 1 in v + assert 2 not in v + assert hi + 1 not in v + assert lo - 1 not in v + assert 1.0 in v + assert 1.5 not in v + assert "x" not in v + +def test_out_of_range() -> None: + for t, lo, hi, err, _ in TYPES: + for bad in (hi + 1, lo - 1, 2**100, -2**100): + with assertRaises(OverflowError): + vec[t]([bad]) + with assertRaises(OverflowError): + append(vec[t](), bad) + v = vec[t]([1]) + with assertRaises(OverflowError): + v[0] = bad + assert v[0] == 1 + with assertRaises(TypeError): + vec[t]([1.0]) + with assertRaises(TypeError): + append(vec[t](), "x") + with assertRaises(TypeError): + vec[t]([None]) + +def test_distinct_types() -> None: + all_types = [t for t, *_ in TYPES] + [i64, i16, u8, bool] + for t in all_types: + for t2 in all_types: + if t is not t2: + assert type(vec[t]()) is not type(vec[t2]()) + # A nested vec only accepts items of the exact vec type + with assertRaises(TypeError): + vec[vec[t]]([vec[t2]()]) + assert type(vec[TYPES[0][0]]()) is type(vec[TYPES[0][0]]([1])) + +def test_optional_rejected() -> None: + for t, *_ in TYPES: + with assertRaises(TypeError, "vec does not support optional value types"): + vec[t | None] + with assertRaises(TypeError): + vec[t | None]() + +def test_nested() -> None: + for t, lo, hi, err, _ in TYPES: + name = t.__name__ + n = vec[vec[t]]([vec[t]([hi]), vec[t]()]) + n = append(n, vec[t]([lo, err])) + assert str(n) == f"vec[vec[{name}]]([[{hi}], [], [{lo}, {err}]])" + assert n[0][0] == hi + assert n[2] == vec[t]([lo, err]) + assert type(n[2]) is type(vec[t]()) + n, last = pop(n) + assert last == vec[t]([lo, err]) + with assertRaises(TypeError): + append(n, vec[i64]([1])) + with assertRaises(TypeError): + append(n, [1]) + nn = vec[vec[vec[t]]]([n]) + assert str(nn) == f"vec[vec[vec[{name}]]]([[[{hi}], []]])" + +def test_buffer_protocol() -> None: + for t, lo, hi, err, fmt in TYPES: + m: Any = memoryview(vec[t]([lo, hi, err])) + assert m.format == fmt + assert m.itemsize == struct.calcsize(fmt) + assert m.readonly + assert m.tolist() == [lo, hi, err] + assert bytes(m) == struct.pack("=" + fmt * 3, lo, hi, err) + assert vec[t](array.array(fmt, [lo, hi, 3])) == vec[t]([lo, hi, 3]) + assert len(vec[t](array.array(fmt))) == 0 + # Buffer with a different format falls back to item-by-item conversion + assert vec[t](array.array("i" if fmt != "i" else "h", [1, 2])) == vec[t]([1, 2]) + assert vec[t](bytes([1, 2])) == vec[t]([1, 2]) diff --git a/mypyc/test-data/run-vecs-misc.test b/mypyc/test-data/run-vecs-misc.test index f3ebe11ff55e2..639cf36de1c59 100644 --- a/mypyc/test-data/run-vecs-misc.test +++ b/mypyc/test-data/run-vecs-misc.test @@ -443,3 +443,362 @@ def test_vec_u8_to_list() -> None: def test_vec_u8_to_tuple() -> None: assert u8_to_tuple(vec[u8]()) == () assert u8_to_tuple(vec[u8]([0, 128, 255])) == (0, 128, 255) + +[case testVecNewNativeIntItemTypes_librt] +# mypy: allow-redefinition-old + +import array +import struct +from typing import Any, cast +from mypy_extensions import i64, i16, i8, u64, u32, u16, u8 +from librt.vecs import vec, append, extend, remove, pop +from testutil import assertRaises + +def raises_any(f: Any) -> bool: + # Compiled and interpreted code may raise different exception types for + # values that don't fit in the item type + try: + f() + except (OverflowError, ValueError, TypeError): + return True + return False + +def test_i8() -> None: + v = vec[i8]() + assert len(v) == 0 + assert str(v) == "vec[i8]([])" + v = vec[i8]([-128, 127, -113, 1]) + assert str(v) == "vec[i8]([-128, 127, -113, 1])" + assert len(v) == 4 + assert v[0] == -128 and v[1] == 127 and v[2] == -113 and v[3] == 1 + assert v[-4] == -128 and v[-1] == 1 + x: i8 = v[1] + assert x == 127 + v[0] = 127 + v[-1] = -113 + assert v == vec[i8]([127, 127, -113, -113]) + with assertRaises(IndexError): + v[4] + with assertRaises(IndexError): + v[-5] = 1 + + v = vec[i8]() + for i in range(100): + v = append(v, i8(i)) + v = append(v, 127) + assert len(v) == 101 + assert v[100] == 127 + v, y = pop(v) + assert y == 127 and len(v) == 100 + v, y = pop(v, 0) + assert y == 0 and v[0] == 1 + v = remove(v, 50) + assert len(v) == 98 + assert 50 not in v + assert 49 in v + assert 127 not in v + with assertRaises(ValueError): + remove(v, 50) + v = extend(vec[i8]([127]), [1, 2]) + v = extend(v, vec[i8]([-113, -128])) + v = extend(v, (x for x in [7])) + assert v == vec[i8]([127, 1, 2, -113, -128, 7]) + assert v[1:3] == vec[i8]([1, 2]) + assert v[::-1] == vec[i8]([7, -128, -113, 2, 1, 127]) + assert [x for x in v] == [127, 1, 2, -113, -128, 7] + total = 0 + for x in v: + total += int(x) + assert total == 127 + 1 + 2 + -113 + -128 + 7 + + # Values that don't fit in the item type + bad: list[Any] = [127 + 1, -128 - 1, 1.0, "x"] + for b in bad: + assert raises_any(lambda: vec[i8]([b])) + assert raises_any(lambda: cast(Any, append)(vec[i8](), b)) + # In compiled code, the operand is converted to the item type first + assert raises_any(lambda: b in vec[i8]([1])) or b not in vec[i8]([1]) + + # Boxing and unboxing + a: Any = vec[i8]([127, -113]) + vv: vec[i8] = a + assert vv[0] == 127 and vv[1] == -113 + assert type(a) is type(vec[i8]()) + for other in (vec[i64]([1]), vec[u8]([1]), vec[i16]([1]), [1]): + with assertRaises(TypeError): + vv = cast(Any, other) + assert isinstance(a, vec) + + # Nested vecs + n = vec[vec[i8]]([vec[i8]([127]), vec[i8]()]) + n = append(n, vec[i8]([-128, -113])) + assert str(n) == "vec[vec[i8]]([[127], [], [-128, -113]])" + assert n[0][0] == 127 + assert n[2][1] == -113 + n, last = pop(n) + assert last == vec[i8]([-128, -113]) + an: Any = n + with assertRaises(TypeError): + append(an, vec[i64]([1])) + + # Buffer protocol + m: Any = memoryview(vec[i8]([-128, 127])) + assert m.format == "b" + assert m.itemsize == struct.calcsize("b") + assert m.tolist() == [-128, 127] + assert vec[i8](array.array("b", [-128, 127, 3])) == vec[i8]([-128, 127, 3]) + +def test_u16() -> None: + v = vec[u16]() + assert len(v) == 0 + assert str(v) == "vec[u16]([])" + v = vec[u16]([0, 65535, 239, 1]) + assert str(v) == "vec[u16]([0, 65535, 239, 1])" + assert len(v) == 4 + assert v[0] == 0 and v[1] == 65535 and v[2] == 239 and v[3] == 1 + assert v[-4] == 0 and v[-1] == 1 + x: u16 = v[1] + assert x == 65535 + v[0] = 65535 + v[-1] = 239 + assert v == vec[u16]([65535, 65535, 239, 239]) + with assertRaises(IndexError): + v[4] + with assertRaises(IndexError): + v[-5] = 1 + + v = vec[u16]() + for i in range(100): + v = append(v, u16(i)) + v = append(v, 65535) + assert len(v) == 101 + assert v[100] == 65535 + v, y = pop(v) + assert y == 65535 and len(v) == 100 + v, y = pop(v, 0) + assert y == 0 and v[0] == 1 + v = remove(v, 50) + assert len(v) == 98 + assert 50 not in v + assert 49 in v + assert 65535 not in v + with assertRaises(ValueError): + remove(v, 50) + v = extend(vec[u16]([65535]), [1, 2]) + v = extend(v, vec[u16]([239, 0])) + v = extend(v, (x for x in [7])) + assert v == vec[u16]([65535, 1, 2, 239, 0, 7]) + assert v[1:3] == vec[u16]([1, 2]) + assert v[::-1] == vec[u16]([7, 0, 239, 2, 1, 65535]) + assert [x for x in v] == [65535, 1, 2, 239, 0, 7] + total = 0 + for x in v: + total += int(x) + assert total == 65535 + 1 + 2 + 239 + 0 + 7 + + # Values that don't fit in the item type + bad: list[Any] = [65535 + 1, 0 - 1, 1.0, "x"] + for b in bad: + assert raises_any(lambda: vec[u16]([b])) + assert raises_any(lambda: cast(Any, append)(vec[u16](), b)) + # In compiled code, the operand is converted to the item type first + assert raises_any(lambda: b in vec[u16]([1])) or b not in vec[u16]([1]) + + # Boxing and unboxing + a: Any = vec[u16]([65535, 239]) + vv: vec[u16] = a + assert vv[0] == 65535 and vv[1] == 239 + assert type(a) is type(vec[u16]()) + for other in (vec[i64]([1]), vec[u8]([1]), vec[i16]([1]), [1]): + with assertRaises(TypeError): + vv = cast(Any, other) + assert isinstance(a, vec) + + # Nested vecs + n = vec[vec[u16]]([vec[u16]([65535]), vec[u16]()]) + n = append(n, vec[u16]([0, 239])) + assert str(n) == "vec[vec[u16]]([[65535], [], [0, 239]])" + assert n[0][0] == 65535 + assert n[2][1] == 239 + n, last = pop(n) + assert last == vec[u16]([0, 239]) + an: Any = n + with assertRaises(TypeError): + append(an, vec[i64]([1])) + + # Buffer protocol + m: Any = memoryview(vec[u16]([0, 65535])) + assert m.format == "H" + assert m.itemsize == struct.calcsize("H") + assert m.tolist() == [0, 65535] + assert vec[u16](array.array("H", [0, 65535, 3])) == vec[u16]([0, 65535, 3]) + +def test_u32() -> None: + v = vec[u32]() + assert len(v) == 0 + assert str(v) == "vec[u32]([])" + v = vec[u32]([0, 4294967295, 239, 1]) + assert str(v) == "vec[u32]([0, 4294967295, 239, 1])" + assert len(v) == 4 + assert v[0] == 0 and v[1] == 4294967295 and v[2] == 239 and v[3] == 1 + assert v[-4] == 0 and v[-1] == 1 + x: u32 = v[1] + assert x == 4294967295 + v[0] = 4294967295 + v[-1] = 239 + assert v == vec[u32]([4294967295, 4294967295, 239, 239]) + with assertRaises(IndexError): + v[4] + with assertRaises(IndexError): + v[-5] = 1 + + v = vec[u32]() + for i in range(100): + v = append(v, u32(i)) + v = append(v, 4294967295) + assert len(v) == 101 + assert v[100] == 4294967295 + v, y = pop(v) + assert y == 4294967295 and len(v) == 100 + v, y = pop(v, 0) + assert y == 0 and v[0] == 1 + v = remove(v, 50) + assert len(v) == 98 + assert 50 not in v + assert 49 in v + assert 4294967295 not in v + with assertRaises(ValueError): + remove(v, 50) + v = extend(vec[u32]([4294967295]), [1, 2]) + v = extend(v, vec[u32]([239, 0])) + v = extend(v, (x for x in [7])) + assert v == vec[u32]([4294967295, 1, 2, 239, 0, 7]) + assert v[1:3] == vec[u32]([1, 2]) + assert v[::-1] == vec[u32]([7, 0, 239, 2, 1, 4294967295]) + assert [x for x in v] == [4294967295, 1, 2, 239, 0, 7] + total = 0 + for x in v: + total += int(x) + assert total == 4294967295 + 1 + 2 + 239 + 0 + 7 + + # Values that don't fit in the item type + bad: list[Any] = [4294967295 + 1, 0 - 1, 1.0, "x"] + for b in bad: + assert raises_any(lambda: vec[u32]([b])) + assert raises_any(lambda: cast(Any, append)(vec[u32](), b)) + # In compiled code, the operand is converted to the item type first + assert raises_any(lambda: b in vec[u32]([1])) or b not in vec[u32]([1]) + + # Boxing and unboxing + a: Any = vec[u32]([4294967295, 239]) + vv: vec[u32] = a + assert vv[0] == 4294967295 and vv[1] == 239 + assert type(a) is type(vec[u32]()) + for other in (vec[i64]([1]), vec[u8]([1]), vec[i16]([1]), [1]): + with assertRaises(TypeError): + vv = cast(Any, other) + assert isinstance(a, vec) + + # Nested vecs + n = vec[vec[u32]]([vec[u32]([4294967295]), vec[u32]()]) + n = append(n, vec[u32]([0, 239])) + assert str(n) == "vec[vec[u32]]([[4294967295], [], [0, 239]])" + assert n[0][0] == 4294967295 + assert n[2][1] == 239 + n, last = pop(n) + assert last == vec[u32]([0, 239]) + an: Any = n + with assertRaises(TypeError): + append(an, vec[i64]([1])) + + # Buffer protocol + m: Any = memoryview(vec[u32]([0, 4294967295])) + assert m.format == "I" + assert m.itemsize == struct.calcsize("I") + assert m.tolist() == [0, 4294967295] + assert vec[u32](array.array("I", [0, 4294967295, 3])) == vec[u32]([0, 4294967295, 3]) + +def test_u64() -> None: + v = vec[u64]() + assert len(v) == 0 + assert str(v) == "vec[u64]([])" + v = vec[u64]([0, 18446744073709551615, 239, 1]) + assert str(v) == "vec[u64]([0, 18446744073709551615, 239, 1])" + assert len(v) == 4 + assert v[0] == 0 and v[1] == 18446744073709551615 and v[2] == 239 and v[3] == 1 + assert v[-4] == 0 and v[-1] == 1 + x: u64 = v[1] + assert x == 18446744073709551615 + v[0] = 18446744073709551615 + v[-1] = 239 + assert v == vec[u64]([18446744073709551615, 18446744073709551615, 239, 239]) + with assertRaises(IndexError): + v[4] + with assertRaises(IndexError): + v[-5] = 1 + + v = vec[u64]() + for i in range(100): + v = append(v, u64(i)) + v = append(v, 18446744073709551615) + assert len(v) == 101 + assert v[100] == 18446744073709551615 + v, y = pop(v) + assert y == 18446744073709551615 and len(v) == 100 + v, y = pop(v, 0) + assert y == 0 and v[0] == 1 + v = remove(v, 50) + assert len(v) == 98 + assert 50 not in v + assert 49 in v + assert 18446744073709551615 not in v + with assertRaises(ValueError): + remove(v, 50) + v = extend(vec[u64]([18446744073709551615]), [1, 2]) + v = extend(v, vec[u64]([239, 0])) + v = extend(v, (x for x in [7])) + assert v == vec[u64]([18446744073709551615, 1, 2, 239, 0, 7]) + assert v[1:3] == vec[u64]([1, 2]) + assert v[::-1] == vec[u64]([7, 0, 239, 2, 1, 18446744073709551615]) + assert [x for x in v] == [18446744073709551615, 1, 2, 239, 0, 7] + total = 0 + for x in v: + total += int(x) + assert total == 18446744073709551615 + 1 + 2 + 239 + 0 + 7 + + # Values that don't fit in the item type + bad: list[Any] = [18446744073709551615 + 1, 0 - 1, 1.0, "x"] + for b in bad: + assert raises_any(lambda: vec[u64]([b])) + assert raises_any(lambda: cast(Any, append)(vec[u64](), b)) + # In compiled code, the operand is converted to the item type first + assert raises_any(lambda: b in vec[u64]([1])) or b not in vec[u64]([1]) + + # Boxing and unboxing + a: Any = vec[u64]([18446744073709551615, 239]) + vv: vec[u64] = a + assert vv[0] == 18446744073709551615 and vv[1] == 239 + assert type(a) is type(vec[u64]()) + for other in (vec[i64]([1]), vec[u8]([1]), vec[i16]([1]), [1]): + with assertRaises(TypeError): + vv = cast(Any, other) + assert isinstance(a, vec) + + # Nested vecs + n = vec[vec[u64]]([vec[u64]([18446744073709551615]), vec[u64]()]) + n = append(n, vec[u64]([0, 239])) + assert str(n) == "vec[vec[u64]]([[18446744073709551615], [], [0, 239]])" + assert n[0][0] == 18446744073709551615 + assert n[2][1] == 239 + n, last = pop(n) + assert last == vec[u64]([0, 239]) + an: Any = n + with assertRaises(TypeError): + append(an, vec[i64]([1])) + + # Buffer protocol + m: Any = memoryview(vec[u64]([0, 18446744073709551615])) + assert m.format == "Q" + assert m.itemsize == struct.calcsize("Q") + assert m.tolist() == [0, 18446744073709551615] + assert vec[u64](array.array("Q", [0, 18446744073709551615, 3])) == vec[u64]([0, 18446744073709551615, 3])