diff --git a/mypyc/build.py b/mypyc/build.py index 9050eef18d27..8cb71c69c3f2 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 3fd0f44acead..c018307d5645 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 14be734866f8..62013e0c3499 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 a7f5bc3ffbd9..fb7b9ba4ce46 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 18b37f0fcb64..9bfd333cc890 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 15d31a443ff8..4c479f5bfc7e 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 88ff47fdda80..5db20effc26e 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 66aa4087b306..cedc77433179 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 8c45874f1bfd..dc30daa53ae1 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 6f42c0b7251d..72192055192b 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 000000000000..0f2f1c5b4639 --- /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 000000000000..82cb9150bb96 --- /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 000000000000..da1942f76a47 --- /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 000000000000..4b05caf066d9 --- /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 22037d8597a7..bea5cef0eda2 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 8cce013cb713..78363a9f9ef9 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 f3ebe11ff55e..639cf36de1c5 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])