Issue #22207: Fix "comparison between signed and unsigned integers" warning in

test checking for integer overflow on Py_ssize_t type: cast explicitly to
size_t.

diff --git a/Modules/_codecsmodule.c b/Modules/_codecsmodule.c
index 1b21300c8d594183a7665424a22d7aa2f3cf59d3..ac25998d7baa3451ca61cef4dd46abe0c48195a6 100644 (file)
--- a/Modules/_codecsmodule.c
+++ b/Modules/_codecsmodule.c
@@ -699,7 +699,7 @@ unicode_internal_encode(PyObject *self,
         u = PyUnicode_AsUnicodeAndSize(obj, &len);
         if (u == NULL)
             return NULL;
-        if (len > PY_SSIZE_T_MAX / sizeof(Py_UNICODE))
+        if ((size_t)len > (size_t)PY_SSIZE_T_MAX / sizeof(Py_UNICODE))
             return PyErr_NoMemory();
         size = len * sizeof(Py_UNICODE);
         return codec_tuple(PyBytes_FromStringAndSize((const char*)u, size),

diff --git a/Modules/_lzmamodule.c b/Modules/_lzmamodule.c
index c43676ab75f1aea1e961fb17d070e45d3c481b3a..dfb95fade1fd15c78c6f690a78e6523ae66da12c 100644 (file)
--- a/Modules/_lzmamodule.c
+++ b/Modules/_lzmamodule.c
@@ -533,7 +533,7 @@ compress(Compressor *c, uint8_t *data, size_t len, lzma_action action)
             c->lzs.avail_out = PyBytes_GET_SIZE(result) - data_size;
         }
     }
-    if (data_size != PyBytes_GET_SIZE(result))
+    if (data_size != (size_t)PyBytes_GET_SIZE(result))
         if (_PyBytes_Resize(&result, data_size) == -1)
             goto error;
     return result;
@@ -931,7 +931,7 @@ decompress(Decompressor *d, uint8_t *data, size_t len)
             d->lzs.avail_out = PyBytes_GET_SIZE(result) - data_size;
         }
     }
-    if (data_size != PyBytes_GET_SIZE(result))
+    if (data_size != (size_t)PyBytes_GET_SIZE(result))
         if (_PyBytes_Resize(&result, data_size) == -1)
             goto error;
     return result;

diff --git a/Modules/_pickle.c b/Modules/_pickle.c
index 1c15190f8279227f725067a005af4d8d0a3e958b..ba9ba9907188a93d4ec6df2cbec599e45ea73434 100644 (file)
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -2052,7 +2052,8 @@ raw_unicode_escape(PyObject *obj)
 {
     PyObject *repr;
     char *p;
-    Py_ssize_t i, size, expandsize;
+    Py_ssize_t i, size;
+    size_t expandsize;
     void *data;
     unsigned int kind;
 
@@ -2067,7 +2068,7 @@ raw_unicode_escape(PyObject *obj)
     else
         expandsize = 6;
 
-    if (size > PY_SSIZE_T_MAX / expandsize)
+    if ((size_t)size > (size_t)PY_SSIZE_T_MAX / expandsize)
         return PyErr_NoMemory();
     repr = PyBytes_FromStringAndSize(NULL, expandsize * size);
     if (repr == NULL)

diff --git a/Modules/fcntlmodule.c b/Modules/fcntlmodule.c
index cf0ac19976f915c8831a393d33472a4e1ca8a4be..56e40212d1c16bf5f85928339b91fefa89afd339 100644 (file)
--- a/Modules/fcntlmodule.c
+++ b/Modules/fcntlmodule.c
@@ -42,7 +42,7 @@ fcntl_fcntl(PyObject *self, PyObject *args)
 
     if (PyArg_ParseTuple(args, "O&is#:fcntl",
                          conv_descriptor, &fd, &code, &str, &len)) {
-        if (len > sizeof buf) {
+        if ((size_t)len > sizeof buf) {
             PyErr_SetString(PyExc_ValueError,
                             "fcntl string arg too long");
             return NULL;

diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
index 7f525ea66fc443df5df95208f082202dc3422e63..bce3799ced2daacc17dd8048fd322686f119d368 100644 (file)
--- a/Modules/mathmodule.c
+++ b/Modules/mathmodule.c
@@ -1010,7 +1010,7 @@ _fsum_realloc(double **p_ptr, Py_ssize_t  n,
     Py_ssize_t m = *m_ptr;
 
     m += m;  /* double */
-    if (n < m && m < (PY_SSIZE_T_MAX / sizeof(double))) {
+    if (n < m && (size_t)m < ((size_t)PY_SSIZE_T_MAX / sizeof(double))) {
         double *p = *p_ptr;
         if (p == ps) {
             v = PyMem_Malloc(sizeof(double) * m);

diff --git a/Objects/bytesobject.c b/Objects/bytesobject.c
index c5af25350e97b12bfb9ac6bfb819844f82380932..f0c26c33e5015871bcfb4ca4b0d299ce9c9f88a2 100644 (file)
--- a/Objects/bytesobject.c
+++ b/Objects/bytesobject.c
@@ -81,6 +81,7 @@ _PyBytes_FromSize(Py_ssize_t size, int use_calloc)
 {
     PyBytesObject *op;
     assert(size >= 0);
+
     if (size == 0 && (op = nullstring) != NULL) {
 #ifdef COUNT_ALLOCS
         null_strings++;
@@ -89,7 +90,7 @@ _PyBytes_FromSize(Py_ssize_t size, int use_calloc)
         return (PyObject *)op;
     }
 
-    if (size > PY_SSIZE_T_MAX - PyBytesObject_SIZE) {
+    if ((size_t)size > (size_t)PY_SSIZE_T_MAX - PyBytesObject_SIZE) {
         PyErr_SetString(PyExc_OverflowError,
                         "byte string is too large");
         return NULL;
@@ -1755,7 +1756,7 @@ bytes_count(PyBytesObject *self, PyObject *args)
 bytes.translate
 
     self: self(type="PyBytesObject *")
-    table: object   
+    table: object
         Translation table, which must be a bytes object of length 256.
     [
     deletechars: object
@@ -3328,7 +3329,7 @@ PyBytes_Concat(PyObject **pv, PyObject *w)
         /* Only one reference, so we can resize in place */
         Py_ssize_t oldsize;
         Py_buffer wb;
-        
+
         wb.len = -1;
         if (_getbuffer(w, &wb) < 0) {
             PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",

diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 753097bef2635b24d38f2cc206a37e9f937ce926..e45462b9cdc3fbada9bdffa1e9fbbb30e1b66bc6 100644 (file)
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -97,7 +97,7 @@ PyTuple_New(Py_ssize_t size)
 #endif
     {
         /* Check for overflow */
-        if (size > (PY_SSIZE_T_MAX - sizeof(PyTupleObject) -
+        if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - sizeof(PyTupleObject) -
                     sizeof(PyObject *)) / sizeof(PyObject *)) {
             return PyErr_NoMemory();
         }

diff --git a/Python/asdl.c b/Python/asdl.c
index 74fa9410e49361cab000dbe9b581b78ab086371c..df387b2119b6559c7a15b79735b5a8d685153bd7 100644 (file)
--- a/Python/asdl.c
+++ b/Python/asdl.c
@@ -5,21 +5,21 @@ asdl_seq *
 _Py_asdl_seq_new(Py_ssize_t size, PyArena *arena)
 {
     asdl_seq *seq = NULL;
-    size_t n = (size ? (sizeof(void *) * (size - 1)) : 0);
+    size_t n;
 
     /* check size is sane */
-    if (size < 0 || size == INT_MIN ||
-        (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
+    if (size < 0 ||
+        (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
         PyErr_NoMemory();
         return NULL;
     }
+    n = (size ? (sizeof(void *) * (size - 1)) : 0);
 
     /* check if size can be added safely */
     if (n > PY_SIZE_MAX - sizeof(asdl_seq)) {
         PyErr_NoMemory();
         return NULL;
     }
-
     n += sizeof(asdl_seq);
 
     seq = (asdl_seq *)PyArena_Malloc(arena, n);
@@ -36,21 +36,21 @@ asdl_int_seq *
 _Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena)
 {
     asdl_int_seq *seq = NULL;
-    size_t n = (size ? (sizeof(void *) * (size - 1)) : 0);
+    size_t n;
 
     /* check size is sane */
-    if (size < 0 || size == INT_MIN ||
-        (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
+    if (size < 0 ||
+        (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
             PyErr_NoMemory();
             return NULL;
     }
+    n = (size ? (sizeof(void *) * (size - 1)) : 0);
 
     /* check if size can be added safely */
     if (n > PY_SIZE_MAX - sizeof(asdl_seq)) {
         PyErr_NoMemory();
         return NULL;
     }
-
     n += sizeof(asdl_seq);
 
     seq = (asdl_int_seq *)PyArena_Malloc(arena, n);