From 18e165558b24d29e7e0ca501842b9236589b012a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20v=2E=20L=C3=B6wis?= Date: Wed, 15 Feb 2006 17:27:45 +0000 Subject: Merge ssize_t branch. --- Include/abstract.h | 36 +-- Include/bufferobject.h | 12 +- Include/cStringIO.h | 4 +- Include/ceval.h | 2 +- Include/dictobject.h | 4 +- Include/intobject.h | 5 +- Include/listobject.h | 16 +- Include/longintrepr.h | 2 +- Include/longobject.h | 7 +- Include/marshal.h | 2 +- Include/modsupport.h | 32 +- Include/object.h | 48 +-- Include/objimpl.h | 6 +- Include/pyerrors.h | 30 +- Include/pyport.h | 9 + Include/pystrtod.h | 2 +- Include/sliceobject.h | 10 +- Include/stringobject.h | 16 +- Include/tupleobject.h | 14 +- Include/unicodeobject.h | 92 +++--- Lib/test/string_tests.py | 4 +- Misc/NEWS | 2 + Modules/_bsddb.c | 6 +- Modules/_codecsmodule.c | 71 +++-- Modules/_elementtree.c | 29 +- Modules/_hotshot.c | 19 +- Modules/_localemodule.c | 4 +- Modules/_testcapimodule.c | 3 +- Modules/arraymodule.c | 193 ++++++------ Modules/audioop.c | 4 +- Modules/bsddbmodule.c | 4 +- Modules/bz2module.c | 2 +- Modules/cPickle.c | 62 ++-- Modules/cStringIO.c | 55 ++-- Modules/cjkcodecs/multibytecodec.c | 2 +- Modules/collectionsmodule.c | 16 +- Modules/datetimemodule.c | 4 +- Modules/dbmmodule.c | 4 +- Modules/gcmodule.c | 2 +- Modules/gdbmmodule.c | 4 +- Modules/mmapmodule.c | 48 +-- Modules/parsermodule.c | 11 +- Modules/posixmodule.c | 41 +-- Modules/rgbimgmodule.c | 7 +- Modules/selectmodule.c | 2 +- Modules/shamodule.c | 2 +- Modules/stropmodule.c | 12 +- Modules/zipimport.c | 6 +- Objects/abstract.c | 86 +++--- Objects/bufferobject.c | 124 ++++---- Objects/classobject.c | 48 +-- Objects/codeobject.c | 6 +- Objects/complexobject.c | 4 +- Objects/descrobject.c | 8 +- Objects/dictobject.c | 32 +- Objects/enumobject.c | 2 +- Objects/fileobject.c | 33 ++- Objects/floatobject.c | 4 +- Objects/frameobject.c | 22 +- Objects/funcobject.c | 16 +- Objects/intobject.c | 71 ++++- Objects/iterobject.c | 2 +- Objects/listobject.c | 274 +++++++++-------- Objects/longobject.c | 188 ++++++++---- Objects/methodobject.c | 6 +- Objects/moduleobject.c | 2 +- Objects/object.c | 23 +- Objects/obmalloc.c | 11 +- Objects/rangeobject.c | 14 +- Objects/setobject.c | 37 +-- Objects/sliceobject.c | 13 +- Objects/stringobject.c | 313 ++++++++++---------- Objects/structseq.c | 28 +- Objects/tupleobject.c | 92 +++--- Objects/typeobject.c | 164 ++++++----- Objects/unicodeobject.c | 586 +++++++++++++++++++------------------ Objects/weakrefobject.c | 18 +- PC/getpathp.c | 10 +- PC/import_nt.c | 7 +- PC/pyconfig.h | 10 + Parser/parsetok.c | 3 +- Parser/tokenizer.c | 20 +- Python/bltinmodule.c | 18 +- Python/ceval.c | 13 +- Python/codecs.c | 28 +- Python/compile.c | 22 +- Python/exceptions.c | 118 ++++---- Python/getargs.c | 262 +++++++++++++---- Python/import.c | 34 ++- Python/mactoolboxglue.c | 4 +- Python/marshal.c | 26 +- Python/modsupport.c | 7 +- Python/pystrtod.c | 2 +- Python/pythonrun.c | 2 +- Python/symtable.c | 8 +- Python/sysmodule.c | 2 +- Python/thread_nt.h | 4 +- RISCOS/Modules/drawfmodule.c | 26 +- RISCOS/Modules/swimodule.c | 26 +- configure | 480 +++++++++++++++++++++++++++++- configure.in | 3 + pyconfig.h.in | 6 + 102 files changed, 2659 insertions(+), 1677 deletions(-) diff --git a/Include/abstract.h b/Include/abstract.h index fd15173..03eb30a 100644 --- a/Include/abstract.h +++ b/Include/abstract.h @@ -407,7 +407,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ equivalent to the Python expression: type(o). */ - PyAPI_FUNC(int) PyObject_Size(PyObject *o); + PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o); /* Return the size of object o. If the object, o, provides @@ -419,10 +419,10 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ /* For DLL compatibility */ #undef PyObject_Length - PyAPI_FUNC(int) PyObject_Length(PyObject *o); + PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o); #define PyObject_Length PyObject_Size - PyAPI_FUNC(int) _PyObject_LengthHint(PyObject *o); + PyAPI_FUNC(Py_ssize_t) _PyObject_LengthHint(PyObject *o); /* Return the size of object o. If the object, o, provides @@ -477,7 +477,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj, const char **buffer, - int *buffer_len); + Py_ssize_t *buffer_len); /* Takes an arbitrary object which must support the (character, @@ -502,7 +502,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, const void **buffer, - int *buffer_len); + Py_ssize_t *buffer_len); /* Same as PyObject_AsCharBuffer() except that this API expects @@ -518,7 +518,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, void **buffer, - int *buffer_len); + Py_ssize_t *buffer_len); /* Takes an arbitrary object which must support the (writeable, @@ -911,7 +911,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ */ - PyAPI_FUNC(int) PySequence_Size(PyObject *o); + PyAPI_FUNC(Py_ssize_t) PySequence_Size(PyObject *o); /* Return the size of sequence object o, or -1 on failure. @@ -920,7 +920,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ /* For DLL compatibility */ #undef PySequence_Length - PyAPI_FUNC(int) PySequence_Length(PyObject *o); + PyAPI_FUNC(Py_ssize_t) PySequence_Length(PyObject *o); #define PySequence_Length PySequence_Size @@ -933,7 +933,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ */ - PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, int count); + PyAPI_FUNC(PyObject *) PySequence_Repeat(PyObject *o, Py_ssize_t count); /* Return the result of repeating sequence object o count times, @@ -942,14 +942,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ */ - PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, int i); + PyAPI_FUNC(PyObject *) PySequence_GetItem(PyObject *o, Py_ssize_t i); /* Return the ith element of o, or NULL on failure. This is the equivalent of the Python expression: o[i]. */ - PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, int i1, int i2); + PyAPI_FUNC(PyObject *) PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2); /* Return the slice of sequence object o between i1 and i2, or @@ -958,7 +958,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ */ - PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, int i, PyObject *v); + PyAPI_FUNC(int) PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v); /* Assign object v to the ith element of o. Returns @@ -967,7 +967,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ */ - PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, int i); + PyAPI_FUNC(int) PySequence_DelItem(PyObject *o, Py_ssize_t i); /* Delete the ith element of object v. Returns @@ -975,7 +975,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ statement: del o[i]. */ - PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, int i1, int i2, + PyAPI_FUNC(int) PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, PyObject *v); /* @@ -984,7 +984,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ equivalent of the Python statement: o[i1:i2]=v. */ - PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, int i1, int i2); + PyAPI_FUNC(int) PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2); /* Delete the slice in sequence object, o, from i1 to i2. @@ -1105,7 +1105,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ */ - PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, int count); + PyAPI_FUNC(PyObject *) PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count); /* Repeat o1 by count, in-place when possible. Return the resulting @@ -1125,7 +1125,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ This function always succeeds. */ - PyAPI_FUNC(int) PyMapping_Size(PyObject *o); + PyAPI_FUNC(Py_ssize_t) PyMapping_Size(PyObject *o); /* Returns the number of keys in object o on success, and -1 on @@ -1135,7 +1135,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ /* For DLL compatibility */ #undef PyMapping_Length - PyAPI_FUNC(int) PyMapping_Length(PyObject *o); + PyAPI_FUNC(Py_ssize_t) PyMapping_Length(PyObject *o); #define PyMapping_Length PyMapping_Size diff --git a/Include/bufferobject.h b/Include/bufferobject.h index ed2c91d..75ba496 100644 --- a/Include/bufferobject.h +++ b/Include/bufferobject.h @@ -17,15 +17,15 @@ PyAPI_DATA(PyTypeObject) PyBuffer_Type; #define Py_END_OF_BUFFER (-1) PyAPI_FUNC(PyObject *) PyBuffer_FromObject(PyObject *base, - int offset, int size); + Py_ssize_t offset, Py_ssize_t size); PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteObject(PyObject *base, - int offset, - int size); + Py_ssize_t offset, + Py_ssize_t size); -PyAPI_FUNC(PyObject *) PyBuffer_FromMemory(void *ptr, int size); -PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, int size); +PyAPI_FUNC(PyObject *) PyBuffer_FromMemory(void *ptr, Py_ssize_t size); +PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size); -PyAPI_FUNC(PyObject *) PyBuffer_New(int size); +PyAPI_FUNC(PyObject *) PyBuffer_New(Py_ssize_t size); #ifdef __cplusplus } diff --git a/Include/cStringIO.h b/Include/cStringIO.h index 290a103..25fc9dd 100644 --- a/Include/cStringIO.h +++ b/Include/cStringIO.h @@ -29,7 +29,7 @@ static struct PycStringIO_CAPI { /* Read a string from an input object. If the last argument is -1, the remainder will be read. */ - int(*cread)(PyObject *, char **, int); + int(*cread)(PyObject *, char **, Py_ssize_t); /* Read a line from an input object. Returns the length of the read line as an int and a pointer inside the object buffer as char** (so @@ -38,7 +38,7 @@ static struct PycStringIO_CAPI { int(*creadline)(PyObject *, char **); /* Write a string to an output object*/ - int(*cwrite)(PyObject *, const char *, int); + int(*cwrite)(PyObject *, const char *, Py_ssize_t); /* Get the output object as a Python string (returns new reference). */ PyObject *(*cgetvalue)(PyObject *); diff --git a/Include/ceval.h b/Include/ceval.h index 6db0818..f441197 100644 --- a/Include/ceval.h +++ b/Include/ceval.h @@ -148,7 +148,7 @@ PyAPI_FUNC(void) PyEval_ReInitThreads(void); #endif /* !WITH_THREAD */ -PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, int *); +PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); #ifdef __cplusplus diff --git a/Include/dictobject.h b/Include/dictobject.h index 3da1273..c917782 100644 --- a/Include/dictobject.h +++ b/Include/dictobject.h @@ -95,11 +95,11 @@ PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item); PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key); PyAPI_FUNC(void) PyDict_Clear(PyObject *mp); PyAPI_FUNC(int) PyDict_Next( - PyObject *mp, int *pos, PyObject **key, PyObject **value); + PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value); PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp); PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp); PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp); -PyAPI_FUNC(int) PyDict_Size(PyObject *mp); +PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp); PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp); PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key); diff --git a/Include/intobject.h b/Include/intobject.h index 1bbd59c..1f4846e 100644 --- a/Include/intobject.h +++ b/Include/intobject.h @@ -32,10 +32,13 @@ PyAPI_DATA(PyTypeObject) PyInt_Type; PyAPI_FUNC(PyObject *) PyInt_FromString(char*, char**, int); #ifdef Py_USING_UNICODE -PyAPI_FUNC(PyObject *) PyInt_FromUnicode(Py_UNICODE*, int, int); +PyAPI_FUNC(PyObject *) PyInt_FromUnicode(Py_UNICODE*, Py_ssize_t, int); #endif PyAPI_FUNC(PyObject *) PyInt_FromLong(long); +PyAPI_FUNC(PyObject *) PyInt_FromSize_t(size_t); +PyAPI_FUNC(PyObject *) PyInt_FromSsize_t(Py_ssize_t); PyAPI_FUNC(long) PyInt_AsLong(PyObject *); +PyAPI_FUNC(Py_ssize_t) PyInt_AsSsize_t(PyObject *); PyAPI_FUNC(unsigned long) PyInt_AsUnsignedLongMask(PyObject *); #ifdef HAVE_LONG_LONG PyAPI_FUNC(unsigned PY_LONG_LONG) PyInt_AsUnsignedLongLongMask(PyObject *); diff --git a/Include/listobject.h b/Include/listobject.h index 0999a82..d9012ce 100644 --- a/Include/listobject.h +++ b/Include/listobject.h @@ -35,7 +35,7 @@ typedef struct { * Items must normally not be NULL, except during construction when * the list is not yet visible outside the function that builds it. */ - int allocated; + Py_ssize_t allocated; } PyListObject; PyAPI_DATA(PyTypeObject) PyList_Type; @@ -43,14 +43,14 @@ PyAPI_DATA(PyTypeObject) PyList_Type; #define PyList_Check(op) PyObject_TypeCheck(op, &PyList_Type) #define PyList_CheckExact(op) ((op)->ob_type == &PyList_Type) -PyAPI_FUNC(PyObject *) PyList_New(int size); -PyAPI_FUNC(int) PyList_Size(PyObject *); -PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, int); -PyAPI_FUNC(int) PyList_SetItem(PyObject *, int, PyObject *); -PyAPI_FUNC(int) PyList_Insert(PyObject *, int, PyObject *); +PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size); +PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *); +PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *); +PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *); PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *); -PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, int, int); -PyAPI_FUNC(int) PyList_SetSlice(PyObject *, int, int, PyObject *); +PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); +PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *); PyAPI_FUNC(int) PyList_Sort(PyObject *); PyAPI_FUNC(int) PyList_Reverse(PyObject *); PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *); diff --git a/Include/longintrepr.h b/Include/longintrepr.h index 254076e..b1574ba 100644 --- a/Include/longintrepr.h +++ b/Include/longintrepr.h @@ -52,7 +52,7 @@ struct _longobject { digit ob_digit[1]; }; -PyAPI_FUNC(PyLongObject *) _PyLong_New(int); +PyAPI_FUNC(PyLongObject *) _PyLong_New(Py_ssize_t); /* Return a copy of src. */ PyAPI_FUNC(PyObject *) _PyLong_Copy(PyLongObject *src); diff --git a/Include/longobject.h b/Include/longobject.h index 209c082..77544ef 100644 --- a/Include/longobject.h +++ b/Include/longobject.h @@ -21,6 +21,11 @@ PyAPI_FUNC(long) PyLong_AsLong(PyObject *); PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *); PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *); +/* For use by intobject.c only */ +PyAPI_FUNC(Py_ssize_t) _PyLong_AsSsize_t(PyObject *); +PyAPI_FUNC(PyObject *) _PyLong_FromSize_t(size_t); +PyAPI_FUNC(PyObject *) _PyLong_FromSsize_t(Py_ssize_t); + /* _PyLong_AsScaledDouble returns a double x and an exponent e such that the true value is approximately equal to x * 2**(SHIFT*e). e is >= 0. x is 0.0 if and only if the input is 0 (in which case, e and x are both @@ -43,7 +48,7 @@ PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *); PyAPI_FUNC(PyObject *) PyLong_FromString(char *, char **, int); #ifdef Py_USING_UNICODE -PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, int, int); +PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int); #endif /* _PyLong_Sign. Return 0 if v is 0, -1 if v < 0, +1 if v > 0. diff --git a/Include/marshal.h b/Include/marshal.h index a9f7320..411fdca 100644 --- a/Include/marshal.h +++ b/Include/marshal.h @@ -17,7 +17,7 @@ PyAPI_FUNC(long) PyMarshal_ReadLongFromFile(FILE *); PyAPI_FUNC(int) PyMarshal_ReadShortFromFile(FILE *); PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromFile(FILE *); PyAPI_FUNC(PyObject *) PyMarshal_ReadLastObjectFromFile(FILE *); -PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, int); +PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t); #ifdef __cplusplus } diff --git a/Include/modsupport.h b/Include/modsupport.h index 7851683..fc9f2e8 100644 --- a/Include/modsupport.h +++ b/Include/modsupport.h @@ -9,6 +9,18 @@ extern "C" { #include +/* If PY_SSIZE_T_CLEAN is defined, each functions treats #-specifier + to mean Py_ssize_t */ +#ifdef PY_SSIZE_T_CLEAN +#define PyArg_Parse _PyArg_Parse_SizeT +#define PyArg_ParseTuple _PyArg_ParseTuple_SizeT +#define PyArg_ParseTupleAndKeywords _PyArg_ParseTupleAndKeywords_SizeT +#define PyArg_VaParse _PyArg_VaParse_SizeT +#define PyArg_VaParseTupleAndKeywords _PyArg_VaParseTupleAndKeywords_SizeT +#define PyArg_BuildValue _PyArg_BuildValue_SizeT +#define PyArg_VaBuildValue _PyArg_VaBuildValue_SizeT +#endif + PyAPI_FUNC(int) PyArg_Parse(PyObject *, const char *, ...); PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...); PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *, @@ -26,6 +38,7 @@ PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *); PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long); PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *); + #define PYTHON_API_VERSION 1012 #define PYTHON_API_STRING "1012" /* The API version is maintained (independently from the Python version) @@ -77,11 +90,22 @@ PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char without actually needing a recompile. */ #endif /* MS_WINDOWS */ +#if SIZEOF_SIZE_T != SIZEOF_INT +/* On a 64-bit system, rename the Py_InitModule4 so that 2.4 + modules cannot get loaded into a 2.5 interpreter */ +#define Py_InitModule4 Py_InitModule4_64 +#endif + #ifdef Py_TRACE_REFS -/* When we are tracing reference counts, rename Py_InitModule4 so - modules compiled with incompatible settings will generate a - link-time error. */ -#define Py_InitModule4 Py_InitModule4TraceRefs + /* When we are tracing reference counts, rename Py_InitModule4 so + modules compiled with incompatible settings will generate a + link-time error. */ + #if SIZEOF_SIZE_T != SIZEOF_INT + #undef Py_InitModule4 + #define Py_InitModule4 Py_InitModule4TraceRefs_64 + #else + #define Py_InitModule4 Py_InitModule4TraceRefs + #endif #endif PyAPI_FUNC(PyObject *) Py_InitModule4(const char *name, PyMethodDef *methods, diff --git a/Include/object.h b/Include/object.h index ed6f3d1..faa3057 100644 --- a/Include/object.h +++ b/Include/object.h @@ -92,7 +92,8 @@ whose size is determined when the object is allocated. */ #define PyObject_VAR_HEAD \ PyObject_HEAD \ - int ob_size; /* Number of items in variable part */ + Py_ssize_t ob_size; /* Number of items in variable part */ +#define Py_INVALID_SIZE (Py_ssize_t)-1 /* Nothing is actually declared to be a PyObject, but every pointer to * a Python object can be cast to a PyObject*. This is inheritance built @@ -127,16 +128,29 @@ typedef PyObject * (*unaryfunc)(PyObject *); typedef PyObject * (*binaryfunc)(PyObject *, PyObject *); typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *); typedef int (*inquiry)(PyObject *); +typedef Py_ssize_t (*lenfunc)(PyObject *); typedef int (*coercion)(PyObject **, PyObject **); -typedef PyObject *(*intargfunc)(PyObject *, int); -typedef PyObject *(*intintargfunc)(PyObject *, int, int); +typedef PyObject *(*intargfunc)(PyObject *, int) Py_DEPRECATED(2.5); +typedef PyObject *(*intintargfunc)(PyObject *, int, int) Py_DEPRECATED(2.5); +typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t); +typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t); typedef int(*intobjargproc)(PyObject *, int, PyObject *); typedef int(*intintobjargproc)(PyObject *, int, int, PyObject *); +typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *); +typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *); typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *); + +/* int-based buffer interface */ typedef int (*getreadbufferproc)(PyObject *, int, void **); typedef int (*getwritebufferproc)(PyObject *, int, void **); typedef int (*getsegcountproc)(PyObject *, int *); typedef int (*getcharbufferproc)(PyObject *, int, const char **); +/* ssize_t-based buffer interface */ +typedef Py_ssize_t (*readbufferproc)(PyObject *, Py_ssize_t, void **); +typedef Py_ssize_t (*writebufferproc)(PyObject *, Py_ssize_t, void **); +typedef Py_ssize_t (*segcountproc)(PyObject *, Py_ssize_t *); +typedef Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, const char **); + typedef int (*objobjproc)(PyObject *, PyObject *); typedef int (*visitproc)(PyObject *, void *); typedef int (*traverseproc)(PyObject *, visitproc, void *); @@ -195,30 +209,30 @@ typedef struct { } PyNumberMethods; typedef struct { - inquiry sq_length; + lenfunc sq_length; binaryfunc sq_concat; - intargfunc sq_repeat; - intargfunc sq_item; - intintargfunc sq_slice; - intobjargproc sq_ass_item; - intintobjargproc sq_ass_slice; + ssizeargfunc sq_repeat; + ssizeargfunc sq_item; + ssizessizeargfunc sq_slice; + ssizeobjargproc sq_ass_item; + ssizessizeobjargproc sq_ass_slice; objobjproc sq_contains; /* Added in release 2.0 */ binaryfunc sq_inplace_concat; - intargfunc sq_inplace_repeat; + ssizeargfunc sq_inplace_repeat; } PySequenceMethods; typedef struct { - inquiry mp_length; + lenfunc mp_length; binaryfunc mp_subscript; objobjargproc mp_ass_subscript; } PyMappingMethods; typedef struct { - getreadbufferproc bf_getreadbuffer; - getwritebufferproc bf_getwritebuffer; - getsegcountproc bf_getsegcount; - getcharbufferproc bf_getcharbuffer; + readbufferproc bf_getreadbuffer; + writebufferproc bf_getwritebuffer; + segcountproc bf_getsegcount; + charbufferproc bf_getcharbuffer; } PyBufferProcs; @@ -239,7 +253,7 @@ typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *); typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *); typedef int (*initproc)(PyObject *, PyObject *, PyObject *); typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *); -typedef PyObject *(*allocfunc)(struct _typeobject *, int); +typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t); typedef struct _typeobject { PyObject_VAR_HEAD @@ -362,7 +376,7 @@ PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */ #define PyType_CheckExact(op) ((op)->ob_type == &PyType_Type) PyAPI_FUNC(int) PyType_Ready(PyTypeObject *); -PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, int); +PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t); PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *, PyObject *, PyObject *); PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *); diff --git a/Include/objimpl.h b/Include/objimpl.h index a9412ce..a168c8b 100644 --- a/Include/objimpl.h +++ b/Include/objimpl.h @@ -146,9 +146,9 @@ PyAPI_FUNC(void) _PyObject_DebugMallocStats(void); /* Functions */ PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *); PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *, - PyTypeObject *, int); + PyTypeObject *, Py_ssize_t); PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *); -PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, int); +PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t); #define PyObject_New(type, typeobj) \ ( (type *) _PyObject_New(typeobj) ) @@ -291,7 +291,7 @@ extern PyGC_Head *_PyGC_generation0; PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t); PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *); -PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, int); +PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t); PyAPI_FUNC(void) PyObject_GC_Track(void *); PyAPI_FUNC(void) PyObject_GC_UnTrack(void *); PyAPI_FUNC(void) PyObject_GC_Del(void *); diff --git a/Include/pyerrors.h b/Include/pyerrors.h index 94a5290..330a35c 100644 --- a/Include/pyerrors.h +++ b/Include/pyerrors.h @@ -156,15 +156,15 @@ PyAPI_FUNC(PyObject *) PyErr_ProgramText(const char *, int); /* create a UnicodeDecodeError object */ PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create( - const char *, const char *, int, int, int, const char *); + const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *); /* create a UnicodeEncodeError object */ PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create( - const char *, const Py_UNICODE *, int, int, int, const char *); + const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *); /* create a UnicodeTranslateError object */ PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create( - const Py_UNICODE *, int, int, int, const char *); + const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *); /* get the encoding attribute */ PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *); @@ -177,27 +177,27 @@ PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_GetObject(PyObject *); /* get the value of the start attribute (the int * may not be NULL) return 0 on success, -1 on failure */ -PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, int *); -PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, int *); -PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, int *); +PyAPI_FUNC(int) PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *); /* assign a new value to the start attribute return 0 on success, -1 on failure */ -PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, int); -PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, int); -PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, int); +PyAPI_FUNC(int) PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t); /* get the value of the end attribute (the int *may not be NULL) return 0 on success, -1 on failure */ -PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, int *); -PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, int *); -PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, int *); +PyAPI_FUNC(int) PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *); /* assign a new value to the end attribute return 0 on success, -1 on failure */ -PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, int); -PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, int); -PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, int); +PyAPI_FUNC(int) PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t); /* get the value of the reason attribute */ PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetReason(PyObject *); diff --git a/Include/pyport.h b/Include/pyport.h index 2440c55..f3ba488 100644 --- a/Include/pyport.h +++ b/Include/pyport.h @@ -85,6 +85,15 @@ typedef PY_LONG_LONG Py_intptr_t; # error "Python needs a typedef for Py_uintptr_t in pyport.h." #endif /* HAVE_UINTPTR_T */ +#ifdef HAVE_SSIZE_T +typedef ssize_t Py_ssize_t; +#elif SIZEOF_VOID_P == SIZEOF_SIZE_T +typedef Py_uintptr_t Py_ssize_t; +#else +# error "Python needs a typedef for Py_ssize_t in pyport.h." +#endif +#define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1)) + #include #include /* Moved here from the math section, before extern "C" */ diff --git a/Include/pystrtod.h b/Include/pystrtod.h index 5314f26..c6921da 100644 --- a/Include/pystrtod.h +++ b/Include/pystrtod.h @@ -8,7 +8,7 @@ extern "C" { PyAPI_FUNC(double) PyOS_ascii_strtod(const char *str, char **ptr); PyAPI_FUNC(double) PyOS_ascii_atof(const char *str); -PyAPI_FUNC(char *) PyOS_ascii_formatd(char *buffer, int buf_len, const char *format, double d); +PyAPI_FUNC(char *) PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d); #ifdef __cplusplus diff --git a/Include/sliceobject.h b/Include/sliceobject.h index fc80254..17f36dc 100644 --- a/Include/sliceobject.h +++ b/Include/sliceobject.h @@ -30,11 +30,11 @@ PyAPI_DATA(PyTypeObject) PySlice_Type; PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop, PyObject* step); -PyAPI_FUNC(int) PySlice_GetIndices(PySliceObject *r, int length, - int *start, int *stop, int *step); -PyAPI_FUNC(int) PySlice_GetIndicesEx(PySliceObject *r, int length, - int *start, int *stop, - int *step, int *slicelength); +PyAPI_FUNC(int) PySlice_GetIndices(PySliceObject *r, Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step); +PyAPI_FUNC(int) PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, + Py_ssize_t *step, Py_ssize_t *slicelength); #ifdef __cplusplus } diff --git a/Include/stringobject.h b/Include/stringobject.h index 0c7e5b6..5f8a6f0 100644 --- a/Include/stringobject.h +++ b/Include/stringobject.h @@ -58,24 +58,24 @@ PyAPI_DATA(PyTypeObject) PyString_Type; #define PyString_Check(op) PyObject_TypeCheck(op, &PyString_Type) #define PyString_CheckExact(op) ((op)->ob_type == &PyString_Type) -PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, int); +PyAPI_FUNC(PyObject *) PyString_FromStringAndSize(const char *, Py_ssize_t); PyAPI_FUNC(PyObject *) PyString_FromString(const char *); PyAPI_FUNC(PyObject *) PyString_FromFormatV(const char*, va_list) Py_GCC_ATTRIBUTE((format(printf, 1, 0))); PyAPI_FUNC(PyObject *) PyString_FromFormat(const char*, ...) Py_GCC_ATTRIBUTE((format(printf, 1, 2))); -PyAPI_FUNC(int) PyString_Size(PyObject *); +PyAPI_FUNC(Py_ssize_t) PyString_Size(PyObject *); PyAPI_FUNC(char *) PyString_AsString(PyObject *); PyAPI_FUNC(PyObject *) PyString_Repr(PyObject *, int); PyAPI_FUNC(void) PyString_Concat(PyObject **, PyObject *); PyAPI_FUNC(void) PyString_ConcatAndDel(PyObject **, PyObject *); -PyAPI_FUNC(int) _PyString_Resize(PyObject **, int); +PyAPI_FUNC(int) _PyString_Resize(PyObject **, Py_ssize_t); PyAPI_FUNC(int) _PyString_Eq(PyObject *, PyObject*); PyAPI_FUNC(PyObject *) PyString_Format(PyObject *, PyObject *); PyAPI_FUNC(PyObject *) _PyString_FormatLong(PyObject*, int, int, int, char**, int*); -PyAPI_FUNC(PyObject *) PyString_DecodeEscape(const char *, int, - const char *, int, +PyAPI_FUNC(PyObject *) PyString_DecodeEscape(const char *, Py_ssize_t, + const char *, Py_ssize_t, const char *); PyAPI_FUNC(void) PyString_InternInPlace(PyObject **); @@ -101,7 +101,7 @@ PyAPI_FUNC(PyObject *) _PyString_Join(PyObject *sep, PyObject *x); PyAPI_FUNC(PyObject*) PyString_Decode( const char *s, /* encoded string */ - int size, /* size of buffer */ + Py_ssize_t size, /* size of buffer */ const char *encoding, /* encoding */ const char *errors /* error handling */ ); @@ -111,7 +111,7 @@ PyAPI_FUNC(PyObject*) PyString_Decode( PyAPI_FUNC(PyObject*) PyString_Encode( const char *s, /* string char buffer */ - int size, /* number of chars to encode */ + Py_ssize_t size, /* number of chars to encode */ const char *encoding, /* encoding */ const char *errors /* error handling */ ); @@ -171,7 +171,7 @@ PyAPI_FUNC(PyObject*) PyString_AsDecodedString( PyAPI_FUNC(int) PyString_AsStringAndSize( register PyObject *obj, /* string or Unicode object */ register char **s, /* pointer to buffer variable */ - register int *len /* pointer to length variable or NULL + register Py_ssize_t *len /* pointer to length variable or NULL (only possible for 0-terminated strings) */ ); diff --git a/Include/tupleobject.h b/Include/tupleobject.h index 6b60d62..8c37cab 100644 --- a/Include/tupleobject.h +++ b/Include/tupleobject.h @@ -36,13 +36,13 @@ PyAPI_DATA(PyTypeObject) PyTuple_Type; #define PyTuple_Check(op) PyObject_TypeCheck(op, &PyTuple_Type) #define PyTuple_CheckExact(op) ((op)->ob_type == &PyTuple_Type) -PyAPI_FUNC(PyObject *) PyTuple_New(int size); -PyAPI_FUNC(int) PyTuple_Size(PyObject *); -PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, int); -PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, int, PyObject *); -PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, int, int); -PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, int); -PyAPI_FUNC(PyObject *) PyTuple_Pack(int, ...); +PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size); +PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *); +PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t); +PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *); +PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); +PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); +PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); /* Macro, trading safety for speed */ #define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i]) diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h index 78e80c7..9012257 100644 --- a/Include/unicodeobject.h +++ b/Include/unicodeobject.h @@ -372,7 +372,7 @@ extern "C" { typedef struct { PyObject_HEAD - int length; /* Length of raw Unicode data in buffer */ + Py_ssize_t length; /* Length of raw Unicode data in buffer */ Py_UNICODE *str; /* Raw Unicode buffer */ long hash; /* Hash value; -1 if not set */ PyObject *defenc; /* (Default) Encoded version as Python @@ -420,7 +420,7 @@ PyAPI_DATA(PyTypeObject) PyUnicode_Type; PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode( const Py_UNICODE *u, /* Unicode buffer */ - int size /* size of buffer */ + Py_ssize_t size /* size of buffer */ ); /* Return a read-only pointer to the Unicode object's internal @@ -432,7 +432,7 @@ PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode( /* Get the length of the Unicode object. */ -PyAPI_FUNC(int) PyUnicode_GetSize( +PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize( PyObject *unicode /* Unicode object */ ); @@ -455,7 +455,7 @@ PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void); PyAPI_FUNC(int) PyUnicode_Resize( PyObject **unicode, /* Pointer to the Unicode object */ - int length /* New length */ + Py_ssize_t length /* New length */ ); /* Coerce obj to an Unicode object and return a reference with @@ -509,7 +509,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromObject( PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar( register const wchar_t *w, /* wchar_t buffer */ - int size /* size of buffer */ + Py_ssize_t size /* size of buffer */ ); /* Copies the Unicode Object contents into the wchar_t buffer w. At @@ -524,10 +524,10 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar( possibly trailing 0-termination character) or -1 in case of an error. */ -PyAPI_FUNC(int) PyUnicode_AsWideChar( +PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar( PyUnicodeObject *unicode, /* Unicode object */ register wchar_t *w, /* wchar_t buffer */ - int size /* size of buffer */ + Py_ssize_t size /* size of buffer */ ); #endif @@ -609,7 +609,7 @@ PyAPI_FUNC(int) PyUnicode_SetDefaultEncoding( PyAPI_FUNC(PyObject*) PyUnicode_Decode( const char *s, /* encoded string */ - int size, /* size of buffer */ + Py_ssize_t size, /* size of buffer */ const char *encoding, /* encoding */ const char *errors /* error handling */ ); @@ -619,7 +619,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_Decode( PyAPI_FUNC(PyObject*) PyUnicode_Encode( const Py_UNICODE *s, /* Unicode char buffer */ - int size, /* number of Py_UNICODE chars to encode */ + Py_ssize_t size, /* number of Py_UNICODE chars to encode */ const char *encoding, /* encoding */ const char *errors /* error handling */ ); @@ -646,13 +646,13 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString( PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7( const char *string, /* UTF-7 encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ int encodeSetO, /* force the encoder to encode characters in Set O, as described in RFC2152 */ int encodeWhiteSpace, /* force the encoder to encode space, tab, @@ -664,15 +664,15 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7( PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8( const char *string, /* UTF-8 encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful( const char *string, /* UTF-8 encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors, /* error handling */ - int *consumed /* bytes consumed */ + Py_ssize_t *consumed /* bytes consumed */ ); PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String( @@ -681,7 +681,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String( PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ const char *errors /* error handling */ ); @@ -712,7 +712,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8( PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16( const char *string, /* UTF-16 encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors, /* error handling */ int *byteorder /* pointer to byteorder to use 0=native;-1=LE,1=BE; updated on @@ -721,12 +721,12 @@ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16( PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful( const char *string, /* UTF-16 encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors, /* error handling */ int *byteorder, /* pointer to byteorder to use 0=native;-1=LE,1=BE; updated on exit */ - int *consumed /* bytes consumed */ + Py_ssize_t *consumed /* bytes consumed */ ); /* Returns a Python string using the UTF-16 encoding in native byte @@ -758,7 +758,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String( PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ const char *errors, /* error handling */ int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ ); @@ -767,7 +767,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16( PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape( const char *string, /* Unicode-Escape encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); @@ -777,14 +777,14 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString( PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape( const Py_UNICODE *data, /* Unicode char buffer */ - int length /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length /* Number of Py_UNICODE chars to encode */ ); /* --- Raw-Unicode-Escape Codecs ------------------------------------------ */ PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape( const char *string, /* Raw-Unicode-Escape encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); @@ -794,7 +794,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString( PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape( const Py_UNICODE *data, /* Unicode char buffer */ - int length /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length /* Number of Py_UNICODE chars to encode */ ); /* --- Unicode Internal Codec --------------------------------------------- @@ -803,7 +803,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape( PyObject *_PyUnicode_DecodeUnicodeInternal( const char *string, - int length, + Py_ssize_t length, const char *errors ); @@ -815,7 +815,7 @@ PyObject *_PyUnicode_DecodeUnicodeInternal( PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1( const char *string, /* Latin-1 encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); @@ -825,7 +825,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String( PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ const char *errors /* error handling */ ); @@ -837,7 +837,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1( PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII( const char *string, /* ASCII encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); @@ -847,7 +847,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString( PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ const char *errors /* error handling */ ); @@ -875,7 +875,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII( PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap( const char *string, /* Encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ PyObject *mapping, /* character mapping (char ordinal -> unicode ordinal) */ const char *errors /* error handling */ @@ -889,7 +889,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString( PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ PyObject *mapping, /* character mapping (unicode ordinal -> char ordinal) */ const char *errors /* error handling */ @@ -910,7 +910,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap( PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ PyObject *table, /* Translate table */ const char *errors /* error handling */ ); @@ -921,7 +921,7 @@ PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap( PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS( const char *string, /* MBCS encoded string */ - int length, /* size of string */ + Py_ssize_t length, /* size of string */ const char *errors /* error handling */ ); @@ -931,7 +931,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString( PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS( const Py_UNICODE *data, /* Unicode char buffer */ - int length, /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ const char *errors /* error handling */ ); @@ -963,7 +963,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS( PyAPI_FUNC(int) PyUnicode_EncodeDecimal( Py_UNICODE *s, /* Unicode buffer */ - int length, /* Number of Py_UNICODE chars to encode */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ char *output, /* Output buffer; must have size >= length */ const char *errors /* error handling */ ); @@ -995,7 +995,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_Concat( PyAPI_FUNC(PyObject*) PyUnicode_Split( PyObject *s, /* String to split */ PyObject *sep, /* String separator */ - int maxsplit /* Maxsplit count */ + Py_ssize_t maxsplit /* Maxsplit count */ ); /* Dito, but split at line breaks. @@ -1024,7 +1024,7 @@ PyAPI_FUNC(PyObject*) PyUnicode_Splitlines( PyAPI_FUNC(PyObject*) PyUnicode_RSplit( PyObject *s, /* String to split */ PyObject *sep, /* String separator */ - int maxsplit /* Maxsplit count */ + Py_ssize_t maxsplit /* Maxsplit count */ ); /* Translate a string by applying a character mapping table to it and @@ -1056,11 +1056,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_Join( /* Return 1 if substr matches str[start:end] at the given tail end, 0 otherwise. */ -PyAPI_FUNC(int) PyUnicode_Tailmatch( +PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch( PyObject *str, /* String */ PyObject *substr, /* Prefix or Suffix string */ - int start, /* Start index */ - int end, /* Stop index */ + Py_ssize_t start, /* Start index */ + Py_ssize_t end, /* Stop index */ int direction /* Tail end: -1 prefix, +1 suffix */ ); @@ -1068,21 +1068,21 @@ PyAPI_FUNC(int) PyUnicode_Tailmatch( given search direction or -1 if not found. -2 is returned in case an error occurred and an exception is set. */ -PyAPI_FUNC(int) PyUnicode_Find( +PyAPI_FUNC(Py_ssize_t) PyUnicode_Find( PyObject *str, /* String */ PyObject *substr, /* Substring to find */ - int start, /* Start index */ - int end, /* Stop index */ + Py_ssize_t start, /* Start index */ + Py_ssize_t end, /* Stop index */ int direction /* Find direction: +1 forward, -1 backward */ ); /* Count the number of occurrences of substr in str[start:end]. */ -PyAPI_FUNC(int) PyUnicode_Count( +PyAPI_FUNC(Py_ssize_t) PyUnicode_Count( PyObject *str, /* String */ PyObject *substr, /* Substring to count */ - int start, /* Start index */ - int end /* Stop index */ + Py_ssize_t start, /* Start index */ + Py_ssize_t end /* Stop index */ ); /* Replace at most maxcount occurrences of substr in str with replstr @@ -1092,7 +1092,7 @@ PyAPI_FUNC(PyObject *) PyUnicode_Replace( PyObject *str, /* String */ PyObject *substr, /* Substring to find */ PyObject *replstr, /* Substring to replace */ - int maxcount /* Max. number of replacements to apply; + Py_ssize_t maxcount /* Max. number of replacements to apply; -1 = all */ ); diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py index 60f5fdb..aab98c2 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -627,7 +627,9 @@ class MixinStrUnicodeUserStringTest: self.checkequal('abcabcabc', 'abc', '__mul__', 3) self.checkraises(TypeError, 'abc', '__mul__') self.checkraises(TypeError, 'abc', '__mul__', '') - self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000) + # XXX: on a 64-bit system, this doesn't raise an overflow error, + # but either raises a MemoryError, or succeeds (if you have 54TiB) + #self.checkraises(OverflowError, 10000*'abc', '__mul__', 2000000000) def test_join(self): # join now works with any sequence type diff --git a/Misc/NEWS b/Misc/NEWS index a7e54ad..f2a5091 100644 --- a/Misc/NEWS +++ b/Misc/NEWS @@ -12,6 +12,8 @@ What's New in Python 2.5 alpha 1? Core and builtins ----------------- +- PEP 353: Using ssize_t as the index type. + - Patch #1400181, fix unicode string formatting to not use the locale. This is how string objects work. u'%f' could use , instead of . for the decimal point. Now both strings and unicode always use periods. diff --git a/Modules/_bsddb.c b/Modules/_bsddb.c index fca203d..9bcb334 100644 --- a/Modules/_bsddb.c +++ b/Modules/_bsddb.c @@ -1100,7 +1100,7 @@ _db_associateCallback(DB* db, const DBT* priKey, const DBT* priData, } else if (PyString_Check(result)) { char* data; - int size; + Py_ssize_t size; CLEAR_DBT(*secKey); #if PYTHON_API_VERSION <= 1007 @@ -2614,7 +2614,7 @@ DB_set_encrypt(DBObject* self, PyObject* args, PyObject* kwargs) /*-------------------------------------------------------------- */ /* Mapping and Dictionary-like access routines */ -int DB_length(DBObject* self) +Py_ssize_t DB_length(DBObject* self) { int err; long size = 0; @@ -4679,7 +4679,7 @@ static PyMethodDef DB_methods[] = { static PyMappingMethods DB_mapping = { - (inquiry)DB_length, /*mp_length*/ + (lenfunc)DB_length, /*mp_length*/ (binaryfunc)DB_subscript, /*mp_subscript*/ (objobjargproc)DB_ass_sub, /*mp_ass_subscript*/ }; diff --git a/Modules/_codecsmodule.c b/Modules/_codecsmodule.c index 8b225c3..39b443b 100644 --- a/Modules/_codecsmodule.c +++ b/Modules/_codecsmodule.c @@ -35,6 +35,7 @@ Copyright (c) Corporation for National Research Initiatives. ------------------------------------------------------------------------ */ +#define PY_SSIZE_T_CLEAN #include "Python.h" /* --- Registry ----------------------------------------------------------- */ @@ -196,7 +197,7 @@ escape_decode(PyObject *self, { const char *errors = NULL; const char *data; - int size; + Py_ssize_t size; if (!PyArg_ParseTuple(args, "s#|z:escape_decode", &data, &size, &errors)) @@ -241,7 +242,7 @@ unicode_internal_decode(PyObject *self, PyObject *obj; const char *errors = NULL; const char *data; - int size; + Py_ssize_t size; if (!PyArg_ParseTuple(args, "O|z:unicode_internal_decode", &obj, &errors)) @@ -265,7 +266,7 @@ utf_7_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:utf_7_decode", @@ -281,15 +282,19 @@ utf_8_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; int final = 0; - int consumed; + Py_ssize_t consumed; PyObject *decoded = NULL; if (!PyArg_ParseTuple(args, "t#|zi:utf_8_decode", &data, &size, &errors, &final)) return NULL; + if (size < 0) { + PyErr_SetString(PyExc_ValueError, "negative argument"); + return 0; + } consumed = size; decoded = PyUnicode_DecodeUTF8Stateful(data, size, errors, @@ -304,16 +309,21 @@ utf_16_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; int byteorder = 0; int final = 0; - int consumed; + Py_ssize_t consumed; PyObject *decoded; if (!PyArg_ParseTuple(args, "t#|zi:utf_16_decode", &data, &size, &errors, &final)) return NULL; + /* XXX Why is consumed initialized to size? mvl */ + if (size < 0) { + PyErr_SetString(PyExc_ValueError, "negative argument"); + return 0; + } consumed = size; decoded = PyUnicode_DecodeUTF16Stateful(data, size, errors, &byteorder, final ? NULL : &consumed); @@ -327,16 +337,22 @@ utf_16_le_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; int byteorder = -1; int final = 0; - int consumed; + Py_ssize_t consumed; PyObject *decoded = NULL; if (!PyArg_ParseTuple(args, "t#|zi:utf_16_le_decode", &data, &size, &errors, &final)) return NULL; + + /* XXX Why is consumed initialized to size? mvl */ + if (size < 0) { + PyErr_SetString(PyExc_ValueError, "negative argument"); + return 0; + } consumed = size; decoded = PyUnicode_DecodeUTF16Stateful(data, size, errors, &byteorder, final ? NULL : &consumed); @@ -351,16 +367,21 @@ utf_16_be_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; int byteorder = 1; int final = 0; - int consumed; + Py_ssize_t consumed; PyObject *decoded = NULL; if (!PyArg_ParseTuple(args, "t#|zi:utf_16_be_decode", &data, &size, &errors, &final)) return NULL; + /* XXX Why is consumed initialized to size? mvl */ + if (size < 0) { + PyErr_SetString(PyExc_ValueError, "negative argument"); + return 0; + } consumed = size; decoded = PyUnicode_DecodeUTF16Stateful(data, size, errors, &byteorder, final ? NULL : &consumed); @@ -382,17 +403,21 @@ utf_16_ex_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; int byteorder = 0; PyObject *unicode, *tuple; int final = 0; - int consumed; + Py_ssize_t consumed; if (!PyArg_ParseTuple(args, "t#|zii:utf_16_ex_decode", &data, &size, &errors, &byteorder, &final)) return NULL; - + /* XXX Why is consumed initialized to size? mvl */ + if (size < 0) { + PyErr_SetString(PyExc_ValueError, "negative argument"); + return 0; + } consumed = size; unicode = PyUnicode_DecodeUTF16Stateful(data, size, errors, &byteorder, final ? NULL : &consumed); @@ -408,7 +433,7 @@ unicode_escape_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:unicode_escape_decode", @@ -424,7 +449,7 @@ raw_unicode_escape_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:raw_unicode_escape_decode", @@ -440,7 +465,7 @@ latin_1_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:latin_1_decode", @@ -456,7 +481,7 @@ ascii_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:ascii_decode", @@ -472,7 +497,7 @@ charmap_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; PyObject *mapping = NULL; @@ -493,7 +518,7 @@ mbcs_decode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:mbcs_decode", @@ -513,7 +538,7 @@ readbuffer_encode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "s#|z:readbuffer_encode", @@ -529,7 +554,7 @@ charbuffer_encode(PyObject *self, PyObject *args) { const char *data; - int size; + Py_ssize_t size; const char *errors = NULL; if (!PyArg_ParseTuple(args, "t#|z:charbuffer_encode", @@ -547,7 +572,7 @@ unicode_internal_encode(PyObject *self, PyObject *obj; const char *errors = NULL; const char *data; - int size; + Py_ssize_t size; if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode", &obj, &errors)) diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c index a43fe2e..ab3ef23 100644 --- a/Modules/_elementtree.c +++ b/Modules/_elementtree.c @@ -92,6 +92,9 @@ do { memory -= size; printf("%8d - %s\n", memory, comment); } while (0) #endif /* compatibility macros */ +#if (PY_VERSION_HEX < 0x02050000) +typedef int Py_ssize_t; +#endif #if (PY_VERSION_HEX < 0x02040000) #define PyDict_CheckExact PyDict_Check #if (PY_VERSION_HEX < 0x02020000) @@ -919,8 +922,9 @@ element_getiterator(ElementObject* self, PyObject* args) } static PyObject* -element_getitem(ElementObject* self, int index) +element_getitem(PyObject* _self, Py_ssize_t index) { + ElementObject* self = (ElementObject*)_self; if (!self->extra || index < 0 || index >= self->extra->length) { PyErr_SetString( PyExc_IndexError, @@ -934,9 +938,10 @@ element_getitem(ElementObject* self, int index) } static PyObject* -element_getslice(ElementObject* self, int start, int end) +element_getslice(PyObject* _self, Py_ssize_t start, Py_ssize_t end) { - int i; + ElementObject* self = (ElementObject*)_self; + Py_ssize_t i; PyObject* list; if (!self->extra) @@ -1022,7 +1027,7 @@ element_keys(ElementObject* self, PyObject* args) return PyDict_Keys(self->extra->attrib); } -static int +static Py_ssize_t element_length(ElementObject* self) { if (!self->extra) @@ -1161,8 +1166,9 @@ element_set(ElementObject* self, PyObject* args) } static int -element_setslice(ElementObject* self, int start, int end, PyObject* item) +element_setslice(PyObject* _self, Py_ssize_t start, Py_ssize_t end, PyObject* item) { + ElementObject* self = (ElementObject*)_self; int i, new, old; PyObject* recycle = NULL; @@ -1231,8 +1237,9 @@ element_setslice(ElementObject* self, int start, int end, PyObject* item) } static int -element_setitem(ElementObject* self, int index, PyObject* item) +element_setitem(PyObject* _self, Py_ssize_t index, PyObject* item) { + ElementObject* self = (ElementObject*)_self; int i; PyObject* old; @@ -1371,13 +1378,13 @@ element_setattr(ElementObject* self, const char* name, PyObject* value) } static PySequenceMethods element_as_sequence = { - (inquiry) element_length, + (lenfunc) element_length, 0, /* sq_concat */ 0, /* sq_repeat */ - (intargfunc) element_getitem, - (intintargfunc) element_getslice, - (intobjargproc) element_setitem, - (intintobjargproc) element_setslice, + element_getitem, + element_getslice, + element_setitem, + element_setslice, }; statichere PyTypeObject Element_Type = { diff --git a/Modules/_hotshot.c b/Modules/_hotshot.c index 758c4ee..162a319 100644 --- a/Modules/_hotshot.c +++ b/Modules/_hotshot.c @@ -71,7 +71,7 @@ typedef struct { PyObject_HEAD PyObject *filemap; PyObject *logfilename; - int index; + Py_ssize_t index; unsigned char buffer[BUFFERSIZE]; FILE *logfp; int lineevents; @@ -526,7 +526,7 @@ logreader_dealloc(LogReaderObject *self) } static PyObject * -logreader_sq_item(LogReaderObject *self, int index) +logreader_sq_item(LogReaderObject *self, Py_ssize_t index) { PyObject *result = logreader_tp_iternext(self); if (result == NULL && !PyErr_Occurred()) { @@ -610,13 +610,14 @@ pack_modified_packed_int(ProfilerObject *self, int value, } static int -pack_string(ProfilerObject *self, const char *s, int len) +pack_string(ProfilerObject *self, const char *s, Py_ssize_t len) { if (len + PISIZE + self->index >= BUFFERSIZE) { if (flush_data(self) < 0) return -1; } - if (pack_packed_int(self, len) < 0) + assert(len < INT_MAX); + if (pack_packed_int(self, (int)len) < 0) return -1; memcpy(self->buffer + self->index, s, len); self->index += len; @@ -626,8 +627,8 @@ pack_string(ProfilerObject *self, const char *s, int len) static int pack_add_info(ProfilerObject *self, const char *s1, const char *s2) { - int len1 = strlen(s1); - int len2 = strlen(s2); + Py_ssize_t len1 = strlen(s1); + Py_ssize_t len2 = strlen(s2); if (len1 + len2 + PISIZE*2 + 1 + self->index >= BUFFERSIZE) { if (flush_data(self) < 0) @@ -643,7 +644,7 @@ pack_add_info(ProfilerObject *self, const char *s1, const char *s2) static int pack_define_file(ProfilerObject *self, int fileno, const char *filename) { - int len = strlen(filename); + Py_ssize_t len = strlen(filename); if (len + PISIZE*2 + 1 + self->index >= BUFFERSIZE) { if (flush_data(self) < 0) @@ -660,7 +661,7 @@ static int pack_define_func(ProfilerObject *self, int fileno, int lineno, const char *funcname) { - int len = strlen(funcname); + Py_ssize_t len = strlen(funcname); if (len + PISIZE*3 + 1 + self->index >= BUFFERSIZE) { if (flush_data(self) < 0) @@ -1269,7 +1270,7 @@ static PySequenceMethods logreader_as_sequence = { 0, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ - (intargfunc)logreader_sq_item, /* sq_item */ + (ssizeargfunc)logreader_sq_item, /* sq_item */ 0, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ diff --git a/Modules/_localemodule.c b/Modules/_localemodule.c index 2d84d80..e3d1e7f 100644 --- a/Modules/_localemodule.c +++ b/Modules/_localemodule.c @@ -382,11 +382,11 @@ PyLocale_getdefaultlocale(PyObject* self) if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, locale, sizeof(locale))) { - int i = strlen(locale); + Py_ssize_t i = strlen(locale); locale[i++] = '_'; if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, - locale+i, sizeof(locale)-i)) + locale+i, (int)(sizeof(locale)-i))) return Py_BuildValue("ss", locale, encoding); } diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c index c008b87..913c49a 100644 --- a/Modules/_testcapimodule.c +++ b/Modules/_testcapimodule.c @@ -115,7 +115,8 @@ test_list_api(PyObject *self) static int test_dict_inner(int count) { - int pos = 0, iterations = 0, i; + Py_ssize_t pos = 0, iterations = 0; + int i; PyObject *dict = PyDict_New(); PyObject *v, *k; diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c index 4c7cdf2..704b745 100644 --- a/Modules/arraymodule.c +++ b/Modules/arraymodule.c @@ -3,6 +3,7 @@ /* An array is a uniform list -- all items have the same type. The item type is restricted to simple C types like int or float */ +#define PY_SSIZE_T_CLEAN #include "Python.h" #include "structmember.h" @@ -23,15 +24,15 @@ struct arrayobject; /* Forward */ struct arraydescr { int typecode; int itemsize; - PyObject * (*getitem)(struct arrayobject *, int); - int (*setitem)(struct arrayobject *, int, PyObject *); + PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); + int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *); }; typedef struct arrayobject { PyObject_HEAD - int ob_size; + Py_ssize_t ob_size; char *ob_item; - int allocated; + Py_ssize_t allocated; struct arraydescr *ob_descr; PyObject *weakreflist; /* List of weak references */ } arrayobject; @@ -42,7 +43,7 @@ static PyTypeObject Arraytype; #define array_CheckExact(op) ((op)->ob_type == &Arraytype) static int -array_resize(arrayobject *self, int newsize) +array_resize(arrayobject *self, Py_ssize_t newsize) { char *items; size_t _new_size; @@ -102,13 +103,13 @@ in bounds; that's the responsibility of the caller. ****************************************************************************/ static PyObject * -c_getitem(arrayobject *ap, int i) +c_getitem(arrayobject *ap, Py_ssize_t i) { return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1); } static int -c_setitem(arrayobject *ap, int i, PyObject *v) +c_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { char x; if (!PyArg_Parse(v, "c;array item must be char", &x)) @@ -119,7 +120,7 @@ c_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -b_getitem(arrayobject *ap, int i) +b_getitem(arrayobject *ap, Py_ssize_t i) { long x = ((char *)ap->ob_item)[i]; if (x >= 128) @@ -128,7 +129,7 @@ b_getitem(arrayobject *ap, int i) } static int -b_setitem(arrayobject *ap, int i, PyObject *v) +b_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { short x; /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore @@ -152,14 +153,14 @@ b_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -BB_getitem(arrayobject *ap, int i) +BB_getitem(arrayobject *ap, Py_ssize_t i) { long x = ((unsigned char *)ap->ob_item)[i]; return PyInt_FromLong(x); } static int -BB_setitem(arrayobject *ap, int i, PyObject *v) +BB_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { unsigned char x; /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */ @@ -172,16 +173,16 @@ BB_setitem(arrayobject *ap, int i, PyObject *v) #ifdef Py_USING_UNICODE static PyObject * -u_getitem(arrayobject *ap, int i) +u_getitem(arrayobject *ap, Py_ssize_t i) { return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1); } static int -u_setitem(arrayobject *ap, int i, PyObject *v) +u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { Py_UNICODE *p; - int len; + Py_ssize_t len; if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len)) return -1; @@ -196,13 +197,13 @@ u_setitem(arrayobject *ap, int i, PyObject *v) #endif static PyObject * -h_getitem(arrayobject *ap, int i) +h_getitem(arrayobject *ap, Py_ssize_t i) { return PyInt_FromLong((long) ((short *)ap->ob_item)[i]); } static int -h_setitem(arrayobject *ap, int i, PyObject *v) +h_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { short x; /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */ @@ -214,13 +215,13 @@ h_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -HH_getitem(arrayobject *ap, int i) +HH_getitem(arrayobject *ap, Py_ssize_t i) { return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]); } static int -HH_setitem(arrayobject *ap, int i, PyObject *v) +HH_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { int x; /* PyArg_Parse's 'h' formatter is for a signed short, therefore @@ -243,13 +244,13 @@ HH_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -i_getitem(arrayobject *ap, int i) +i_getitem(arrayobject *ap, Py_ssize_t i) { return PyInt_FromLong((long) ((int *)ap->ob_item)[i]); } static int -i_setitem(arrayobject *ap, int i, PyObject *v) +i_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { int x; /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */ @@ -261,14 +262,14 @@ i_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -II_getitem(arrayobject *ap, int i) +II_getitem(arrayobject *ap, Py_ssize_t i) { return PyLong_FromUnsignedLong( (unsigned long) ((unsigned int *)ap->ob_item)[i]); } static int -II_setitem(arrayobject *ap, int i, PyObject *v) +II_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { unsigned long x; if (PyLong_Check(v)) { @@ -300,13 +301,13 @@ II_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -l_getitem(arrayobject *ap, int i) +l_getitem(arrayobject *ap, Py_ssize_t i) { return PyInt_FromLong(((long *)ap->ob_item)[i]); } static int -l_setitem(arrayobject *ap, int i, PyObject *v) +l_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { long x; if (!PyArg_Parse(v, "l;array item must be integer", &x)) @@ -317,13 +318,13 @@ l_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -LL_getitem(arrayobject *ap, int i) +LL_getitem(arrayobject *ap, Py_ssize_t i) { return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]); } static int -LL_setitem(arrayobject *ap, int i, PyObject *v) +LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { unsigned long x; if (PyLong_Check(v)) { @@ -355,13 +356,13 @@ LL_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -f_getitem(arrayobject *ap, int i) +f_getitem(arrayobject *ap, Py_ssize_t i) { return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]); } static int -f_setitem(arrayobject *ap, int i, PyObject *v) +f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { float x; if (!PyArg_Parse(v, "f;array item must be float", &x)) @@ -372,13 +373,13 @@ f_setitem(arrayobject *ap, int i, PyObject *v) } static PyObject * -d_getitem(arrayobject *ap, int i) +d_getitem(arrayobject *ap, Py_ssize_t i) { return PyFloat_FromDouble(((double *)ap->ob_item)[i]); } static int -d_setitem(arrayobject *ap, int i, PyObject *v) +d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) { double x; if (!PyArg_Parse(v, "d;array item must be float", &x)) @@ -412,7 +413,7 @@ Implementations of array object methods. ****************************************************************************/ static PyObject * -newarrayobject(PyTypeObject *type, int size, struct arraydescr *descr) +newarrayobject(PyTypeObject *type, Py_ssize_t size, struct arraydescr *descr) { arrayobject *op; size_t nbytes; @@ -449,7 +450,7 @@ newarrayobject(PyTypeObject *type, int size, struct arraydescr *descr) } static PyObject * -getarrayitem(PyObject *op, int i) +getarrayitem(PyObject *op, Py_ssize_t i) { register arrayobject *ap; assert(array_Check(op)); @@ -459,10 +460,10 @@ getarrayitem(PyObject *op, int i) } static int -ins1(arrayobject *self, int where, PyObject *v) +ins1(arrayobject *self, Py_ssize_t where, PyObject *v) { char *items; - int n = self->ob_size; + Py_ssize_t n = self->ob_size; if (v == NULL) { PyErr_BadInternalCall(); return -1; @@ -506,7 +507,7 @@ array_richcompare(PyObject *v, PyObject *w, int op) arrayobject *va, *wa; PyObject *vi = NULL; PyObject *wi = NULL; - int i, k; + Py_ssize_t i, k; PyObject *res; if (!array_Check(v) || !array_Check(w)) { @@ -548,8 +549,8 @@ array_richcompare(PyObject *v, PyObject *w, int op) if (k) { /* No more items to compare -- compare sizes */ - int vs = va->ob_size; - int ws = wa->ob_size; + Py_ssize_t vs = va->ob_size; + Py_ssize_t ws = wa->ob_size; int cmp; switch (op) { case Py_LT: cmp = vs < ws; break; @@ -586,14 +587,14 @@ array_richcompare(PyObject *v, PyObject *w, int op) return res; } -static int +static Py_ssize_t array_length(arrayobject *a) { return a->ob_size; } static PyObject * -array_item(arrayobject *a, int i) +array_item(arrayobject *a, Py_ssize_t i) { if (i < 0 || i >= a->ob_size) { PyErr_SetString(PyExc_IndexError, "array index out of range"); @@ -603,7 +604,7 @@ array_item(arrayobject *a, int i) } static PyObject * -array_slice(arrayobject *a, int ilow, int ihigh) +array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh) { arrayobject *np; if (ilow < 0) @@ -638,7 +639,7 @@ PyDoc_STRVAR(copy_doc, static PyObject * array_concat(arrayobject *a, PyObject *bb) { - int size; + Py_ssize_t size; arrayobject *np; if (!array_Check(bb)) { PyErr_Format(PyExc_TypeError, @@ -664,13 +665,13 @@ array_concat(arrayobject *a, PyObject *bb) } static PyObject * -array_repeat(arrayobject *a, int n) +array_repeat(arrayobject *a, Py_ssize_t n) { - int i; - int size; + Py_ssize_t i; + Py_ssize_t size; arrayobject *np; char *p; - int nbytes; + Py_ssize_t nbytes; if (n < 0) n = 0; size = a->ob_size * n; @@ -760,7 +761,7 @@ array_ass_slice(arrayobject *a, int ilow, int ihigh, PyObject *v) } static int -array_ass_item(arrayobject *a, int i, PyObject *v) +array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v) { if (i < 0 || i >= a->ob_size) { PyErr_SetString(PyExc_IndexError, @@ -773,7 +774,7 @@ array_ass_item(arrayobject *a, int i, PyObject *v) } static int -setarrayitem(PyObject *a, int i, PyObject *v) +setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v) { assert(array_Check(a)); return array_ass_item((arrayobject *)a, i, v); @@ -805,7 +806,7 @@ array_iter_extend(arrayobject *self, PyObject *bb) static int array_do_extend(arrayobject *self, PyObject *bb) { - int size; + Py_ssize_t size; if (!array_Check(bb)) return array_iter_extend(self, bb); @@ -847,10 +848,10 @@ array_inplace_concat(arrayobject *self, PyObject *bb) } static PyObject * -array_inplace_repeat(arrayobject *self, int n) +array_inplace_repeat(arrayobject *self, Py_ssize_t n) { char *items, *p; - int size, i; + Py_ssize_t size, i; if (self->ob_size > 0) { if (n < 0) @@ -883,7 +884,7 @@ array_inplace_repeat(arrayobject *self, int n) static PyObject * -ins(arrayobject *self, int where, PyObject *v) +ins(arrayobject *self, Py_ssize_t where, PyObject *v) { if (ins1(self, where, v) != 0) return NULL; @@ -894,8 +895,8 @@ ins(arrayobject *self, int where, PyObject *v) static PyObject * array_count(arrayobject *self, PyObject *v) { - int count = 0; - int i; + Py_ssize_t count = 0; + Py_ssize_t i; for (i = 0; i < self->ob_size; i++) { PyObject *selfi = getarrayitem((PyObject *)self, i); @@ -906,7 +907,10 @@ array_count(arrayobject *self, PyObject *v) else if (cmp < 0) return NULL; } - return PyInt_FromLong((long)count); + if (i < LONG_MAX) + return PyInt_FromLong((long)count); + else + return PyLong_FromLong(count); } PyDoc_STRVAR(count_doc, @@ -917,7 +921,7 @@ Return number of occurences of x in the array."); static PyObject * array_index(arrayobject *self, PyObject *v) { - int i; + Py_ssize_t i; for (i = 0; i < self->ob_size; i++) { PyObject *selfi = getarrayitem((PyObject *)self, i); @@ -941,7 +945,8 @@ Return index of first occurence of x in the array."); static int array_contains(arrayobject *self, PyObject *v) { - int i, cmp; + Py_ssize_t i; + int cmp; for (i = 0, cmp = 0 ; cmp == 0 && i < self->ob_size; i++) { PyObject *selfi = getarrayitem((PyObject *)self, i); @@ -1079,7 +1084,7 @@ static PyObject * array_byteswap(arrayobject *self, PyObject *unused) { char *p; - int i; + Py_ssize_t i; switch (self->ob_descr->itemsize) { case 1: @@ -1158,7 +1163,7 @@ PyDoc_STRVAR(array_doc, "Return state information for pickling."); static PyObject * array_reverse(arrayobject *self, PyObject *unused) { - register int itemsize = self->ob_descr->itemsize; + register Py_ssize_t itemsize = self->ob_descr->itemsize; register char *p, *q; /* little buffer to hold items while swapping */ char tmp[256]; /* 8 is probably enough -- but why skimp */ @@ -1223,7 +1228,7 @@ array_fromfile(arrayobject *self, PyObject *args) nread = fread(item + (self->ob_size - n) * itemsize, itemsize, n, fp); if (nread < (size_t)n) { - self->ob_size -= (n - nread); + self->ob_size -= (n - nread); PyMem_RESIZE(item, char, self->ob_size*itemsize); self->ob_item = item; self->allocated = self->ob_size; @@ -1275,8 +1280,8 @@ write."); static PyObject * array_fromlist(arrayobject *self, PyObject *list) { - int n; - int itemsize = self->ob_descr->itemsize; + Py_ssize_t n; + Py_ssize_t itemsize = self->ob_descr->itemsize; if (!PyList_Check(list)) { PyErr_SetString(PyExc_TypeError, "arg must be list"); @@ -1285,7 +1290,7 @@ array_fromlist(arrayobject *self, PyObject *list) n = PyList_Size(list); if (n > 0) { char *item = self->ob_item; - int i; + Py_ssize_t i; PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize); if (item == NULL) { PyErr_NoMemory(); @@ -1321,7 +1326,7 @@ static PyObject * array_tolist(arrayobject *self, PyObject *unused) { PyObject *list = PyList_New(self->ob_size); - int i; + Py_ssize_t i; if (list == NULL) return NULL; @@ -1346,7 +1351,7 @@ static PyObject * array_fromstring(arrayobject *self, PyObject *args) { char *str; - int n; + Py_ssize_t n; int itemsize = self->ob_descr->itemsize; if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n)) return NULL; @@ -1400,7 +1405,7 @@ static PyObject * array_fromunicode(arrayobject *self, PyObject *args) { Py_UNICODE *ustr; - int n; + Py_ssize_t n; if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n)) return NULL; @@ -1541,7 +1546,7 @@ array_repr(arrayobject *a) { char buf[256], typecode; PyObject *s, *t, *v = NULL; - int len; + Py_ssize_t len; len = a->ob_size; typecode = a->ob_descr->typecode; @@ -1586,7 +1591,7 @@ array_subscr(arrayobject* self, PyObject* item) return array_item(self, i); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength, cur, i; + Py_ssize_t start, stop, step, slicelength, cur, i; PyObject* result; arrayobject* ar; int itemsize = self->ob_descr->itemsize; @@ -1640,7 +1645,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) return array_ass_item(self, i, value); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength; + Py_ssize_t start, stop, step, slicelength; int itemsize = self->ob_descr->itemsize; if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size, @@ -1654,7 +1659,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) if (value == NULL) { /* delete slice */ - int cur, i, extra; + Py_ssize_t cur, i, extra; if (slicelength <= 0) return 0; @@ -1686,7 +1691,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) } else { /* assign slice */ - int cur, i; + Py_ssize_t cur, i; arrayobject* av; if (!array_Check(value)) { @@ -1700,8 +1705,8 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) if (av->ob_size != slicelength) { PyErr_Format(PyExc_ValueError, - "attempt to assign array of size %d to extended slice of size %d", - av->ob_size, slicelength); + "attempt to assign array of size %ld to extended slice of size %ld", + /*XXX*/(long)av->ob_size, /*XXX*/(long)slicelength); return -1; } @@ -1737,13 +1742,13 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) } static PyMappingMethods array_as_mapping = { - (inquiry)array_length, + (lenfunc)array_length, (binaryfunc)array_subscr, (objobjargproc)array_ass_subscr }; -static int -array_buffer_getreadbuf(arrayobject *self, int index, const void **ptr) +static Py_ssize_t +array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr) { if ( index != 0 ) { PyErr_SetString(PyExc_SystemError, @@ -1754,8 +1759,8 @@ array_buffer_getreadbuf(arrayobject *self, int index, const void **ptr) return self->ob_size*self->ob_descr->itemsize; } -static int -array_buffer_getwritebuf(arrayobject *self, int index, const void **ptr) +static Py_ssize_t +array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr) { if ( index != 0 ) { PyErr_SetString(PyExc_SystemError, @@ -1766,8 +1771,8 @@ array_buffer_getwritebuf(arrayobject *self, int index, const void **ptr) return self->ob_size*self->ob_descr->itemsize; } -static int -array_buffer_getsegcount(arrayobject *self, int *lenp) +static Py_ssize_t +array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp) { if ( lenp ) *lenp = self->ob_size*self->ob_descr->itemsize; @@ -1775,22 +1780,22 @@ array_buffer_getsegcount(arrayobject *self, int *lenp) } static PySequenceMethods array_as_sequence = { - (inquiry)array_length, /*sq_length*/ + (lenfunc)array_length, /*sq_length*/ (binaryfunc)array_concat, /*sq_concat*/ - (intargfunc)array_repeat, /*sq_repeat*/ - (intargfunc)array_item, /*sq_item*/ - (intintargfunc)array_slice, /*sq_slice*/ - (intobjargproc)array_ass_item, /*sq_ass_item*/ - (intintobjargproc)array_ass_slice, /*sq_ass_slice*/ + (ssizeargfunc)array_repeat, /*sq_repeat*/ + (ssizeargfunc)array_item, /*sq_item*/ + (ssizessizeargfunc)array_slice, /*sq_slice*/ + (ssizeobjargproc)array_ass_item, /*sq_ass_item*/ + (ssizessizeobjargproc)array_ass_slice, /*sq_ass_slice*/ (objobjproc)array_contains, /*sq_contains*/ (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/ - (intargfunc)array_inplace_repeat /*sq_inplace_repeat*/ + (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/ }; static PyBufferProcs array_as_buffer = { - (getreadbufferproc)array_buffer_getreadbuf, - (getwritebufferproc)array_buffer_getwritebuf, - (getsegcountproc)array_buffer_getsegcount, + (readbufferproc)array_buffer_getreadbuf, + (writebufferproc)array_buffer_getwritebuf, + (segcountproc)array_buffer_getsegcount, }; static PyObject * @@ -1822,7 +1827,7 @@ array_new(PyTypeObject *type, PyObject *args, PyObject *kwds) for (descr = descriptors; descr->typecode != '\0'; descr++) { if (descr->typecode == c) { PyObject *a; - int len; + Py_ssize_t len; if (initial == NULL || !(PyList_Check(initial) || PyTuple_Check(initial))) @@ -1835,7 +1840,7 @@ array_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return NULL; if (len > 0) { - int i; + Py_ssize_t i; for (i = 0; i < len; i++) { PyObject *v = PySequence_GetItem(initial, i); @@ -1864,7 +1869,7 @@ array_new(PyTypeObject *type, PyObject *args, PyObject *kwds) Py_DECREF(v); #ifdef Py_USING_UNICODE } else if (initial != NULL && PyUnicode_Check(initial)) { - int n = PyUnicode_GET_DATA_SIZE(initial); + Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial); if (n > 0) { arrayobject *self = (arrayobject *)a; char *item = self->ob_item; @@ -2012,9 +2017,9 @@ static PyTypeObject Arraytype = { typedef struct { PyObject_HEAD - long index; + Py_ssize_t index; arrayobject *ao; - PyObject * (*getitem)(struct arrayobject *, int); + PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); } arrayiterobject; static PyTypeObject PyArrayIter_Type; diff --git a/Modules/audioop.c b/Modules/audioop.c index 8d5a305..5e285f4 100644 --- a/Modules/audioop.c +++ b/Modules/audioop.c @@ -1020,7 +1020,9 @@ audioop_ratecv(PyObject *self, PyObject *args) cur_i[chan])); if (PyErr_Occurred()) goto exit; - len = ncp - PyString_AsString(str); + /* We have checked before that the length + * of the string fits into int. */ + len = (int)(ncp - PyString_AsString(str)); if (len == 0) { /*don't want to resize to zero length*/ rv = PyString_FromStringAndSize("", 0); diff --git a/Modules/bsddbmodule.c b/Modules/bsddbmodule.c index 6bdffde..61c6564 100644 --- a/Modules/bsddbmodule.c +++ b/Modules/bsddbmodule.c @@ -240,7 +240,7 @@ bsddb_dealloc(bsddbobject *dp) #define BSDDB_END_SAVE(_dp) Py_END_ALLOW_THREADS #endif -static int +static Py_ssize_t bsddb_length(bsddbobject *dp) { check_bsddbobject_open(dp, -1); @@ -374,7 +374,7 @@ bsddb_ass_sub(bsddbobject *dp, PyObject *key, PyObject *value) } static PyMappingMethods bsddb_as_mapping = { - (inquiry)bsddb_length, /*mp_length*/ + (lenfunc)bsddb_length, /*mp_length*/ (binaryfunc)bsddb_subscript, /*mp_subscript*/ (objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/ }; diff --git a/Modules/bz2module.c b/Modules/bz2module.c index 9f30f8a..a0f66ee 100644 --- a/Modules/bz2module.c +++ b/Modules/bz2module.c @@ -908,7 +908,7 @@ BZ2File_writelines(BZ2FileObject *self, PyObject *seq) PyObject *v = PyList_GET_ITEM(list, i); if (!PyString_Check(v)) { const char *buffer; - int len; + Py_ssize_t len; if (PyObject_AsCharBuffer(v, &buffer, &len)) { PyErr_SetString(PyExc_TypeError, "writelines() " diff --git a/Modules/cPickle.c b/Modules/cPickle.c index cc821fd..cb14627 100644 --- a/Modules/cPickle.c +++ b/Modules/cPickle.c @@ -339,7 +339,7 @@ typedef struct Picklerobject { int fast; /* Fast mode doesn't save in memo, don't use if circ ref */ int nesting; - int (*write_func)(struct Picklerobject *, const char *, int); + int (*write_func)(struct Picklerobject *, const char *, Py_ssize_t); char *write_buf; int buf_size; PyObject *dispatch_table; @@ -368,8 +368,8 @@ typedef struct Unpicklerobject { int *marks; int num_marks; int marks_size; - int (*read_func)(struct Unpicklerobject *, char **, int); - int (*readline_func)(struct Unpicklerobject *, char **); + Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t); + Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **); int buf_size; char *buf; PyObject *find_class; @@ -417,7 +417,7 @@ cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...) } static int -write_file(Picklerobject *self, const char *s, int n) +write_file(Picklerobject *self, const char *s, Py_ssize_t n) { size_t nbyteswritten; @@ -425,6 +425,11 @@ write_file(Picklerobject *self, const char *s, int n) return 0; } + if (n > INT_MAX) { + /* String too large */ + return -1; + } + Py_BEGIN_ALLOW_THREADS nbyteswritten = fwrite(s, sizeof(char), n, self->fp); Py_END_ALLOW_THREADS @@ -433,11 +438,11 @@ write_file(Picklerobject *self, const char *s, int n) return -1; } - return n; + return (int)n; } static int -write_cStringIO(Picklerobject *self, const char *s, int n) +write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t n) { if (s == NULL) { return 0; @@ -447,21 +452,26 @@ write_cStringIO(Picklerobject *self, const char *s, int n) return -1; } - return n; + return (int)n; } static int -write_none(Picklerobject *self, const char *s, int n) +write_none(Picklerobject *self, const char *s, Py_ssize_t n) { if (s == NULL) return 0; - return n; + if (n > INT_MAX) return -1; + return (int)n; } static int -write_other(Picklerobject *self, const char *s, int n) +write_other(Picklerobject *self, const char *s, Py_ssize_t _n) { PyObject *py_str = 0, *junk = 0; + int n; + if (_n > INT_MAX) + return -1; + n = (int)_n; if (s == NULL) { if (!( self->buf_size )) return 0; py_str = PyString_FromStringAndSize(self->write_buf, @@ -505,8 +515,8 @@ write_other(Picklerobject *self, const char *s, int n) } -static int -read_file(Unpicklerobject *self, char **s, int n) +static Py_ssize_t +read_file(Unpicklerobject *self, char **s, Py_ssize_t n) { size_t nbytesread; @@ -549,7 +559,7 @@ read_file(Unpicklerobject *self, char **s, int n) } -static int +static Py_ssize_t readline_file(Unpicklerobject *self, char **s) { int i; @@ -588,8 +598,8 @@ readline_file(Unpicklerobject *self, char **s) } -static int -read_cStringIO(Unpicklerobject *self, char **s, int n) +static Py_ssize_t +read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t n) { char *ptr; @@ -604,10 +614,10 @@ read_cStringIO(Unpicklerobject *self, char **s, int n) } -static int +static Py_ssize_t readline_cStringIO(Unpicklerobject *self, char **s) { - int n; + Py_ssize_t n; char *ptr; if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) { @@ -620,12 +630,12 @@ readline_cStringIO(Unpicklerobject *self, char **s) } -static int -read_other(Unpicklerobject *self, char **s, int n) +static Py_ssize_t +read_other(Unpicklerobject *self, char **s, Py_ssize_t n) { PyObject *bytes, *str=0; - if (!( bytes = PyInt_FromLong(n))) return -1; + if (!( bytes = PyInt_FromSsize_t(n))) return -1; ARG_TUP(self, bytes); if (self->arg) { @@ -642,11 +652,11 @@ read_other(Unpicklerobject *self, char **s, int n) } -static int +static Py_ssize_t readline_other(Unpicklerobject *self, char **s) { PyObject *str; - int str_size; + Py_ssize_t str_size; if (!( str = PyObject_CallObject(self->readline, empty_tuple))) { return -1; @@ -828,7 +838,7 @@ put2(Picklerobject *self, PyObject *ob) static PyObject * whichmodule(PyObject *global, PyObject *global_name) { - int i, j; + Py_ssize_t i, j; PyObject *module = 0, *modules_dict = 0, *global_name_attr = 0, *name = 0; @@ -3280,7 +3290,7 @@ load_long(Unpicklerobject *self) static int load_counted_long(Unpicklerobject *self, int size) { - int i; + Py_ssize_t i; char *nbytes; unsigned char *pdata; PyObject *along; @@ -4253,7 +4263,7 @@ load_build(Unpicklerobject *self) PyObject *state, *inst, *slotstate; PyObject *__setstate__; PyObject *d_key, *d_value; - int i; + Py_ssize_t i; int res = -1; /* Stack is ... instance, state. We want to leave instance at @@ -5710,7 +5720,7 @@ PyMODINIT_FUNC initcPickle(void) { PyObject *m, *d, *di, *v, *k; - int i; + Py_ssize_t i; char *rev = "1.71"; /* XXX when does this change? */ PyObject *format_version; PyObject *compatible_formats; diff --git a/Modules/cStringIO.c b/Modules/cStringIO.c index ad2f36b..618b88c 100644 --- a/Modules/cStringIO.c +++ b/Modules/cStringIO.c @@ -47,7 +47,7 @@ PyDoc_STRVAR(cStringIO_module_documentation, typedef struct { PyObject_HEAD char *buf; - int pos, string_size; + Py_ssize_t pos, string_size; } IOobject; #define IOOOBJECT(O) ((IOobject*)(O)) @@ -57,9 +57,10 @@ typedef struct { typedef struct { /* Subtype of IOobject */ PyObject_HEAD char *buf; - int pos, string_size; + Py_ssize_t pos, string_size; - int buf_size, softspace; + Py_ssize_t buf_size; + int softspace; } Oobject; /* Declarations for objects of type StringI */ @@ -67,7 +68,7 @@ typedef struct { /* Subtype of IOobject */ typedef struct { /* Subtype of IOobject */ PyObject_HEAD char *buf; - int pos, string_size; + Py_ssize_t pos, string_size; /* We store a reference to the object here in order to keep the buffer alive during the lifetime of the Iobject. */ PyObject *pbuf; @@ -154,7 +155,7 @@ PyDoc_STRVAR(IO_read__doc__, "read([s]) -- Read s characters, or the rest of the string"); static int -IO_cread(PyObject *self, char **output, int n) { +IO_cread(PyObject *self, char **output, Py_ssize_t n) { int l; UNLESS (IO__opencheck(IOOOBJECT(self))) return -1; @@ -171,10 +172,10 @@ IO_cread(PyObject *self, char **output, int n) { static PyObject * IO_read(IOobject *self, PyObject *args) { - int n = -1; + Py_ssize_t n = -1; char *output; - UNLESS (PyArg_ParseTuple(args, "|i:read", &n)) return NULL; + UNLESS (PyArg_ParseTuple(args, "|n:read", &n)) return NULL; if ( (n=IO_cread((PyObject*)self,&output,n)) < 0) return NULL; @@ -186,7 +187,7 @@ PyDoc_STRVAR(IO_readline__doc__, "readline() -- Read one line"); static int IO_creadline(PyObject *self, char **output) { char *n, *s; - int l; + Py_ssize_t l; UNLESS (IO__opencheck(IOOOBJECT(self))) return -1; @@ -197,8 +198,9 @@ IO_creadline(PyObject *self, char **output) { *output=((IOobject*)self)->buf + ((IOobject*)self)->pos; l = n - ((IOobject*)self)->buf - ((IOobject*)self)->pos; - ((IOobject*)self)->pos += l; - return l; + assert(((IOobject*)self)->pos + l < INT_MAX); + ((IOobject*)self)->pos += (int)l; + return (int)l; } static PyObject * @@ -285,10 +287,10 @@ PyDoc_STRVAR(IO_truncate__doc__, static PyObject * IO_truncate(IOobject *self, PyObject *args) { - int pos = -1; + Py_ssize_t pos = -1; UNLESS (IO__opencheck(self)) return NULL; - UNLESS (PyArg_ParseTuple(args, "|i:truncate", &pos)) return NULL; + UNLESS (PyArg_ParseTuple(args, "|n:truncate", &pos)) return NULL; if (pos < 0) pos = self->pos; if (self->string_size > pos) self->string_size = pos; @@ -324,10 +326,11 @@ PyDoc_STRVAR(O_seek__doc__, static PyObject * O_seek(Oobject *self, PyObject *args) { - int position, mode = 0; + Py_ssize_t position; + int mode = 0; UNLESS (IO__opencheck(IOOOBJECT(self))) return NULL; - UNLESS (PyArg_ParseTuple(args, "i|i:seek", &position, &mode)) + UNLESS (PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) return NULL; if (mode == 2) { @@ -362,8 +365,8 @@ PyDoc_STRVAR(O_write__doc__, static int -O_cwrite(PyObject *self, const char *c, int l) { - int newl; +O_cwrite(PyObject *self, const char *c, Py_ssize_t l) { + Py_ssize_t newl; Oobject *oself; UNLESS (IO__opencheck(IOOOBJECT(self))) return -1; @@ -372,8 +375,10 @@ O_cwrite(PyObject *self, const char *c, int l) { newl = oself->pos+l; if (newl >= oself->buf_size) { oself->buf_size *= 2; - if (oself->buf_size <= newl) - oself->buf_size = newl+1; + if (oself->buf_size <= newl) { + assert(newl + 1 < INT_MAX); + oself->buf_size = (int)(newl+1); + } UNLESS (oself->buf = (char*)realloc(oself->buf, oself->buf_size)) { PyErr_SetString(PyExc_MemoryError,"out of memory"); @@ -384,13 +389,14 @@ O_cwrite(PyObject *self, const char *c, int l) { memcpy(oself->buf+oself->pos,c,l); - oself->pos += l; + assert(oself->pos + l < INT_MAX); + oself->pos += (int)l; if (oself->string_size < oself->pos) { oself->string_size = oself->pos; } - return l; + return (int)l; } static PyObject * @@ -432,7 +438,7 @@ O_writelines(Oobject *self, PyObject *args) { if (it == NULL) return NULL; while ((s = PyIter_Next(it)) != NULL) { - int n; + Py_ssize_t n; char *c; if (PyString_AsStringAndSize(s, &c, &n) == -1) { Py_DECREF(it); @@ -564,10 +570,11 @@ I_close(Iobject *self, PyObject *unused) { static PyObject * I_seek(Iobject *self, PyObject *args) { - int position, mode = 0; + Py_ssize_t position; + int mode = 0; UNLESS (IO__opencheck(IOOOBJECT(self))) return NULL; - UNLESS (PyArg_ParseTuple(args, "i|i:seek", &position, &mode)) + UNLESS (PyArg_ParseTuple(args, "n|i:seek", &position, &mode)) return NULL; if (mode == 2) position += self->string_size; @@ -648,7 +655,7 @@ static PyObject * newIobject(PyObject *s) { Iobject *self; char *buf; - int size; + Py_ssize_t size; if (PyObject_AsReadBuffer(s, (const void **)&buf, &size)) { PyErr_Format(PyExc_TypeError, "expected read buffer, %.200s found", diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c index b0dae0c..c13de8f 100644 --- a/Modules/cjkcodecs/multibytecodec.c +++ b/Modules/cjkcodecs/multibytecodec.c @@ -214,7 +214,7 @@ multibytecodec_encerror(MultibyteCodec *codec, if (buf->excobj == NULL) { buf->excobj = PyUnicodeEncodeError_Create(codec->encoding, buf->inbuf_top, - (int)(buf->inbuf_end - buf->inbuf_top), + buf->inbuf_end - buf->inbuf_top, start, end, reason); if (buf->excobj == NULL) goto errorexit; diff --git a/Modules/collectionsmodule.c b/Modules/collectionsmodule.c index 2003154..41ef8cc 100644 --- a/Modules/collectionsmodule.c +++ b/Modules/collectionsmodule.c @@ -314,7 +314,7 @@ PyDoc_STRVAR(extendleft_doc, "Extend the left side of the deque with elements from the iterable"); static int -_deque_rotate(dequeobject *deque, int n) +_deque_rotate(dequeobject *deque, Py_ssize_t n) { int i, len=deque->len, halflen=(len+1)>>1; PyObject *item, *rv; @@ -365,7 +365,7 @@ deque_rotate(dequeobject *deque, PyObject *args) PyDoc_STRVAR(rotate_doc, "Rotate the deque n steps to the right (default n=1). If n is negative, rotates left."); -static int +static Py_ssize_t deque_len(dequeobject *deque) { return deque->len; @@ -374,7 +374,7 @@ deque_len(dequeobject *deque) static PyObject * deque_remove(dequeobject *deque, PyObject *value) { - int i, n=deque->len; + Py_ssize_t i, n=deque->len; for (i=0 ; ileftblock->data[deque->leftindex]; @@ -469,7 +469,7 @@ deque_item(dequeobject *deque, int i) */ static int -deque_del_item(dequeobject *deque, int i) +deque_del_item(dequeobject *deque, Py_ssize_t i) { PyObject *item; @@ -485,7 +485,7 @@ deque_del_item(dequeobject *deque, int i) } static int -deque_ass_item(dequeobject *deque, int i, PyObject *v) +deque_ass_item(dequeobject *deque, Py_ssize_t i, PyObject *v) { PyObject *old_value; block *b; @@ -776,12 +776,12 @@ deque_init(dequeobject *deque, PyObject *args, PyObject *kwds) } static PySequenceMethods deque_as_sequence = { - (inquiry)deque_len, /* sq_length */ + (lenfunc)deque_len, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ - (intargfunc)deque_item, /* sq_item */ + (ssizeargfunc)deque_item, /* sq_item */ 0, /* sq_slice */ - (intobjargproc)deque_ass_item, /* sq_ass_item */ + (ssizeobjargproc)deque_ass_item, /* sq_ass_item */ }; /* deque object ********************************************************/ diff --git a/Modules/datetimemodule.c b/Modules/datetimemodule.c index 50f47d4..5c0f220 100644 --- a/Modules/datetimemodule.c +++ b/Modules/datetimemodule.c @@ -596,7 +596,7 @@ normalize_datetime(int *year, int *month, int *day, */ static PyObject * -time_alloc(PyTypeObject *type, int aware) +time_alloc(PyTypeObject *type, Py_ssize_t aware) { PyObject *self; @@ -611,7 +611,7 @@ time_alloc(PyTypeObject *type, int aware) } static PyObject * -datetime_alloc(PyTypeObject *type, int aware) +datetime_alloc(PyTypeObject *type, Py_ssize_t aware) { PyObject *self; diff --git a/Modules/dbmmodule.c b/Modules/dbmmodule.c index cc963a2..8bfbbcd 100644 --- a/Modules/dbmmodule.c +++ b/Modules/dbmmodule.c @@ -70,7 +70,7 @@ dbm_dealloc(register dbmobject *dp) PyObject_Del(dp); } -static int +static Py_ssize_t dbm_length(dbmobject *dp) { if (dp->di_dbm == NULL) { @@ -162,7 +162,7 @@ dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w) } static PyMappingMethods dbm_as_mapping = { - (inquiry)dbm_length, /*mp_length*/ + (lenfunc)dbm_length, /*mp_length*/ (binaryfunc)dbm_subscript, /*mp_subscript*/ (objobjargproc)dbm_ass_sub, /*mp_ass_subscript*/ }; diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c index 00239bd..4902eb5 100644 --- a/Modules/gcmodule.c +++ b/Modules/gcmodule.c @@ -1274,7 +1274,7 @@ _PyObject_GC_New(PyTypeObject *tp) } PyVarObject * -_PyObject_GC_NewVar(PyTypeObject *tp, int nitems) +_PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems) { const size_t size = _PyObject_VAR_SIZE(tp, nitems); PyVarObject *op = (PyVarObject *) _PyObject_GC_Malloc(size); diff --git a/Modules/gdbmmodule.c b/Modules/gdbmmodule.c index 6045743..025bdb7 100644 --- a/Modules/gdbmmodule.c +++ b/Modules/gdbmmodule.c @@ -86,7 +86,7 @@ dbm_dealloc(register dbmobject *dp) PyObject_Del(dp); } -static int +static Py_ssize_t dbm_length(dbmobject *dp) { if (dp->di_dbm == NULL) { @@ -178,7 +178,7 @@ dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w) } static PyMappingMethods dbm_as_mapping = { - (inquiry)dbm_length, /*mp_length*/ + (lenfunc)dbm_length, /*mp_length*/ (binaryfunc)dbm_subscript, /*mp_subscript*/ (objobjargproc)dbm_ass_sub, /*mp_ass_subscript*/ }; diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c index b6b2d85..7a68de4 100644 --- a/Modules/mmapmodule.c +++ b/Modules/mmapmodule.c @@ -583,8 +583,8 @@ static struct PyMethodDef mmap_object_methods[] = { /* Functions for treating an mmap'ed file as a buffer */ -static int -mmap_buffer_getreadbuf(mmap_object *self, int index, const void **ptr) +static Py_ssize_t +mmap_buffer_getreadbuf(mmap_object *self, Py_ssize_t index, const void **ptr) { CHECK_VALID(-1); if ( index != 0 ) { @@ -596,8 +596,8 @@ mmap_buffer_getreadbuf(mmap_object *self, int index, const void **ptr) return self->size; } -static int -mmap_buffer_getwritebuf(mmap_object *self, int index, const void **ptr) +static Py_ssize_t +mmap_buffer_getwritebuf(mmap_object *self, Py_ssize_t index, const void **ptr) { CHECK_VALID(-1); if ( index != 0 ) { @@ -611,8 +611,8 @@ mmap_buffer_getwritebuf(mmap_object *self, int index, const void **ptr) return self->size; } -static int -mmap_buffer_getsegcount(mmap_object *self, int *lenp) +static Py_ssize_t +mmap_buffer_getsegcount(mmap_object *self, Py_ssize_t *lenp) { CHECK_VALID(-1); if (lenp) @@ -620,8 +620,8 @@ mmap_buffer_getsegcount(mmap_object *self, int *lenp) return 1; } -static int -mmap_buffer_getcharbuffer(mmap_object *self, int index, const void **ptr) +static Py_ssize_t +mmap_buffer_getcharbuffer(mmap_object *self, Py_ssize_t index, const void **ptr) { if ( index != 0 ) { PyErr_SetString(PyExc_SystemError, @@ -638,7 +638,7 @@ mmap_object_getattr(mmap_object *self, char *name) return Py_FindMethod (mmap_object_methods, (PyObject *)self, name); } -static int +static Py_ssize_t mmap_length(mmap_object *self) { CHECK_VALID(-1); @@ -646,7 +646,7 @@ mmap_length(mmap_object *self) } static PyObject * -mmap_item(mmap_object *self, int i) +mmap_item(mmap_object *self, Py_ssize_t i) { CHECK_VALID(NULL); if (i < 0 || (size_t)i >= self->size) { @@ -657,7 +657,7 @@ mmap_item(mmap_object *self, int i) } static PyObject * -mmap_slice(mmap_object *self, int ilow, int ihigh) +mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh) { CHECK_VALID(NULL); if (ilow < 0) @@ -684,7 +684,7 @@ mmap_concat(mmap_object *self, PyObject *bb) } static PyObject * -mmap_repeat(mmap_object *self, int n) +mmap_repeat(mmap_object *self, Py_ssize_t n) { CHECK_VALID(NULL); PyErr_SetString(PyExc_SystemError, @@ -693,7 +693,7 @@ mmap_repeat(mmap_object *self, int n) } static int -mmap_ass_slice(mmap_object *self, int ilow, int ihigh, PyObject *v) +mmap_ass_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) { const char *buf; @@ -732,7 +732,7 @@ mmap_ass_slice(mmap_object *self, int ilow, int ihigh, PyObject *v) } static int -mmap_ass_item(mmap_object *self, int i, PyObject *v) +mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v) { const char *buf; @@ -759,20 +759,20 @@ mmap_ass_item(mmap_object *self, int i, PyObject *v) } static PySequenceMethods mmap_as_sequence = { - (inquiry)mmap_length, /*sq_length*/ + (lenfunc)mmap_length, /*sq_length*/ (binaryfunc)mmap_concat, /*sq_concat*/ - (intargfunc)mmap_repeat, /*sq_repeat*/ - (intargfunc)mmap_item, /*sq_item*/ - (intintargfunc)mmap_slice, /*sq_slice*/ - (intobjargproc)mmap_ass_item, /*sq_ass_item*/ - (intintobjargproc)mmap_ass_slice, /*sq_ass_slice*/ + (ssizeargfunc)mmap_repeat, /*sq_repeat*/ + (ssizeargfunc)mmap_item, /*sq_item*/ + (ssizessizeargfunc)mmap_slice, /*sq_slice*/ + (ssizeobjargproc)mmap_ass_item, /*sq_ass_item*/ + (ssizessizeobjargproc)mmap_ass_slice, /*sq_ass_slice*/ }; static PyBufferProcs mmap_as_buffer = { - (getreadbufferproc)mmap_buffer_getreadbuf, - (getwritebufferproc)mmap_buffer_getwritebuf, - (getsegcountproc)mmap_buffer_getsegcount, - (getcharbufferproc)mmap_buffer_getcharbuffer, + (readbufferproc)mmap_buffer_getreadbuf, + (writebufferproc)mmap_buffer_getwritebuf, + (segcountproc)mmap_buffer_getsegcount, + (charbufferproc)mmap_buffer_getcharbuffer, }; static PyTypeObject mmap_object_type = { diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c index b2b32df..514e7e6 100644 --- a/Modules/parsermodule.c +++ b/Modules/parsermodule.c @@ -55,9 +55,9 @@ PyDoc_STRVAR(parser_doc_string, static char parser_version_string[] = "0.5"; -typedef PyObject* (*SeqMaker) (int length); +typedef PyObject* (*SeqMaker) (Py_ssize_t length); typedef int (*SeqInserter) (PyObject* sequence, - int index, + Py_ssize_t index, PyObject* element); /* The function below is copyrighted by Stichting Mathematisch Centrum. The @@ -632,8 +632,9 @@ parser_tuple2st(PyST_Object *self, PyObject *args, PyObject *kw) static node* build_node_children(PyObject *tuple, node *root, int *line_num) { - int len = PyObject_Size(tuple); - int i, err; + Py_ssize_t len = PyObject_Size(tuple); + Py_ssize_t i; + int err; for (i = 1; i < len; ++i) { /* elem must always be a sequence, however simple */ @@ -663,7 +664,7 @@ build_node_children(PyObject *tuple, node *root, int *line_num) return (0); } if (ISTERMINAL(type)) { - int len = PyObject_Size(elem); + Py_ssize_t len = PyObject_Size(elem); PyObject *temp; if ((len != 2) && (len != 3)) { diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c index ba7ea70..f35c090 100644 --- a/Modules/posixmodule.c +++ b/Modules/posixmodule.c @@ -1642,7 +1642,7 @@ posix_listdir(PyObject *self, PyObject *args) /* MAX_PATH characters could mean a bigger encoded string */ char namebuf[MAX_PATH*2+5]; char *bufptr = namebuf; - int len = sizeof(namebuf)/sizeof(namebuf[0]); + Py_ssize_t len = sizeof(namebuf)/sizeof(namebuf[0]); #ifdef Py_WIN_WIDE_FILENAMES /* If on wide-character-capable OS see if argument @@ -2340,7 +2340,7 @@ posix_execv(PyObject *self, PyObject *args) PyObject *argv; char **argvlist; int i, argc; - PyObject *(*getitem)(PyObject *, int); + PyObject *(*getitem)(PyObject *, Py_ssize_t); /* execv has two arguments: (path, argv), where argv is a list or tuple of strings. */ @@ -2409,7 +2409,7 @@ posix_execve(PyObject *self, PyObject *args) char **envlist; PyObject *key, *val, *keys=NULL, *vals=NULL; int i, pos, argc, envc; - PyObject *(*getitem)(PyObject *, int); + PyObject *(*getitem)(PyObject *, Py_ssize_t); int lastarg = 0; /* execve has three arguments: (path, argv, env), where @@ -2553,7 +2553,7 @@ posix_spawnv(PyObject *self, PyObject *args) char **argvlist; int mode, i, argc; Py_intptr_t spawnval; - PyObject *(*getitem)(PyObject *, int); + PyObject *(*getitem)(PyObject *, Py_ssize_t); /* spawnv has three arguments: (mode, path, argv), where argv is a list or tuple of strings. */ @@ -2642,7 +2642,7 @@ posix_spawnve(PyObject *self, PyObject *args) PyObject *key, *val, *keys=NULL, *vals=NULL, *res=NULL; int mode, i, pos, argc, envc; Py_intptr_t spawnval; - PyObject *(*getitem)(PyObject *, int); + PyObject *(*getitem)(PyObject *, Py_ssize_t); int lastarg = 0; /* spawnve has four arguments: (mode, path, argv, env), where @@ -2794,7 +2794,7 @@ posix_spawnvp(PyObject *self, PyObject *args) char **argvlist; int mode, i, argc; Py_intptr_t spawnval; - PyObject *(*getitem)(PyObject *, int); + PyObject *(*getitem)(PyObject *, Py_ssize_t); /* spawnvp has three arguments: (mode, path, argv), where argv is a list or tuple of strings. */ @@ -2875,7 +2875,7 @@ posix_spawnvpe(PyObject *self, PyObject *args) PyObject *key, *val, *keys=NULL, *vals=NULL, *res=NULL; int mode, i, pos, argc, envc; Py_intptr_t spawnval; - PyObject *(*getitem)(PyObject *, int); + PyObject *(*getitem)(PyObject *, Py_ssize_t); int lastarg = 0; /* spawnvpe has four arguments: (mode, path, argv, env), where @@ -4310,14 +4310,15 @@ _PyPopenCreateProcess(char *cmdstring, char *s1,*s2, *s3 = " /c "; const char *szConsoleSpawn = "w9xpopen.exe"; int i; - int x; + Py_ssize_t x; if (i = GetEnvironmentVariable("COMSPEC",NULL,0)) { char *comshell; s1 = (char *)alloca(i); if (!(x = GetEnvironmentVariable("COMSPEC", s1, i))) - return x; + /* x < i, so x fits into an integer */ + return (int)x; /* Explicitly check if we are using COMMAND.COM. If we are * then use the w9xpopen hack. @@ -4520,7 +4521,7 @@ _PyPopen(char *cmdstring, int mode, int n) switch (mode & (_O_RDONLY | _O_TEXT | _O_BINARY | _O_WRONLY)) { case _O_WRONLY | _O_TEXT: /* Case for writing to child Stdin in text mode. */ - fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); + fd1 = _open_osfhandle((intptr_t)hChildStdinWrDup, mode); f1 = _fdopen(fd1, "w"); f = PyFile_FromFile(f1, cmdstring, "w", _PyPclose); PyFile_SetBufSize(f, 0); @@ -4531,7 +4532,7 @@ _PyPopen(char *cmdstring, int mode, int n) case _O_RDONLY | _O_TEXT: /* Case for reading from child Stdout in text mode. */ - fd1 = _open_osfhandle((long)hChildStdoutRdDup, mode); + fd1 = _open_osfhandle((intptr_t)hChildStdoutRdDup, mode); f1 = _fdopen(fd1, "r"); f = PyFile_FromFile(f1, cmdstring, "r", _PyPclose); PyFile_SetBufSize(f, 0); @@ -4542,7 +4543,7 @@ _PyPopen(char *cmdstring, int mode, int n) case _O_RDONLY | _O_BINARY: /* Case for readinig from child Stdout in binary mode. */ - fd1 = _open_osfhandle((long)hChildStdoutRdDup, mode); + fd1 = _open_osfhandle((intptr_t)hChildStdoutRdDup, mode); f1 = _fdopen(fd1, "rb"); f = PyFile_FromFile(f1, cmdstring, "rb", _PyPclose); PyFile_SetBufSize(f, 0); @@ -4553,7 +4554,7 @@ _PyPopen(char *cmdstring, int mode, int n) case _O_WRONLY | _O_BINARY: /* Case for writing to child Stdin in binary mode. */ - fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); + fd1 = _open_osfhandle((intptr_t)hChildStdinWrDup, mode); f1 = _fdopen(fd1, "wb"); f = PyFile_FromFile(f1, cmdstring, "wb", _PyPclose); PyFile_SetBufSize(f, 0); @@ -4579,9 +4580,9 @@ _PyPopen(char *cmdstring, int mode, int n) m2 = "wb"; } - fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); + fd1 = _open_osfhandle((intptr_t)hChildStdinWrDup, mode); f1 = _fdopen(fd1, m2); - fd2 = _open_osfhandle((long)hChildStdoutRdDup, mode); + fd2 = _open_osfhandle((intptr_t)hChildStdoutRdDup, mode); f2 = _fdopen(fd2, m1); p1 = PyFile_FromFile(f1, cmdstring, m2, _PyPclose); PyFile_SetBufSize(p1, 0); @@ -4611,11 +4612,11 @@ _PyPopen(char *cmdstring, int mode, int n) m2 = "wb"; } - fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); + fd1 = _open_osfhandle((intptr_t)hChildStdinWrDup, mode); f1 = _fdopen(fd1, m2); - fd2 = _open_osfhandle((long)hChildStdoutRdDup, mode); + fd2 = _open_osfhandle((intptr_t)hChildStdoutRdDup, mode); f2 = _fdopen(fd2, m1); - fd3 = _open_osfhandle((long)hChildStderrRdDup, mode); + fd3 = _open_osfhandle((intptr_t)hChildStderrRdDup, mode); f3 = _fdopen(fd3, m1); p1 = PyFile_FromFile(f1, cmdstring, m2, _PyPclose); p2 = PyFile_FromFile(f2, cmdstring, m1, _PyPclose); @@ -5117,8 +5118,8 @@ PyDoc_STRVAR(posix_waitpid__doc__, static PyObject * posix_waitpid(PyObject *self, PyObject *args) { - int pid, options; - int status; + intptr_t pid; + int status, options; if (!PyArg_ParseTuple(args, "ii:waitpid", &pid, &options)) return NULL; diff --git a/Modules/rgbimgmodule.c b/Modules/rgbimgmodule.c index 8c70d95..67b5521 100644 --- a/Modules/rgbimgmodule.c +++ b/Modules/rgbimgmodule.c @@ -168,7 +168,7 @@ putlong(FILE *outf, Py_UInt32 val) buf[1] = (unsigned char) (val >> 16); buf[2] = (unsigned char) (val >> 8); buf[3] = (unsigned char) (val >> 0); - return fwrite(buf, 4, 1, outf); + return (int)fwrite(buf, 4, 1, outf); } static void @@ -200,7 +200,7 @@ writeheader(FILE *outf, IMAGE *image) putlong(outf, image->min); putlong(outf, image->max); putlong(outf, 0); - return fwrite("no name", 8, 1, outf); + return (int)fwrite("no name", 8, 1, outf); } static int @@ -567,7 +567,8 @@ longstoimage(PyObject *self, PyObject *args) Py_Int32 *starttab = NULL, *lengthtab = NULL; unsigned char *rlebuf = NULL; unsigned char *lumbuf = NULL; - int rlebuflen, goodwrite; + int rlebuflen; + Py_ssize_t goodwrite; PyObject *retval = NULL; if (!PyArg_ParseTuple(args, "s#iiis:longstoimage", &lptr, &len, diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c index 53c68c1..c9d403a 100644 --- a/Modules/selectmodule.c +++ b/Modules/selectmodule.c @@ -340,7 +340,7 @@ static PyTypeObject poll_Type; static int update_ufd_array(pollObject *self) { - int i, pos; + Py_ssize_t i, pos; PyObject *key, *value; self->ufd_len = PyDict_Size(self->dict); diff --git a/Modules/shamodule.c b/Modules/shamodule.c index 058391d..93a9224 100644 --- a/Modules/shamodule.c +++ b/Modules/shamodule.c @@ -543,7 +543,7 @@ hashed."); static PyObject * SHA_new(PyObject *self, PyObject *args, PyObject *kwdict) { - static char *kwlist[] = {"string", NULL}; + static const char *kwlist[] = {"string", NULL}; SHAobject *new; unsigned char *cp = NULL; int len; diff --git a/Modules/stropmodule.c b/Modules/stropmodule.c index 2917298..93dad8e 100644 --- a/Modules/stropmodule.c +++ b/Modules/stropmodule.c @@ -170,7 +170,7 @@ strop_joinfields(PyObject *self, PyObject *args) int i, reslen = 0, slen = 0, sz = 100; PyObject *res = NULL; char* p = NULL; - intargfunc getitemfunc; + ssizeargfunc getitemfunc; WARN; if (!PyArg_ParseTuple(args, "O|t#:join", &seq, &sep, &seplen)) @@ -364,7 +364,7 @@ static PyObject * do_strip(PyObject *args, int striptype) { char *s; - int len, i, j; + Py_ssize_t len, i, j; if (PyString_AsStringAndSize(args, &s, &len)) @@ -443,7 +443,7 @@ static PyObject * strop_lower(PyObject *self, PyObject *args) { char *s, *s_new; - int i, n; + Py_ssize_t i, n; PyObject *new; int changed; @@ -482,7 +482,7 @@ static PyObject * strop_upper(PyObject *self, PyObject *args) { char *s, *s_new; - int i, n; + Py_ssize_t i, n; PyObject *new; int changed; @@ -522,7 +522,7 @@ static PyObject * strop_capitalize(PyObject *self, PyObject *args) { char *s, *s_new; - int i, n; + Py_ssize_t i, n; PyObject *new; int changed; @@ -688,7 +688,7 @@ static PyObject * strop_swapcase(PyObject *self, PyObject *args) { char *s, *s_new; - int i, n; + Py_ssize_t i, n; PyObject *new; int changed; diff --git a/Modules/zipimport.c b/Modules/zipimport.c index 937b0f7..be141d0 100644 --- a/Modules/zipimport.c +++ b/Modules/zipimport.c @@ -249,6 +249,7 @@ make_filename(char *prefix, char *name, char *path) *p = SEP; } len += strlen(name); + assert(len < INT_MAX); return (int)len; } @@ -808,7 +809,8 @@ get_data(char *archive, PyObject *toc_entry) PyObject *raw_data, *data = NULL, *decompress; char *buf; FILE *fp; - int err, bytes_read = 0; + int err; + Py_ssize_t bytes_read = 0; long l; char *datapath; long compress, data_size, file_size, file_offset; @@ -1024,7 +1026,7 @@ get_mtime_of_source(ZipImporter *self, char *path) { PyObject *toc_entry; time_t mtime = 0; - int lastchar = strlen(path) - 1; + Py_ssize_t lastchar = strlen(path) - 1; char savechar = path[lastchar]; path[lastchar] = '\0'; /* strip 'c' or 'o' from *.py[co] */ toc_entry = PyDict_GetItemString(self->files, path); diff --git a/Objects/abstract.c b/Objects/abstract.c index b794974..3fe7a7e 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -56,7 +56,7 @@ PyObject_Type(PyObject *o) return v; } -int +Py_ssize_t PyObject_Size(PyObject *o) { PySequenceMethods *m; @@ -74,17 +74,17 @@ PyObject_Size(PyObject *o) } #undef PyObject_Length -int +Py_ssize_t PyObject_Length(PyObject *o) { return PyObject_Size(o); } #define PyObject_Length PyObject_Size -int +Py_ssize_t _PyObject_LengthHint(PyObject *o) { - int rv = PyObject_Size(o); + Py_ssize_t rv = PyObject_Size(o); if (rv != -1) return rv; if (PyErr_ExceptionMatches(PyExc_TypeError) || @@ -94,7 +94,7 @@ _PyObject_LengthHint(PyObject *o) PyErr_Fetch(&err_type, &err_value, &err_tb); ro = PyObject_CallMethod(o, "__length_hint__", NULL); if (ro != NULL) { - rv = (int)PyInt_AsLong(ro); + rv = PyInt_AsLong(ro); Py_DECREF(ro); Py_XDECREF(err_type); Py_XDECREF(err_value); @@ -218,11 +218,11 @@ PyObject_DelItemString(PyObject *o, char *key) int PyObject_AsCharBuffer(PyObject *obj, const char **buffer, - int *buffer_len) + Py_ssize_t *buffer_len) { PyBufferProcs *pb; const char *pp; - int len; + Py_ssize_t len; if (obj == NULL || buffer == NULL || buffer_len == NULL) { null_error(); @@ -264,11 +264,11 @@ PyObject_CheckReadBuffer(PyObject *obj) int PyObject_AsReadBuffer(PyObject *obj, const void **buffer, - int *buffer_len) + Py_ssize_t *buffer_len) { PyBufferProcs *pb; void *pp; - int len; + Py_ssize_t len; if (obj == NULL || buffer == NULL || buffer_len == NULL) { null_error(); @@ -297,11 +297,11 @@ int PyObject_AsReadBuffer(PyObject *obj, int PyObject_AsWriteBuffer(PyObject *obj, void **buffer, - int *buffer_len) + Py_ssize_t *buffer_len) { PyBufferProcs *pb; void*pp; - int len; + Py_ssize_t len; if (obj == NULL || buffer == NULL || buffer_len == NULL) { null_error(); @@ -645,7 +645,7 @@ PyNumber_Add(PyObject *v, PyObject *w) } static PyObject * -sequence_repeat(intargfunc repeatfunc, PyObject *seq, PyObject *n) +sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n) { long count; if (PyInt_Check(n)) { @@ -839,7 +839,7 @@ PyNumber_InPlaceMultiply(PyObject *v, PyObject *w) PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply), NB_SLOT(nb_multiply)); if (result == Py_NotImplemented) { - intargfunc f = NULL; + ssizeargfunc f = NULL; PySequenceMethods *mv = v->ob_type->tp_as_sequence; PySequenceMethods *mw = w->ob_type->tp_as_sequence; Py_DECREF(result); @@ -943,7 +943,7 @@ PyNumber_Absolute(PyObject *o) /* Add a check for embedded NULL-bytes in the argument. */ static PyObject * -int_from_string(const char *s, int len) +int_from_string(const char *s, Py_ssize_t len) { char *end; PyObject *x; @@ -965,7 +965,7 @@ PyNumber_Int(PyObject *o) { PyNumberMethods *m; const char *buffer; - int buffer_len; + Py_ssize_t buffer_len; if (o == NULL) return null_error(); @@ -1006,7 +1006,7 @@ PyNumber_Int(PyObject *o) /* Add a check for embedded NULL-bytes in the argument. */ static PyObject * -long_from_string(const char *s, int len) +long_from_string(const char *s, Py_ssize_t len) { char *end; PyObject *x; @@ -1028,7 +1028,7 @@ PyNumber_Long(PyObject *o) { PyNumberMethods *m; const char *buffer; - int buffer_len; + Py_ssize_t buffer_len; if (o == NULL) return null_error(); @@ -1103,7 +1103,7 @@ PySequence_Check(PyObject *s) s->ob_type->tp_as_sequence->sq_item != NULL; } -int +Py_ssize_t PySequence_Size(PyObject *s) { PySequenceMethods *m; @@ -1122,7 +1122,7 @@ PySequence_Size(PyObject *s) } #undef PySequence_Length -int +Py_ssize_t PySequence_Length(PyObject *s) { return PySequence_Size(s); @@ -1154,7 +1154,7 @@ PySequence_Concat(PyObject *s, PyObject *o) } PyObject * -PySequence_Repeat(PyObject *o, int count) +PySequence_Repeat(PyObject *o, Py_ssize_t count) { PySequenceMethods *m; @@ -1207,7 +1207,7 @@ PySequence_InPlaceConcat(PyObject *s, PyObject *o) } PyObject * -PySequence_InPlaceRepeat(PyObject *o, int count) +PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count) { PySequenceMethods *m; @@ -1236,7 +1236,7 @@ PySequence_InPlaceRepeat(PyObject *o, int count) } PyObject * -PySequence_GetItem(PyObject *s, int i) +PySequence_GetItem(PyObject *s, Py_ssize_t i) { PySequenceMethods *m; @@ -1247,7 +1247,7 @@ PySequence_GetItem(PyObject *s, int i) if (m && m->sq_item) { if (i < 0) { if (m->sq_length) { - int l = (*m->sq_length)(s); + Py_ssize_t l = (*m->sq_length)(s); if (l < 0) return NULL; i += l; @@ -1260,7 +1260,7 @@ PySequence_GetItem(PyObject *s, int i) } static PyObject * -sliceobj_from_intint(int i, int j) +sliceobj_from_intint(Py_ssize_t i, Py_ssize_t j) { PyObject *start, *end, *slice; start = PyInt_FromLong((long)i); @@ -1278,7 +1278,7 @@ sliceobj_from_intint(int i, int j) } PyObject * -PySequence_GetSlice(PyObject *s, int i1, int i2) +PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2) { PySequenceMethods *m; PyMappingMethods *mp; @@ -1289,7 +1289,7 @@ PySequence_GetSlice(PyObject *s, int i1, int i2) if (m && m->sq_slice) { if (i1 < 0 || i2 < 0) { if (m->sq_length) { - int l = (*m->sq_length)(s); + Py_ssize_t l = (*m->sq_length)(s); if (l < 0) return NULL; if (i1 < 0) @@ -1313,7 +1313,7 @@ PySequence_GetSlice(PyObject *s, int i1, int i2) } int -PySequence_SetItem(PyObject *s, int i, PyObject *o) +PySequence_SetItem(PyObject *s, Py_ssize_t i, PyObject *o) { PySequenceMethods *m; @@ -1326,7 +1326,7 @@ PySequence_SetItem(PyObject *s, int i, PyObject *o) if (m && m->sq_ass_item) { if (i < 0) { if (m->sq_length) { - int l = (*m->sq_length)(s); + Py_ssize_t l = (*m->sq_length)(s); if (l < 0) return -1; i += l; @@ -1340,7 +1340,7 @@ PySequence_SetItem(PyObject *s, int i, PyObject *o) } int -PySequence_DelItem(PyObject *s, int i) +PySequence_DelItem(PyObject *s, Py_ssize_t i) { PySequenceMethods *m; @@ -1353,7 +1353,7 @@ PySequence_DelItem(PyObject *s, int i) if (m && m->sq_ass_item) { if (i < 0) { if (m->sq_length) { - int l = (*m->sq_length)(s); + Py_ssize_t l = (*m->sq_length)(s); if (l < 0) return -1; i += l; @@ -1367,7 +1367,7 @@ PySequence_DelItem(PyObject *s, int i) } int -PySequence_SetSlice(PyObject *s, int i1, int i2, PyObject *o) +PySequence_SetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2, PyObject *o) { PySequenceMethods *m; PyMappingMethods *mp; @@ -1381,7 +1381,7 @@ PySequence_SetSlice(PyObject *s, int i1, int i2, PyObject *o) if (m && m->sq_ass_slice) { if (i1 < 0 || i2 < 0) { if (m->sq_length) { - int l = (*m->sq_length)(s); + Py_ssize_t l = (*m->sq_length)(s); if (l < 0) return -1; if (i1 < 0) @@ -1406,7 +1406,7 @@ PySequence_SetSlice(PyObject *s, int i1, int i2, PyObject *o) } int -PySequence_DelSlice(PyObject *s, int i1, int i2) +PySequence_DelSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2) { PySequenceMethods *m; @@ -1419,7 +1419,7 @@ PySequence_DelSlice(PyObject *s, int i1, int i2) if (m && m->sq_ass_slice) { if (i1 < 0 || i2 < 0) { if (m->sq_length) { - int l = (*m->sq_length)(s); + Py_ssize_t l = (*m->sq_length)(s); if (l < 0) return -1; if (i1 < 0) @@ -1438,9 +1438,9 @@ PyObject * PySequence_Tuple(PyObject *v) { PyObject *it; /* iter(v) */ - int n; /* guess for result tuple size */ + Py_ssize_t n; /* guess for result tuple size */ PyObject *result; - int j; + Py_ssize_t j; if (v == NULL) return null_error(); @@ -1486,7 +1486,7 @@ PySequence_Tuple(PyObject *v) break; } if (j >= n) { - int oldn = n; + Py_ssize_t oldn = n; /* The over-allocation strategy can grow a bit faster than for lists because unlike lists the over-allocation isn't permanent -- we reclaim @@ -1708,7 +1708,7 @@ PyMapping_Check(PyObject *o) o->ob_type->tp_as_sequence->sq_slice); } -int +Py_ssize_t PyMapping_Size(PyObject *o) { PyMappingMethods *m; @@ -1727,7 +1727,7 @@ PyMapping_Size(PyObject *o) } #undef PyMapping_Length -int +Py_ssize_t PyMapping_Length(PyObject *o) { return PyMapping_Size(o); @@ -2053,7 +2053,7 @@ static int abstract_issubclass(PyObject *derived, PyObject *cls) { PyObject *bases; - int i, n; + Py_ssize_t i, n; int r = 0; @@ -2137,7 +2137,7 @@ recursive_isinstance(PyObject *inst, PyObject *cls, int recursion_depth) } } else if (PyTuple_Check(cls)) { - int i, n; + Py_ssize_t i, n; if (!recursion_depth) { PyErr_SetString(PyExc_RuntimeError, @@ -2191,8 +2191,8 @@ recursive_issubclass(PyObject *derived, PyObject *cls, int recursion_depth) return -1; if (PyTuple_Check(cls)) { - int i; - int n = PyTuple_GET_SIZE(cls); + Py_ssize_t i; + Py_ssize_t n = PyTuple_GET_SIZE(cls); if (!recursion_depth) { PyErr_SetString(PyExc_RuntimeError, diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c index 56748e6..4a9e3ae 100644 --- a/Objects/bufferobject.c +++ b/Objects/bufferobject.c @@ -8,15 +8,15 @@ typedef struct { PyObject_HEAD PyObject *b_base; void *b_ptr; - int b_size; - int b_offset; + Py_ssize_t b_size; + Py_ssize_t b_offset; int b_readonly; long b_hash; } PyBufferObject; static int -get_buf(PyBufferObject *self, void **ptr, int *size) +get_buf(PyBufferObject *self, void **ptr, Py_ssize_t *size) { if (self->b_base == NULL) { assert (ptr != NULL); @@ -24,8 +24,8 @@ get_buf(PyBufferObject *self, void **ptr, int *size) *size = self->b_size; } else { - int count, offset; - getreadbufferproc proc; + Py_ssize_t count, offset; + readbufferproc proc; PyBufferProcs *bp = self->b_base->ob_type->tp_as_buffer; if ((*bp->bf_getsegcount)(self->b_base, NULL) != 1) { PyErr_SetString(PyExc_TypeError, @@ -35,7 +35,7 @@ get_buf(PyBufferObject *self, void **ptr, int *size) if (self->b_readonly) proc = bp->bf_getreadbuffer; else - proc = (getreadbufferproc)bp->bf_getwritebuffer; + proc = (readbufferproc)bp->bf_getwritebuffer; if ((count = (*proc)(self->b_base, 0, ptr)) < 0) return 0; /* apply constraints to the start/end */ @@ -56,7 +56,7 @@ get_buf(PyBufferObject *self, void **ptr, int *size) static PyObject * -buffer_from_memory(PyObject *base, int size, int offset, void *ptr, +buffer_from_memory(PyObject *base, Py_ssize_t size, Py_ssize_t offset, void *ptr, int readonly) { PyBufferObject * b; @@ -88,7 +88,7 @@ buffer_from_memory(PyObject *base, int size, int offset, void *ptr, } static PyObject * -buffer_from_object(PyObject *base, int size, int offset, int readonly) +buffer_from_object(PyObject *base, Py_ssize_t size, Py_ssize_t offset, int readonly) { if (offset < 0) { PyErr_SetString(PyExc_ValueError, @@ -99,7 +99,7 @@ buffer_from_object(PyObject *base, int size, int offset, int readonly) /* another buffer, refer to the base object */ PyBufferObject *b = (PyBufferObject *)base; if (b->b_size != Py_END_OF_BUFFER) { - int base_size = b->b_size - offset; + Py_ssize_t base_size = b->b_size - offset; if (base_size < 0) base_size = 0; if (size == Py_END_OF_BUFFER || size > base_size) @@ -113,7 +113,7 @@ buffer_from_object(PyObject *base, int size, int offset, int readonly) PyObject * -PyBuffer_FromObject(PyObject *base, int offset, int size) +PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size) { PyBufferProcs *pb = base->ob_type->tp_as_buffer; @@ -129,7 +129,7 @@ PyBuffer_FromObject(PyObject *base, int offset, int size) } PyObject * -PyBuffer_FromReadWriteObject(PyObject *base, int offset, int size) +PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size) { PyBufferProcs *pb = base->ob_type->tp_as_buffer; @@ -145,19 +145,19 @@ PyBuffer_FromReadWriteObject(PyObject *base, int offset, int size) } PyObject * -PyBuffer_FromMemory(void *ptr, int size) +PyBuffer_FromMemory(void *ptr, Py_ssize_t size) { return buffer_from_memory(NULL, size, 0, ptr, 1); } PyObject * -PyBuffer_FromReadWriteMemory(void *ptr, int size) +PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size) { return buffer_from_memory(NULL, size, 0, ptr, 0); } PyObject * -PyBuffer_New(int size) +PyBuffer_New(Py_ssize_t size) { PyObject *o; PyBufferObject * b; @@ -167,6 +167,7 @@ PyBuffer_New(int size) "size must be zero or positive"); return NULL; } + /* XXX: check for overflow in multiply */ /* Inline PyObject_New */ o = PyObject_MALLOC(sizeof(*b) + size); if ( o == NULL ) @@ -189,13 +190,13 @@ static PyObject * buffer_new(PyTypeObject *type, PyObject *args, PyObject *kw) { PyObject *ob; - int offset = 0; - int size = Py_END_OF_BUFFER; + Py_ssize_t offset = 0; + Py_ssize_t size = Py_END_OF_BUFFER; if (!_PyArg_NoKeywords("buffer()", kw)) return NULL; - if (!PyArg_ParseTuple(args, "O|ii:buffer", &ob, &offset, &size)) + if (!PyArg_ParseTuple(args, "O|ll:buffer", &ob, &offset, &size)) return NULL; return PyBuffer_FromObject(ob, offset, size); } @@ -220,7 +221,8 @@ static int buffer_compare(PyBufferObject *self, PyBufferObject *other) { void *p1, *p2; - int len_self, len_other, min_len, cmp; + Py_ssize_t len_self, len_other, min_len; + int cmp; if (!get_buf(self, &p1, &len_self)) return -1; @@ -238,17 +240,17 @@ buffer_compare(PyBufferObject *self, PyBufferObject *other) static PyObject * buffer_repr(PyBufferObject *self) { - char *status = self->b_readonly ? "read-only" : "read-write"; + const char *status = self->b_readonly ? "read-only" : "read-write"; if ( self->b_base == NULL ) - return PyString_FromFormat("<%s buffer ptr %p, size %d at %p>", + return PyString_FromFormat("<%s buffer ptr %p, size %ld at %p>", status, self->b_ptr, self->b_size, self); else return PyString_FromFormat( - "<%s buffer for %p, size %d, offset %d at %p>", + "<%s buffer for %p, size %ld, offset %ld at %p>", status, self->b_base, self->b_size, @@ -260,8 +262,8 @@ static long buffer_hash(PyBufferObject *self) { void *ptr; - int size; - register int len; + Py_ssize_t size; + register Py_ssize_t len; register unsigned char *p; register long x; @@ -300,7 +302,7 @@ static PyObject * buffer_str(PyBufferObject *self) { void *ptr; - int size; + Py_ssize_t size; if (!get_buf(self, &ptr, &size)) return NULL; return PyString_FromStringAndSize(ptr, size); @@ -308,11 +310,11 @@ buffer_str(PyBufferObject *self) /* Sequence methods */ -static int +static Py_ssize_t buffer_length(PyBufferObject *self) { void *ptr; - int size; + Py_ssize_t size; if (!get_buf(self, &ptr, &size)) return -1; return size; @@ -325,7 +327,7 @@ buffer_concat(PyBufferObject *self, PyObject *other) void *ptr1, *ptr2; char *p; PyObject *ob; - int size, count; + Py_ssize_t size, count; if ( pb == NULL || pb->bf_getreadbuffer == NULL || @@ -369,12 +371,12 @@ buffer_concat(PyBufferObject *self, PyObject *other) } static PyObject * -buffer_repeat(PyBufferObject *self, int count) +buffer_repeat(PyBufferObject *self, Py_ssize_t count) { PyObject *ob; register char *p; void *ptr; - int size; + Py_ssize_t size; if ( count < 0 ) count = 0; @@ -398,10 +400,10 @@ buffer_repeat(PyBufferObject *self, int count) } static PyObject * -buffer_item(PyBufferObject *self, int idx) +buffer_item(PyBufferObject *self, Py_ssize_t idx) { void *ptr; - int size; + Py_ssize_t size; if (!get_buf(self, &ptr, &size)) return NULL; if ( idx < 0 || idx >= size ) { @@ -412,10 +414,10 @@ buffer_item(PyBufferObject *self, int idx) } static PyObject * -buffer_slice(PyBufferObject *self, int left, int right) +buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right) { void *ptr; - int size; + Py_ssize_t size; if (!get_buf(self, &ptr, &size)) return NULL; if ( left < 0 ) @@ -431,12 +433,12 @@ buffer_slice(PyBufferObject *self, int left, int right) } static int -buffer_ass_item(PyBufferObject *self, int idx, PyObject *other) +buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other) { PyBufferProcs *pb; void *ptr1, *ptr2; - int size; - int count; + Py_ssize_t size; + Py_ssize_t count; if ( self->b_readonly ) { PyErr_SetString(PyExc_TypeError, @@ -482,13 +484,13 @@ buffer_ass_item(PyBufferObject *self, int idx, PyObject *other) } static int -buffer_ass_slice(PyBufferObject *self, int left, int right, PyObject *other) +buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right, PyObject *other) { PyBufferProcs *pb; void *ptr1, *ptr2; - int size; - int slice_len; - int count; + Py_ssize_t size; + Py_ssize_t slice_len; + Py_ssize_t count; if ( self->b_readonly ) { PyErr_SetString(PyExc_TypeError, @@ -541,10 +543,10 @@ buffer_ass_slice(PyBufferObject *self, int left, int right, PyObject *other) /* Buffer methods */ -static int -buffer_getreadbuf(PyBufferObject *self, int idx, void **pp) +static Py_ssize_t +buffer_getreadbuf(PyBufferObject *self, Py_ssize_t idx, void **pp) { - int size; + Py_ssize_t size; if ( idx != 0 ) { PyErr_SetString(PyExc_SystemError, "accessing non-existent buffer segment"); @@ -555,8 +557,8 @@ buffer_getreadbuf(PyBufferObject *self, int idx, void **pp) return size; } -static int -buffer_getwritebuf(PyBufferObject *self, int idx, void **pp) +static Py_ssize_t +buffer_getwritebuf(PyBufferObject *self, Py_ssize_t idx, void **pp) { if ( self->b_readonly ) { @@ -566,11 +568,11 @@ buffer_getwritebuf(PyBufferObject *self, int idx, void **pp) return buffer_getreadbuf(self, idx, pp); } -static int -buffer_getsegcount(PyBufferObject *self, int *lenp) +static Py_ssize_t +buffer_getsegcount(PyBufferObject *self, Py_ssize_t *lenp) { void *ptr; - int size; + Py_ssize_t size; if (!get_buf(self, &ptr, &size)) return -1; if (lenp) @@ -578,11 +580,11 @@ buffer_getsegcount(PyBufferObject *self, int *lenp) return 1; } -static int -buffer_getcharbuf(PyBufferObject *self, int idx, const char **pp) +static Py_ssize_t +buffer_getcharbuf(PyBufferObject *self, Py_ssize_t idx, const char **pp) { void *ptr; - int size; + Py_ssize_t size; if ( idx != 0 ) { PyErr_SetString(PyExc_SystemError, "accessing non-existent buffer segment"); @@ -596,20 +598,20 @@ buffer_getcharbuf(PyBufferObject *self, int idx, const char **pp) static PySequenceMethods buffer_as_sequence = { - (inquiry)buffer_length, /*sq_length*/ + (lenfunc)buffer_length, /*sq_length*/ (binaryfunc)buffer_concat, /*sq_concat*/ - (intargfunc)buffer_repeat, /*sq_repeat*/ - (intargfunc)buffer_item, /*sq_item*/ - (intintargfunc)buffer_slice, /*sq_slice*/ - (intobjargproc)buffer_ass_item, /*sq_ass_item*/ - (intintobjargproc)buffer_ass_slice, /*sq_ass_slice*/ + (ssizeargfunc)buffer_repeat, /*sq_repeat*/ + (ssizeargfunc)buffer_item, /*sq_item*/ + (ssizessizeargfunc)buffer_slice, /*sq_slice*/ + (ssizeobjargproc)buffer_ass_item, /*sq_ass_item*/ + (ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/ }; static PyBufferProcs buffer_as_buffer = { - (getreadbufferproc)buffer_getreadbuf, - (getwritebufferproc)buffer_getwritebuf, - (getsegcountproc)buffer_getsegcount, - (getcharbufferproc)buffer_getcharbuf, + (readbufferproc)buffer_getreadbuf, + (writebufferproc)buffer_getwritebuf, + (segcountproc)buffer_getsegcount, + (charbufferproc)buffer_getcharbuf, }; PyTypeObject PyBuffer_Type = { diff --git a/Objects/classobject.c b/Objects/classobject.c index c8057e2..7d975ec 100644 --- a/Objects/classobject.c +++ b/Objects/classobject.c @@ -68,7 +68,7 @@ PyClass_New(PyObject *bases, PyObject *dict, PyObject *name) return NULL; } else { - int i, n; + Py_ssize_t i, n; PyObject *base; if (!PyTuple_Check(bases)) { PyErr_SetString(PyExc_TypeError, @@ -185,7 +185,7 @@ class_dealloc(PyClassObject *op) static PyObject * class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass) { - int i, n; + Py_ssize_t i, n; PyObject *value = PyDict_GetItem(cp->cl_dict, name); if (value != NULL) { *pclass = cp; @@ -281,7 +281,7 @@ set_dict(PyClassObject *c, PyObject *v) static char * set_bases(PyClassObject *c, PyObject *v) { - int i, n; + Py_ssize_t i, n; if (v == NULL || !PyTuple_Check(v)) return "__bases__ must be a tuple object"; @@ -483,7 +483,7 @@ PyTypeObject PyClass_Type = { int PyClass_IsSubclass(PyObject *class, PyObject *base) { - int i, n; + Py_ssize_t i, n; PyClassObject *cp; if (class == base) return 1; @@ -996,12 +996,12 @@ instance_traverse(PyInstanceObject *o, visitproc visit, void *arg) static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr; static PyObject *iterstr, *nextstr; -static int +static Py_ssize_t instance_length(PyInstanceObject *inst) { PyObject *func; PyObject *res; - int outcome; + Py_ssize_t outcome; if (lenstr == NULL) lenstr = PyString_InternFromString("__len__"); @@ -1013,9 +1013,13 @@ instance_length(PyInstanceObject *inst) if (res == NULL) return -1; if (PyInt_Check(res)) { - long temp = PyInt_AsLong(res); - outcome = (int)temp; -#if SIZEOF_INT < SIZEOF_LONG + Py_ssize_t temp = PyInt_AsSsize_t(res); + if (temp == -1 && PyErr_Occurred()) { + Py_DECREF(res); + return -1; + } + outcome = (Py_ssize_t)temp; +#if SIZEOF_SIZE_T < SIZEOF_LONG /* Overflow check -- range of PyInt is more than C int */ if (outcome != temp) { PyErr_SetString(PyExc_OverflowError, @@ -1097,13 +1101,13 @@ instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value) } static PyMappingMethods instance_as_mapping = { - (inquiry)instance_length, /* mp_length */ + (lenfunc)instance_length, /* mp_length */ (binaryfunc)instance_subscript, /* mp_subscript */ (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */ }; static PyObject * -instance_item(PyInstanceObject *inst, int i) +instance_item(PyInstanceObject *inst, Py_ssize_t i) { PyObject *func, *arg, *res; @@ -1112,7 +1116,7 @@ instance_item(PyInstanceObject *inst, int i) func = instance_getattr(inst, getitemstr); if (func == NULL) return NULL; - arg = Py_BuildValue("(i)", i); + arg = Py_BuildValue("(n)", i); if (arg == NULL) { Py_DECREF(func); return NULL; @@ -1124,7 +1128,7 @@ instance_item(PyInstanceObject *inst, int i) } static PyObject * -sliceobj_from_intint(int i, int j) +sliceobj_from_intint(Py_ssize_t i, Py_ssize_t j) { PyObject *start, *end, *res; @@ -1145,7 +1149,7 @@ sliceobj_from_intint(int i, int j) static PyObject * -instance_slice(PyInstanceObject *inst, int i, int j) +instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j) { PyObject *func, *arg, *res; static PyObject *getslicestr; @@ -1179,7 +1183,7 @@ instance_slice(PyInstanceObject *inst, int i, int j) } static int -instance_ass_item(PyInstanceObject *inst, int i, PyObject *item) +instance_ass_item(PyInstanceObject *inst, Py_ssize_t i, PyObject *item) { PyObject *func, *arg, *res; @@ -1213,7 +1217,7 @@ instance_ass_item(PyInstanceObject *inst, int i, PyObject *item) } static int -instance_ass_slice(PyInstanceObject *inst, int i, int j, PyObject *value) +instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject *value) { PyObject *func, *arg, *res; static PyObject *setslicestr, *delslicestr; @@ -1322,13 +1326,13 @@ instance_contains(PyInstanceObject *inst, PyObject *member) static PySequenceMethods instance_as_sequence = { - (inquiry)instance_length, /* sq_length */ + (lenfunc)instance_length, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ - (intargfunc)instance_item, /* sq_item */ - (intintargfunc)instance_slice, /* sq_slice */ - (intobjargproc)instance_ass_item, /* sq_ass_item */ - (intintobjargproc)instance_ass_slice, /* sq_ass_slice */ + (ssizeargfunc)instance_item, /* sq_item */ + (ssizessizeargfunc)instance_slice, /* sq_slice */ + (ssizeobjargproc)instance_ass_item, /* sq_ass_item */ + (ssizessizeobjargproc)instance_ass_slice,/* sq_ass_slice */ (objobjproc)instance_contains, /* sq_contains */ }; @@ -2430,7 +2434,7 @@ instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw) Py_INCREF(arg); } else { - int argcount = PyTuple_Size(arg); + Py_ssize_t argcount = PyTuple_Size(arg); PyObject *newarg = PyTuple_New(argcount + 1); int i; if (newarg == NULL) diff --git a/Objects/codeobject.c b/Objects/codeobject.c index c5ddfd5..f832911 100644 --- a/Objects/codeobject.c +++ b/Objects/codeobject.c @@ -28,7 +28,7 @@ all_name_chars(unsigned char *s) static void intern_strings(PyObject *tuple) { - int i; + Py_ssize_t i; for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { PyObject *v = PyTuple_GET_ITEM(tuple, i); @@ -48,7 +48,7 @@ PyCode_New(int argcount, int nlocals, int stacksize, int flags, PyObject *lnotab) { PyCodeObject *co; - int i; + Py_ssize_t i; /* Check argument types */ if (argcount < 0 || nlocals < 0 || code == NULL || @@ -135,7 +135,7 @@ validate_and_copy_tuple(PyObject *tup) { PyObject *newtuple; PyObject *item; - int i, len; + Py_ssize_t i, len; len = PyTuple_GET_SIZE(tup); newtuple = PyTuple_New(len); diff --git a/Objects/complexobject.c b/Objects/complexobject.c index 08c8c89..f29a90f 100644 --- a/Objects/complexobject.c +++ b/Objects/complexobject.c @@ -680,7 +680,7 @@ complex_subtype_from_string(PyTypeObject *type, PyObject *v) #ifdef Py_USING_UNICODE char s_buffer[256]; #endif - int len; + Py_ssize_t len; if (PyString_Check(v)) { s = PyString_AS_STRING(v); @@ -699,7 +699,7 @@ complex_subtype_from_string(PyTypeObject *type, PyObject *v) NULL)) return NULL; s = s_buffer; - len = (int)strlen(s); + len = strlen(s); } #endif else if (PyObject_AsCharBuffer(v, &s, &len)) { diff --git a/Objects/descrobject.c b/Objects/descrobject.c index f763832..6972a69 100644 --- a/Objects/descrobject.c +++ b/Objects/descrobject.c @@ -209,7 +209,7 @@ getset_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) static PyObject * methoddescr_call(PyMethodDescrObject *descr, PyObject *args, PyObject *kwds) { - int argc; + Py_ssize_t argc; PyObject *self, *func, *result; /* Make sure that the first argument is acceptable as 'self' */ @@ -267,7 +267,7 @@ classmethoddescr_call(PyMethodDescrObject *descr, PyObject *args, static PyObject * wrapperdescr_call(PyWrapperDescrObject *descr, PyObject *args, PyObject *kwds) { - int argc; + Py_ssize_t argc; PyObject *self, *func, *result; /* Make sure that the first argument is acceptable as 'self' */ @@ -669,7 +669,7 @@ typedef struct { PyObject *dict; } proxyobject; -static int +static Py_ssize_t proxy_len(proxyobject *pp) { return PyObject_Size(pp->dict); @@ -682,7 +682,7 @@ proxy_getitem(proxyobject *pp, PyObject *key) } static PyMappingMethods proxy_as_mapping = { - (inquiry)proxy_len, /* mp_length */ + (lenfunc)proxy_len, /* mp_length */ (binaryfunc)proxy_getitem, /* mp_subscript */ 0, /* mp_ass_subscript */ }; diff --git a/Objects/dictobject.c b/Objects/dictobject.c index 1deb26c..bacb705 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -217,8 +217,8 @@ reported by this function, and outstanding exceptions are maintained. static dictentry * lookdict(dictobject *mp, PyObject *key, register long hash) { - register int i; - register unsigned int perturb; + register Py_ssize_t i; + register size_t perturb; register dictentry *freeslot; register unsigned int mask = mp->ma_mask; dictentry *ep0 = mp->ma_table; @@ -328,8 +328,8 @@ Done: static dictentry * lookdict_string(dictobject *mp, PyObject *key, register long hash) { - register int i; - register unsigned int perturb; + register Py_ssize_t i; + register size_t perturb; register dictentry *freeslot; register unsigned int mask = mp->ma_mask; dictentry *ep0 = mp->ma_table; @@ -690,9 +690,10 @@ PyDict_Clear(PyObject *op) * delete keys), via PyDict_SetItem(). */ int -PyDict_Next(PyObject *op, int *ppos, PyObject **pkey, PyObject **pvalue) +PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { - register int i, mask; + register Py_ssize_t i; + register int mask; register dictentry *ep; if (!PyDict_Check(op)) @@ -786,7 +787,7 @@ dict_print(register dictobject *mp, register FILE *fp, register int flags) static PyObject * dict_repr(dictobject *mp) { - int i; + Py_ssize_t i; PyObject *s, *temp, *colon = NULL; PyObject *pieces = NULL, *result = NULL; PyObject *key, *value; @@ -862,7 +863,7 @@ Done: return result; } -static int +static Py_ssize_t dict_length(dictobject *mp) { return mp->ma_used; @@ -898,7 +899,7 @@ dict_ass_sub(dictobject *mp, PyObject *v, PyObject *w) } static PyMappingMethods dict_as_mapping = { - (inquiry)dict_length, /*mp_length*/ + (lenfunc)dict_length, /*mp_length*/ (binaryfunc)dict_subscript, /*mp_subscript*/ (objobjargproc)dict_ass_sub, /*mp_ass_subscript*/ }; @@ -1109,7 +1110,7 @@ int PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override) { PyObject *it; /* iter(seq2) */ - int i; /* index into seq2 of current element */ + int i; /* index into seq2 of current element */ PyObject *item; /* seq2[i] */ PyObject *fast; /* item as a 2-tuple or 2-list */ @@ -1123,7 +1124,7 @@ PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override) for (i = 0; ; ++i) { PyObject *key, *value; - int n; + Py_ssize_t n; fast = NULL; item = PyIter_Next(it); @@ -1147,7 +1148,7 @@ PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override) if (n != 2) { PyErr_Format(PyExc_ValueError, "dictionary update sequence element #%d " - "has length %d; 2 is required", + "has length %ld; 2 is required", i, n); goto Fail; } @@ -1300,7 +1301,7 @@ PyDict_Copy(PyObject *o) return NULL; } -int +Py_ssize_t PyDict_Size(PyObject *mp) { if (mp == NULL || !PyDict_Check(mp)) { @@ -1708,7 +1709,8 @@ dict_popitem(dictobject *mp) static int dict_traverse(PyObject *op, visitproc visit, void *arg) { - int i = 0, err; + Py_ssize_t i = 0; + int err; PyObject *pk; PyObject *pv; @@ -2057,7 +2059,7 @@ dictiter_dealloc(dictiterobject *di) static PyObject * dictiter_len(dictiterobject *di) { - int len = 0; + long len = 0; if (di->di_dict != NULL && di->di_used == di->di_dict->ma_used) len = di->len; return PyInt_FromLong(len); diff --git a/Objects/enumobject.c b/Objects/enumobject.c index 7a5d1a1..e6e5bc5 100644 --- a/Objects/enumobject.c +++ b/Objects/enumobject.c @@ -241,7 +241,7 @@ PyDoc_STRVAR(reversed_doc, static PyObject * reversed_len(reversedobject *ro) { - int position, seqsize; + Py_ssize_t position, seqsize; if (ro->seq == NULL) return PyInt_FromLong(0); diff --git a/Objects/fileobject.c b/Objects/fileobject.c index 6faabc3..e4fffdd 100644 --- a/Objects/fileobject.c +++ b/Objects/fileobject.c @@ -1,5 +1,6 @@ /* File object implementation */ +#define PY_SSIZE_T_CLEAN #include "Python.h" #include "structmember.h" @@ -869,8 +870,8 @@ static PyObject * file_readinto(PyFileObject *f, PyObject *args) { char *ptr; - int ntodo; - size_t ndone, nnow; + Py_ssize_t ntodo; + Py_ssize_t ndone, nnow; if (f->f_fp == NULL) return err_closed(); @@ -988,7 +989,8 @@ getline_via_fgets(FILE *fp) pvend = buf + total_v_size; nfree = pvend - pvfree; memset(pvfree, '\n', nfree); - p = fgets(pvfree, nfree, fp); + assert(nfree < INT_MAX); /* Should be atmost MAXBUFSIZE */ + p = fgets(pvfree, (int)nfree, fp); Py_END_ALLOW_THREADS if (p == NULL) { @@ -1062,7 +1064,8 @@ getline_via_fgets(FILE *fp) pvend = BUF(v) + total_v_size; nfree = pvend - pvfree; memset(pvfree, '\n', nfree); - p = fgets(pvfree, nfree, fp); + assert(nfree < INT_MAX); + p = fgets(pvfree, (int)nfree, fp); Py_END_ALLOW_THREADS if (p == NULL) { @@ -1271,7 +1274,7 @@ PyFile_GetLine(PyObject *f, int n) if (n < 0 && result != NULL && PyString_Check(result)) { char *s = PyString_AS_STRING(result); - int len = PyString_GET_SIZE(result); + Py_ssize_t len = PyString_GET_SIZE(result); if (len == 0) { Py_DECREF(result); result = NULL; @@ -1292,7 +1295,7 @@ PyFile_GetLine(PyObject *f, int n) #ifdef Py_USING_UNICODE if (n < 0 && result != NULL && PyUnicode_Check(result)) { Py_UNICODE *s = PyUnicode_AS_UNICODE(result); - int len = PyUnicode_GET_SIZE(result); + Py_ssize_t len = PyUnicode_GET_SIZE(result); if (len == 0) { Py_DECREF(result); result = NULL; @@ -1468,7 +1471,7 @@ static PyObject * file_write(PyFileObject *f, PyObject *args) { char *s; - int n, n2; + Py_ssize_t n, n2; if (f->f_fp == NULL) return err_closed(); if (!PyArg_ParseTuple(args, f->f_binary ? "s#" : "t#", &s, &n)) @@ -1494,7 +1497,8 @@ file_writelines(PyFileObject *f, PyObject *seq) PyObject *list, *line; PyObject *it; /* iter(seq) */ PyObject *result; - int i, j, index, len, nwritten, islist; + int index, islist; + Py_ssize_t i, j, nwritten, len; assert(seq != NULL); if (f->f_fp == NULL) @@ -1552,7 +1556,6 @@ file_writelines(PyFileObject *f, PyObject *seq) PyObject *v = PyList_GET_ITEM(list, i); if (!PyString_Check(v)) { const char *buffer; - int len; if (((f->f_binary && PyObject_AsReadBuffer(v, (const void**)&buffer, @@ -1789,7 +1792,7 @@ drop_readahead(PyFileObject *f) static int readahead(PyFileObject *f, int bufsize) { - int chunksize; + Py_ssize_t chunksize; if (f->f_buf != NULL) { if( (f->f_bufend - f->f_bufptr) >= 1) @@ -1829,7 +1832,7 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize) PyStringObject* s; char *bufptr; char *buf; - int len; + Py_ssize_t len; if (f->f_buf == NULL) if (readahead(f, bufsize) < 0) @@ -1855,8 +1858,9 @@ readahead_get_line_skip(PyFileObject *f, int skip, int bufsize) bufptr = f->f_bufptr; buf = f->f_buf; f->f_buf = NULL; /* Force new readahead buffer */ + assert(skip+len < INT_MAX); s = readahead_get_line_skip( - f, skip+len, bufsize + (bufsize>>2) ); + f, (int)(skip+len), bufsize + (bufsize>>2) ); if (s == NULL) { PyMem_Free(buf); return NULL; @@ -2061,7 +2065,7 @@ PyTypeObject PyFile_Type = { int PyFile_SoftSpace(PyObject *f, int newflag) { - int oldflag = 0; + long oldflag = 0; if (f == NULL) { /* Do nothing */ } @@ -2077,6 +2081,7 @@ PyFile_SoftSpace(PyObject *f, int newflag) else { if (PyInt_Check(v)) oldflag = PyInt_AsLong(v); + assert(oldflag < INT_MAX); Py_DECREF(v); } v = PyInt_FromLong((long)newflag); @@ -2088,7 +2093,7 @@ PyFile_SoftSpace(PyObject *f, int newflag) Py_DECREF(v); } } - return oldflag; + return (int)oldflag; } /* Interfaces to write objects/strings to file-like objects */ diff --git a/Objects/floatobject.c b/Objects/floatobject.c index 86c2ba3..e1e063b 100644 --- a/Objects/floatobject.c +++ b/Objects/floatobject.c @@ -87,7 +87,7 @@ PyFloat_FromString(PyObject *v, char **pend) #ifdef Py_USING_UNICODE char s_buffer[256]; /* for objects convertible to a char buffer */ #endif - int len; + Py_ssize_t len; if (pend) *pend = NULL; @@ -108,7 +108,7 @@ PyFloat_FromString(PyObject *v, char **pend) NULL)) return NULL; s = s_buffer; - len = (int)strlen(s); + len = strlen(s); } #endif else if (PyObject_AsCharBuffer(v, &s, &len)) { diff --git a/Objects/frameobject.c b/Objects/frameobject.c index 3535544..6e3f297 100644 --- a/Objects/frameobject.c +++ b/Objects/frameobject.c @@ -71,9 +71,9 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno) int new_lasti = 0; /* The new value of f_lasti */ int new_iblock = 0; /* The new value of f_iblock */ char *code = NULL; /* The bytecode for the frame... */ - int code_len = 0; /* ...and its length */ + Py_ssize_t code_len = 0; /* ...and its length */ char *lnotab = NULL; /* Iterating over co_lnotab */ - int lnotab_len = 0; /* (ditto) */ + Py_ssize_t lnotab_len = 0; /* (ditto) */ int offset = 0; /* (ditto) */ int line = 0; /* (ditto) */ int addr = 0; /* (ditto) */ @@ -540,7 +540,7 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, PyFrameObject *back = tstate->frame; PyFrameObject *f; PyObject *builtins; - int extras, ncells, nfrees, i; + Py_ssize_t extras, ncells, nfrees, i; #ifdef Py_DEBUG if (code == NULL || globals == NULL || !PyDict_Check(globals) || @@ -678,10 +678,10 @@ PyFrame_BlockPop(PyFrameObject *f) /* Convert between "fast" version of locals and dictionary version */ static void -map_to_dict(PyObject *map, int nmap, PyObject *dict, PyObject **values, - int deref) +map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, + Py_ssize_t deref) { - int j; + Py_ssize_t j; for (j = nmap; --j >= 0; ) { PyObject *key = PyTuple_GET_ITEM(map, j); PyObject *value = values[j]; @@ -699,10 +699,10 @@ map_to_dict(PyObject *map, int nmap, PyObject *dict, PyObject **values, } static void -dict_to_map(PyObject *map, int nmap, PyObject *dict, PyObject **values, - int deref, int clear) +dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values, + Py_ssize_t deref, int clear) { - int j; + Py_ssize_t j; for (j = nmap; --j >= 0; ) { PyObject *key = PyTuple_GET_ITEM(map, j); PyObject *value = PyObject_GetItem(dict, key); @@ -733,7 +733,7 @@ PyFrame_FastToLocals(PyFrameObject *f) PyObject *locals, *map; PyObject **fast; PyObject *error_type, *error_value, *error_traceback; - int j; + Py_ssize_t j; if (f == NULL) return; locals = f->f_locals; @@ -776,7 +776,7 @@ PyFrame_LocalsToFast(PyFrameObject *f, int clear) PyObject *locals, *map; PyObject **fast; PyObject *error_type, *error_value, *error_traceback; - int j; + Py_ssize_t j; if (f == NULL) return; locals = f->f_locals; diff --git a/Objects/funcobject.c b/Objects/funcobject.c index d0e3a25..4abf51a 100644 --- a/Objects/funcobject.c +++ b/Objects/funcobject.c @@ -232,7 +232,7 @@ static int func_set_code(PyFunctionObject *op, PyObject *value) { PyObject *tmp; - int nfree, nclosure; + Py_ssize_t nfree, nclosure; if (restricted()) return -1; @@ -248,8 +248,8 @@ func_set_code(PyFunctionObject *op, PyObject *value) PyTuple_GET_SIZE(op->func_closure)); if (nclosure != nfree) { PyErr_Format(PyExc_ValueError, - "%s() requires a code object with %d free vars," - " not %d", + "%s() requires a code object with %ld free vars," + " not %ld", PyString_AsString(op->func_name), nclosure, nfree); return -1; @@ -363,7 +363,7 @@ func_new(PyTypeObject* type, PyObject* args, PyObject* kw) PyObject *defaults = Py_None; PyObject *closure = Py_None; PyFunctionObject *newfunc; - int nfree, nclosure; + Py_ssize_t nfree, nclosure; static const char *kwlist[] = {"code", "globals", "name", "argdefs", "closure", 0}; @@ -401,11 +401,11 @@ func_new(PyTypeObject* type, PyObject* args, PyObject* kw) nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure); if (nfree != nclosure) return PyErr_Format(PyExc_ValueError, - "%s requires closure of length %d, not %d", + "%s requires closure of length %ld, not %ld", PyString_AS_STRING(code->co_name), nfree, nclosure); if (nclosure) { - int i; + Py_ssize_t i; for (i = 0; i < nclosure; i++) { PyObject *o = PyTuple_GET_ITEM(closure, i); if (!PyCell_Check(o)) { @@ -516,7 +516,7 @@ function_call(PyObject *func, PyObject *arg, PyObject *kw) PyObject *result; PyObject *argdefs; PyObject **d, **k; - int nk, nd; + Py_ssize_t nk, nd; argdefs = PyFunction_GET_DEFAULTS(func); if (argdefs != NULL && PyTuple_Check(argdefs)) { @@ -529,7 +529,7 @@ function_call(PyObject *func, PyObject *arg, PyObject *kw) } if (kw != NULL && PyDict_Check(kw)) { - int pos, i; + Py_ssize_t pos, i; nk = PyDict_Size(kw); k = PyMem_NEW(PyObject *, 2*nk); if (k == NULL) { diff --git a/Objects/intobject.c b/Objects/intobject.c index 5a0b259..d1b9599 100644 --- a/Objects/intobject.c +++ b/Objects/intobject.c @@ -108,6 +108,22 @@ PyInt_FromLong(long ival) return (PyObject *) v; } +PyObject * +PyInt_FromSize_t(size_t ival) +{ + if (ival <= LONG_MAX) + return PyInt_FromLong((long)ival); + return _PyLong_FromSize_t(ival); +} + +PyObject * +PyInt_FromSsize_t(Py_ssize_t ival) +{ + if (ival >= LONG_MIN && ival <= LONG_MAX) + return PyInt_FromLong((long)ival); + return _PyLong_FromSsize_t(ival); +} + static void int_dealloc(PyIntObject *v) { @@ -169,6 +185,59 @@ PyInt_AsLong(register PyObject *op) return val; } +Py_ssize_t +PyInt_AsSsize_t(register PyObject *op) +{ + PyNumberMethods *nb; + PyIntObject *io; + Py_ssize_t val; + if (op && !PyInt_CheckExact(op) && PyLong_Check(op)) + return _PyLong_AsSsize_t(op); +#if SIZEOF_SIZE_T==SIZEOF_LONG + return PyInt_AsLong(op); +#else + + if (op && PyInt_Check(op)) + return PyInt_AS_LONG((PyIntObject*) op); + + if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL || + (nb->nb_int == NULL && nb->nb_long == 0)) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); + return -1; + } + + if (nb->nb_long != 0) { + io = (PyIntObject*) (*nb->nb_long) (op); + } else { + io = (PyIntObject*) (*nb->nb_int) (op); + } + if (io == NULL) + return -1; + if (!PyInt_Check(io)) { + if (PyLong_Check(io)) { + /* got a long? => retry int conversion */ + val = _PyLong_AsSsize_t((PyObject *)io); + Py_DECREF(io); + if ((val == -1) && PyErr_Occurred()) + return -1; + return val; + } + else + { + Py_DECREF(io); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return -1; + } + } + + val = PyInt_AS_LONG(io); + Py_DECREF(io); + + return val; +#endif +} + unsigned long PyInt_AsUnsignedLongMask(register PyObject *op) { @@ -302,7 +371,7 @@ PyInt_FromString(char *s, char **pend, int base) #ifdef Py_USING_UNICODE PyObject * -PyInt_FromUnicode(Py_UNICODE *s, int length, int base) +PyInt_FromUnicode(Py_UNICODE *s, Py_ssize_t length, int base) { PyObject *result; char *buffer = PyMem_MALLOC(length+1); diff --git a/Objects/iterobject.c b/Objects/iterobject.c index 90dc3f0..6f7c57e 100644 --- a/Objects/iterobject.c +++ b/Objects/iterobject.c @@ -74,7 +74,7 @@ iter_iternext(PyObject *iterator) static PyObject * iter_len(seqiterobject *it) { - int seqsize, len; + Py_ssize_t seqsize, len; if (it->it_seq) { seqsize = PySequence_Size(it->it_seq); diff --git a/Objects/listobject.c b/Objects/listobject.c index 8ba317a..41f7390 100644 --- a/Objects/listobject.c +++ b/Objects/listobject.c @@ -22,11 +22,11 @@ * than ob_size on entry. */ static int -list_resize(PyListObject *self, int newsize) +list_resize(PyListObject *self, Py_ssize_t newsize) { PyObject **items; size_t new_allocated; - int allocated = self->allocated; + Py_ssize_t allocated = self->allocated; /* Bypass realloc() when a previous overallocation is large enough to accommodate the newsize. If the newsize falls lower than half @@ -82,7 +82,7 @@ PyList_Fini(void) } PyObject * -PyList_New(int size) +PyList_New(Py_ssize_t size) { PyListObject *op; size_t nbytes; @@ -118,7 +118,7 @@ PyList_New(int size) return (PyObject *) op; } -int +Py_ssize_t PyList_Size(PyObject *op) { if (!PyList_Check(op)) { @@ -132,7 +132,7 @@ PyList_Size(PyObject *op) static PyObject *indexerr = NULL; PyObject * -PyList_GetItem(PyObject *op, int i) +PyList_GetItem(PyObject *op, Py_ssize_t i) { if (!PyList_Check(op)) { PyErr_BadInternalCall(); @@ -149,7 +149,7 @@ PyList_GetItem(PyObject *op, int i) } int -PyList_SetItem(register PyObject *op, register int i, +PyList_SetItem(register PyObject *op, register Py_ssize_t i, register PyObject *newitem) { register PyObject *olditem; @@ -173,9 +173,9 @@ PyList_SetItem(register PyObject *op, register int i, } static int -ins1(PyListObject *self, int where, PyObject *v) +ins1(PyListObject *self, Py_ssize_t where, PyObject *v) { - int i, n = self->ob_size; + Py_ssize_t i, n = self->ob_size; PyObject **items; if (v == NULL) { PyErr_BadInternalCall(); @@ -206,7 +206,7 @@ ins1(PyListObject *self, int where, PyObject *v) } int -PyList_Insert(PyObject *op, int where, PyObject *newitem) +PyList_Insert(PyObject *op, Py_ssize_t where, PyObject *newitem) { if (!PyList_Check(op)) { PyErr_BadInternalCall(); @@ -218,7 +218,7 @@ PyList_Insert(PyObject *op, int where, PyObject *newitem) static int app1(PyListObject *self, PyObject *v) { - int n = PyList_GET_SIZE(self); + Py_ssize_t n = PyList_GET_SIZE(self); assert (v != NULL); if (n == INT_MAX) { @@ -249,7 +249,7 @@ PyList_Append(PyObject *op, PyObject *newitem) static void list_dealloc(PyListObject *op) { - int i; + Py_ssize_t i; PyObject_GC_UnTrack(op); Py_TRASHCAN_SAFE_BEGIN(op) if (op->ob_item != NULL) { @@ -273,12 +273,13 @@ list_dealloc(PyListObject *op) static int list_print(PyListObject *op, FILE *fp, int flags) { - int i; + int rc; + Py_ssize_t i; - i = Py_ReprEnter((PyObject*)op); - if (i != 0) { - if (i < 0) - return i; + rc = Py_ReprEnter((PyObject*)op); + if (rc != 0) { + if (rc < 0) + return rc; fprintf(fp, "[...]"); return 0; } @@ -299,7 +300,7 @@ list_print(PyListObject *op, FILE *fp, int flags) static PyObject * list_repr(PyListObject *v) { - int i; + Py_ssize_t i; PyObject *s, *temp; PyObject *pieces = NULL, *result = NULL; @@ -363,7 +364,7 @@ Done: return result; } -static int +static Py_ssize_t list_length(PyListObject *a) { return a->ob_size; @@ -372,7 +373,8 @@ list_length(PyListObject *a) static int list_contains(PyListObject *a, PyObject *el) { - int i, cmp; + Py_ssize_t i; + int cmp; for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i) cmp = PyObject_RichCompareBool(el, PyList_GET_ITEM(a, i), @@ -381,7 +383,7 @@ list_contains(PyListObject *a, PyObject *el) } static PyObject * -list_item(PyListObject *a, int i) +list_item(PyListObject *a, Py_ssize_t i) { if (i < 0 || i >= a->ob_size) { if (indexerr == NULL) @@ -395,11 +397,11 @@ list_item(PyListObject *a, int i) } static PyObject * -list_slice(PyListObject *a, int ilow, int ihigh) +list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh) { PyListObject *np; PyObject **src, **dest; - int i, len; + Py_ssize_t i, len; if (ilow < 0) ilow = 0; else if (ilow > a->ob_size) @@ -424,7 +426,7 @@ list_slice(PyListObject *a, int ilow, int ihigh) } PyObject * -PyList_GetSlice(PyObject *a, int ilow, int ihigh) +PyList_GetSlice(PyObject *a, Py_ssize_t ilow, Py_ssize_t ihigh) { if (!PyList_Check(a)) { PyErr_BadInternalCall(); @@ -436,8 +438,8 @@ PyList_GetSlice(PyObject *a, int ilow, int ihigh) static PyObject * list_concat(PyListObject *a, PyObject *bb) { - int size; - int i; + Py_ssize_t size; + Py_ssize_t i; PyObject **src, **dest; PyListObject *np; if (!PyList_Check(bb)) { @@ -473,10 +475,10 @@ list_concat(PyListObject *a, PyObject *bb) } static PyObject * -list_repeat(PyListObject *a, int n) +list_repeat(PyListObject *a, Py_ssize_t n) { - int i, j; - int size; + Py_ssize_t i, j; + Py_ssize_t size; PyListObject *np; PyObject **p, **items; PyObject *elem; @@ -515,7 +517,7 @@ list_repeat(PyListObject *a, int n) static int list_clear(PyListObject *a) { - int i; + Py_ssize_t i; PyObject **item = a->ob_item; if (item != NULL) { /* Because XDECREF can recursively invoke operations on @@ -542,7 +544,7 @@ list_clear(PyListObject *a) * guaranteed the call cannot fail. */ static int -list_ass_slice(PyListObject *a, int ilow, int ihigh, PyObject *v) +list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) { /* Because [X]DECREF can recursively invoke list operations on this list, we must postpone all [X]DECREF activity until @@ -555,10 +557,10 @@ list_ass_slice(PyListObject *a, int ilow, int ihigh, PyObject *v) PyObject **item; PyObject **vitem = NULL; PyObject *v_as_SF = NULL; /* PySequence_Fast(v) */ - int n; /* # of elements in replacement list */ - int norig; /* # of elements in list getting replaced */ - int d; /* Change in size */ - int k; + Py_ssize_t n; /* # of elements in replacement list */ + Py_ssize_t norig; /* # of elements in list getting replaced */ + Py_ssize_t d; /* Change in size */ + Py_ssize_t k; size_t s; int result = -1; /* guilty until proved innocent */ #define b ((PyListObject *)v) @@ -640,7 +642,7 @@ list_ass_slice(PyListObject *a, int ilow, int ihigh, PyObject *v) } int -PyList_SetSlice(PyObject *a, int ilow, int ihigh, PyObject *v) +PyList_SetSlice(PyObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) { if (!PyList_Check(a)) { PyErr_BadInternalCall(); @@ -650,10 +652,10 @@ PyList_SetSlice(PyObject *a, int ilow, int ihigh, PyObject *v) } static PyObject * -list_inplace_repeat(PyListObject *self, int n) +list_inplace_repeat(PyListObject *self, Py_ssize_t n) { PyObject **items; - int size, i, j, p; + Py_ssize_t size, i, j, p; size = PyList_GET_SIZE(self); @@ -685,7 +687,7 @@ list_inplace_repeat(PyListObject *self, int n) } static int -list_ass_item(PyListObject *a, int i, PyObject *v) +list_ass_item(PyListObject *a, Py_ssize_t i, PyObject *v) { PyObject *old_value; if (i < 0 || i >= a->ob_size) { @@ -705,9 +707,9 @@ list_ass_item(PyListObject *a, int i, PyObject *v) static PyObject * listinsert(PyListObject *self, PyObject *args) { - int i; + Py_ssize_t i; PyObject *v; - if (!PyArg_ParseTuple(args, "iO:insert", &i, &v)) + if (!PyArg_ParseTuple(args, "nO:insert", &i, &v)) return NULL; if (ins1(self, i, v) == 0) Py_RETURN_NONE; @@ -726,10 +728,10 @@ static PyObject * listextend(PyListObject *self, PyObject *b) { PyObject *it; /* iter(v) */ - int m; /* size of self */ - int n; /* guess for size of b */ - int mn; /* m + n */ - int i; + Py_ssize_t m; /* size of self */ + Py_ssize_t n; /* guess for size of b */ + Py_ssize_t mn; /* m + n */ + Py_ssize_t i; PyObject *(*iternext)(PyObject *); /* Special cases: @@ -858,7 +860,7 @@ list_inplace_concat(PyListObject *self, PyObject *other) static PyObject * listpop(PyListObject *self, PyObject *args) { - int i = -1; + Py_ssize_t i = -1; PyObject *v, *arg = NULL; int status; @@ -866,8 +868,8 @@ listpop(PyListObject *self, PyObject *args) return NULL; if (arg != NULL) { if (PyInt_Check(arg)) - i = (int)(PyInt_AS_LONG((PyIntObject*) arg)); - else if (!PyArg_ParseTuple(args, "|i:pop", &i)) + i = PyInt_AS_LONG((PyIntObject*) arg); + else if (!PyArg_ParseTuple(args, "|n:pop", &i)) return NULL; } if (self->ob_size == 0) { @@ -929,7 +931,7 @@ islt(PyObject *x, PyObject *y, PyObject *compare) { PyObject *res; PyObject *args; - int i; + Py_ssize_t i; assert(compare != NULL); /* Call the user's comparison function and translate the 3-way @@ -988,7 +990,7 @@ static int binarysort(PyObject **lo, PyObject **hi, PyObject **start, PyObject *compare) /* compare -- comparison function object, or NULL for default */ { - register int k; + register Py_ssize_t k; register PyObject **l, **p, **r; register PyObject *pivot; @@ -1050,11 +1052,11 @@ elements to get out of order). Returns -1 in case of error. */ -static int +static Py_ssize_t count_run(PyObject **lo, PyObject **hi, PyObject *compare, int *descending) { - int k; - int n; + Py_ssize_t k; + Py_ssize_t n; assert(lo < hi); *descending = 0; @@ -1105,12 +1107,12 @@ key, and the last n-k should follow key. Returns -1 on error. See listsort.txt for info on the method. */ -static int -gallop_left(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) +static Py_ssize_t +gallop_left(PyObject *key, PyObject **a, Py_ssize_t n, Py_ssize_t hint, PyObject *compare) { - int ofs; - int lastofs; - int k; + Py_ssize_t ofs; + Py_ssize_t lastofs; + Py_ssize_t k; assert(key && a && n > 0 && hint >= 0 && hint < n); @@ -1121,7 +1123,7 @@ gallop_left(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) /* a[hint] < key -- gallop right, until * a[hint + lastofs] < key <= a[hint + ofs] */ - const int maxofs = n - hint; /* &a[n-1] is highest */ + const Py_ssize_t maxofs = n - hint; /* &a[n-1] is highest */ while (ofs < maxofs) { IFLT(a[ofs], key) { lastofs = ofs; @@ -1142,7 +1144,7 @@ gallop_left(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) /* key <= a[hint] -- gallop left, until * a[hint - ofs] < key <= a[hint - lastofs] */ - const int maxofs = hint + 1; /* &a[0] is lowest */ + const Py_ssize_t maxofs = hint + 1; /* &a[0] is lowest */ while (ofs < maxofs) { IFLT(*(a-ofs), key) break; @@ -1168,7 +1170,7 @@ gallop_left(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) */ ++lastofs; while (lastofs < ofs) { - int m = lastofs + ((ofs - lastofs) >> 1); + Py_ssize_t m = lastofs + ((ofs - lastofs) >> 1); IFLT(a[m], key) lastofs = m+1; /* a[m] < key */ @@ -1196,12 +1198,12 @@ The code duplication is massive, but this is enough different given that we're sticking to "<" comparisons that it's much harder to follow if written as one routine with yet another "left or right?" flag. */ -static int -gallop_right(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) +static Py_ssize_t +gallop_right(PyObject *key, PyObject **a, Py_ssize_t n, Py_ssize_t hint, PyObject *compare) { - int ofs; - int lastofs; - int k; + Py_ssize_t ofs; + Py_ssize_t lastofs; + Py_ssize_t k; assert(key && a && n > 0 && hint >= 0 && hint < n); @@ -1212,7 +1214,7 @@ gallop_right(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) /* key < a[hint] -- gallop left, until * a[hint - ofs] <= key < a[hint - lastofs] */ - const int maxofs = hint + 1; /* &a[0] is lowest */ + const Py_ssize_t maxofs = hint + 1; /* &a[0] is lowest */ while (ofs < maxofs) { IFLT(key, *(a-ofs)) { lastofs = ofs; @@ -1234,7 +1236,7 @@ gallop_right(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) /* a[hint] <= key -- gallop right, until * a[hint + lastofs] <= key < a[hint + ofs] */ - const int maxofs = n - hint; /* &a[n-1] is highest */ + const Py_ssize_t maxofs = n - hint; /* &a[n-1] is highest */ while (ofs < maxofs) { IFLT(key, a[ofs]) break; @@ -1259,7 +1261,7 @@ gallop_right(PyObject *key, PyObject **a, int n, int hint, PyObject *compare) */ ++lastofs; while (lastofs < ofs) { - int m = lastofs + ((ofs - lastofs) >> 1); + Py_ssize_t m = lastofs + ((ofs - lastofs) >> 1); IFLT(key, a[m]) ofs = m; /* key < a[m] */ @@ -1294,7 +1296,7 @@ fail: */ struct s_slice { PyObject **base; - int len; + Py_ssize_t len; }; typedef struct s_MergeState { @@ -1305,13 +1307,13 @@ typedef struct s_MergeState { * to MIN_GALLOP. merge_lo and merge_hi tend to nudge it higher for * random data, and lower for highly structured data. */ - int min_gallop; + Py_ssize_t min_gallop; /* 'a' is temp storage to help with merges. It contains room for * alloced entries. */ PyObject **a; /* may point to temparray below */ - int alloced; + Py_ssize_t alloced; /* A stack of n pending runs yet to be merged. Run #i starts at * address base[i] and extends for len[i] elements. It's always @@ -1359,7 +1361,7 @@ merge_freemem(MergeState *ms) * Returns 0 on success and -1 if the memory can't be gotten. */ static int -merge_getmem(MergeState *ms, int need) +merge_getmem(MergeState *ms, Py_ssize_t need) { assert(ms != NULL); if (need <= ms->alloced) @@ -1386,14 +1388,15 @@ merge_getmem(MergeState *ms, int need) * merge, and should have na <= nb. See listsort.txt for more info. * Return 0 if successful, -1 if error. */ -static int -merge_lo(MergeState *ms, PyObject **pa, int na, PyObject **pb, int nb) +static Py_ssize_t +merge_lo(MergeState *ms, PyObject **pa, Py_ssize_t na, + PyObject **pb, Py_ssize_t nb) { - int k; + Py_ssize_t k; PyObject *compare; PyObject **dest; int result = -1; /* guilty until proved innocent */ - int min_gallop = ms->min_gallop; + Py_ssize_t min_gallop = ms->min_gallop; assert(ms && pa && pb && na > 0 && nb > 0 && pa + na == pb); if (MERGE_GETMEM(ms, na) < 0) @@ -1411,8 +1414,8 @@ merge_lo(MergeState *ms, PyObject **pa, int na, PyObject **pb, int nb) compare = ms->compare; for (;;) { - int acount = 0; /* # of times A won in a row */ - int bcount = 0; /* # of times B won in a row */ + Py_ssize_t acount = 0; /* # of times A won in a row */ + Py_ssize_t bcount = 0; /* # of times B won in a row */ /* Do the straightforward thing until (if ever) one run * appears to win consistently. @@ -1517,16 +1520,16 @@ CopyB: * merge, and should have na >= nb. See listsort.txt for more info. * Return 0 if successful, -1 if error. */ -static int -merge_hi(MergeState *ms, PyObject **pa, int na, PyObject **pb, int nb) +static Py_ssize_t +merge_hi(MergeState *ms, PyObject **pa, Py_ssize_t na, PyObject **pb, Py_ssize_t nb) { - int k; + Py_ssize_t k; PyObject *compare; PyObject **dest; int result = -1; /* guilty until proved innocent */ PyObject **basea; PyObject **baseb; - int min_gallop = ms->min_gallop; + Py_ssize_t min_gallop = ms->min_gallop; assert(ms && pa && pb && na > 0 && nb > 0 && pa + na == pb); if (MERGE_GETMEM(ms, nb) < 0) @@ -1547,8 +1550,8 @@ merge_hi(MergeState *ms, PyObject **pa, int na, PyObject **pb, int nb) compare = ms->compare; for (;;) { - int acount = 0; /* # of times A won in a row */ - int bcount = 0; /* # of times B won in a row */ + Py_ssize_t acount = 0; /* # of times A won in a row */ + Py_ssize_t bcount = 0; /* # of times B won in a row */ /* Do the straightforward thing until (if ever) one run * appears to win consistently. @@ -1654,12 +1657,12 @@ CopyA: /* Merge the two runs at stack indices i and i+1. * Returns 0 on success, -1 on error. */ -static int -merge_at(MergeState *ms, int i) +static Py_ssize_t +merge_at(MergeState *ms, Py_ssize_t i) { PyObject **pa, **pb; - int na, nb; - int k; + Py_ssize_t na, nb; + Py_ssize_t k; PyObject *compare; assert(ms != NULL); @@ -1728,7 +1731,7 @@ merge_collapse(MergeState *ms) assert(ms); while (ms->n > 1) { - int n = ms->n - 2; + Py_ssize_t n = ms->n - 2; if (n > 0 && p[n-1].len <= p[n].len + p[n+1].len) { if (p[n-1].len < p[n+1].len) --n; @@ -1757,7 +1760,7 @@ merge_force_collapse(MergeState *ms) assert(ms); while (ms->n > 1) { - int n = ms->n - 2; + Py_ssize_t n = ms->n - 2; if (n > 0 && p[n-1].len < p[n+1].len) --n; if (merge_at(ms, n) < 0) @@ -1776,10 +1779,10 @@ merge_force_collapse(MergeState *ms) * * See listsort.txt for more info. */ -static int -merge_compute_minrun(int n) +static Py_ssize_t +merge_compute_minrun(Py_ssize_t n) { - int r = 0; /* becomes 1 if any 1 bits are shifted off */ + Py_ssize_t r = 0; /* becomes 1 if any 1 bits are shifted off */ assert(n >= 0); while (n >= 64) { @@ -1972,16 +1975,16 @@ listsort(PyListObject *self, PyObject *args, PyObject *kwds) { MergeState ms; PyObject **lo, **hi; - int nremaining; - int minrun; - int saved_ob_size, saved_allocated; + Py_ssize_t nremaining; + Py_ssize_t minrun; + Py_ssize_t saved_ob_size, saved_allocated; PyObject **saved_ob_item; PyObject **final_ob_item; PyObject *compare = NULL; PyObject *result = NULL; /* guilty until proved innocent */ int reverse = 0; PyObject *keyfunc = NULL; - int i; + Py_ssize_t i; PyObject *key, *value, *kvpair; static const char *kwlist[] = {"cmp", "key", "reverse", 0}; @@ -2055,7 +2058,7 @@ listsort(PyListObject *self, PyObject *args, PyObject *kwds) minrun = merge_compute_minrun(nremaining); do { int descending; - int n; + Py_ssize_t n; /* Identify next run. */ n = count_run(lo, hi, compare, &descending); @@ -2065,7 +2068,7 @@ listsort(PyListObject *self, PyObject *args, PyObject *kwds) reverse_slice(lo, lo + n); /* If short, extend to min(minrun, nremaining). */ if (n < minrun) { - const int force = nremaining <= minrun ? + const Py_ssize_t force = nremaining <= minrun ? nremaining : minrun; if (binarysort(lo, lo + force, lo + n, compare) < 0) goto fail; @@ -2177,7 +2180,7 @@ PyList_AsTuple(PyObject *v) { PyObject *w; PyObject **p; - int n; + Py_ssize_t n; if (v == NULL || !PyList_Check(v)) { PyErr_BadInternalCall(); return NULL; @@ -2200,7 +2203,7 @@ PyList_AsTuple(PyObject *v) static PyObject * listindex(PyListObject *self, PyObject *args) { - int i, start=0, stop=self->ob_size; + Py_ssize_t i, start=0, stop=self->ob_size; PyObject *v; if (!PyArg_ParseTuple(args, "O|O&O&:index", &v, @@ -2220,7 +2223,7 @@ listindex(PyListObject *self, PyObject *args) for (i = start; i < stop && i < self->ob_size; i++) { int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ); if (cmp > 0) - return PyInt_FromLong((long)i); + return PyInt_FromSsize_t(i); else if (cmp < 0) return NULL; } @@ -2231,8 +2234,8 @@ listindex(PyListObject *self, PyObject *args) static PyObject * listcount(PyListObject *self, PyObject *v) { - int count = 0; - int i; + Py_ssize_t count = 0; + Py_ssize_t i; for (i = 0; i < self->ob_size; i++) { int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ); @@ -2241,13 +2244,13 @@ listcount(PyListObject *self, PyObject *v) else if (cmp < 0) return NULL; } - return PyInt_FromLong((long)count); + return PyInt_FromSsize_t(count); } static PyObject * listremove(PyListObject *self, PyObject *v) { - int i; + Py_ssize_t i; for (i = 0; i < self->ob_size; i++) { int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ); @@ -2267,13 +2270,13 @@ listremove(PyListObject *self, PyObject *v) static int list_traverse(PyListObject *o, visitproc visit, void *arg) { - int i, err; + Py_ssize_t i; PyObject *x; for (i = o->ob_size; --i >= 0; ) { x = o->ob_item[i]; if (x != NULL) { - err = visit(x, arg); + int err = visit(x, arg); if (err) return err; } @@ -2285,7 +2288,7 @@ static PyObject * list_richcompare(PyObject *v, PyObject *w, int op) { PyListObject *vl, *wl; - int i; + Py_ssize_t i; if (!PyList_Check(v) || !PyList_Check(w)) { Py_INCREF(Py_NotImplemented); @@ -2318,8 +2321,8 @@ list_richcompare(PyObject *v, PyObject *w, int op) if (i >= vl->ob_size || i >= wl->ob_size) { /* No more items to compare -- compare sizes */ - int vs = vl->ob_size; - int ws = wl->ob_size; + Py_ssize_t vs = vl->ob_size; + Py_ssize_t ws = wl->ob_size; int cmp; PyObject *res; switch (op) { @@ -2433,16 +2436,16 @@ static PyMethodDef list_methods[] = { }; static PySequenceMethods list_as_sequence = { - (inquiry)list_length, /* sq_length */ + (lenfunc)list_length, /* sq_length */ (binaryfunc)list_concat, /* sq_concat */ - (intargfunc)list_repeat, /* sq_repeat */ - (intargfunc)list_item, /* sq_item */ - (intintargfunc)list_slice, /* sq_slice */ - (intobjargproc)list_ass_item, /* sq_ass_item */ - (intintobjargproc)list_ass_slice, /* sq_ass_slice */ + (ssizeargfunc)list_repeat, /* sq_repeat */ + (ssizeargfunc)list_item, /* sq_item */ + (ssizessizeargfunc)list_slice, /* sq_slice */ + (ssizeobjargproc)list_ass_item, /* sq_ass_item */ + (ssizessizeobjargproc)list_ass_slice, /* sq_ass_slice */ (objobjproc)list_contains, /* sq_contains */ (binaryfunc)list_inplace_concat, /* sq_inplace_concat */ - (intargfunc)list_inplace_repeat, /* sq_inplace_repeat */ + (ssizeargfunc)list_inplace_repeat, /* sq_inplace_repeat */ }; PyDoc_STRVAR(list_doc, @@ -2452,14 +2455,8 @@ PyDoc_STRVAR(list_doc, static PyObject * list_subscript(PyListObject* self, PyObject* item) { - if (PyInt_Check(item)) { - long i = PyInt_AS_LONG(item); - if (i < 0) - i += PyList_GET_SIZE(self); - return list_item(self, i); - } - else if (PyLong_Check(item)) { - long i = PyLong_AsLong(item); + if (PyInt_Check(item) || PyLong_Check(item)) { + Py_ssize_t i = PyInt_AsSsize_t(item); if (i == -1 && PyErr_Occurred()) return NULL; if (i < 0) @@ -2467,7 +2464,7 @@ list_subscript(PyListObject* self, PyObject* item) return list_item(self, i); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength, cur, i; + Py_ssize_t start, stop, step, slicelength, cur, i; PyObject* result; PyObject* it; PyObject **src, **dest; @@ -2521,7 +2518,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) return list_ass_item(self, i, value); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength; + Py_ssize_t start, stop, step, slicelength; if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size, &start, &stop, &step, &slicelength) < 0) { @@ -2535,7 +2532,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) if (value == NULL) { /* delete slice */ PyObject **garbage; - int cur, i; + Py_ssize_t cur, i; if (slicelength <= 0) return 0; @@ -2554,7 +2551,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) for (cur = start, i = 0; cur < stop; cur += step, i++) { - int lim = step; + Py_ssize_t lim = step; garbage[i] = PyList_GET_ITEM(self, cur); @@ -2586,7 +2583,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) else { /* assign slice */ PyObject **garbage, *ins, *seq, **seqitems, **selfitems; - int cur, i; + Py_ssize_t cur, i; /* protect against a[::-1] = a */ if (self == (PyListObject*)value) { @@ -2601,8 +2598,9 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) } if (PySequence_Fast_GET_SIZE(seq) != slicelength) { + /* XXX can we use %zd here? */ PyErr_Format(PyExc_ValueError, - "attempt to assign sequence of size %d to extended slice of size %d", + "attempt to assign sequence of size %ld to extended slice of size %ld", PySequence_Fast_GET_SIZE(seq), slicelength); Py_DECREF(seq); @@ -2645,7 +2643,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) } static PyMappingMethods list_as_mapping = { - (inquiry)list_length, + (lenfunc)list_length, (binaryfunc)list_subscript, (objobjargproc)list_ass_subscript }; @@ -2767,11 +2765,11 @@ listiter_next(listiterobject *it) static PyObject * listiter_len(listiterobject *it) { - int len; + Py_ssize_t len; if (it->it_seq) { len = PyList_GET_SIZE(it->it_seq) - it->it_index; if (len >= 0) - return PyInt_FromLong((long)len); + return PyInt_FromSsize_t(len); } return PyInt_FromLong(0); } @@ -2880,17 +2878,17 @@ listreviter_next(listreviterobject *it) return NULL; } -static int +static Py_ssize_t listreviter_len(listreviterobject *it) { - int len = it->it_index + 1; + Py_ssize_t len = it->it_index + 1; if (it->it_seq == NULL || PyList_GET_SIZE(it->it_seq) < len) return 0; return len; } static PySequenceMethods listreviter_as_sequence = { - (inquiry)listreviter_len, /* sq_length */ + (lenfunc)listreviter_len, /* sq_length */ 0, /* sq_concat */ }; diff --git a/Objects/longobject.c b/Objects/longobject.c index 32f7958..17aab35 100644 --- a/Objects/longobject.c +++ b/Objects/longobject.c @@ -50,8 +50,8 @@ static PyObject *long_format(PyObject *aa, int base, int addL); static PyLongObject * long_normalize(register PyLongObject *v) { - int j = ABS(v->ob_size); - register int i = j; + Py_ssize_t j = ABS(v->ob_size); + Py_ssize_t i = j; while (i > 0 && v->ob_digit[i-1] == 0) --i; @@ -64,8 +64,13 @@ long_normalize(register PyLongObject *v) Return NULL and set exception if we run out of memory. */ PyLongObject * -_PyLong_New(int size) +_PyLong_New(Py_ssize_t size) { + if (size > INT_MAX) { + /* XXX: Fix this check when ob_size becomes ssize_t */ + PyErr_NoMemory(); + return NULL; + } return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size); } @@ -73,7 +78,7 @@ PyObject * _PyLong_Copy(PyLongObject *src) { PyLongObject *result; - int i; + Py_ssize_t i; assert(src != NULL); i = src->ob_size; @@ -198,7 +203,8 @@ PyLong_AsLong(PyObject *vv) /* This version by Tim Peters */ register PyLongObject *v; unsigned long x, prev; - int i, sign; + Py_ssize_t i; + int sign; if (vv == NULL || !PyLong_Check(vv)) { if (vv != NULL && PyInt_Check(vv)) @@ -235,6 +241,50 @@ PyLong_AsLong(PyObject *vv) return -1; } +/* Get a Py_ssize_t from a long int object. + Returns -1 and sets an error condition if overflow occurs. */ + +Py_ssize_t +_PyLong_AsSsize_t(PyObject *vv) +{ + register PyLongObject *v; + size_t x, prev; + Py_ssize_t i; + int sign; + + if (vv == NULL || !PyLong_Check(vv)) { + PyErr_BadInternalCall(); + return -1; + } + v = (PyLongObject *)vv; + i = v->ob_size; + sign = 1; + x = 0; + if (i < 0) { + sign = -1; + i = -(i); + } + while (--i >= 0) { + prev = x; + x = (x << SHIFT) + v->ob_digit[i]; + if ((x >> SHIFT) != prev) + goto overflow; + } + /* Haven't lost any bits, but if the sign bit is set we're in + * trouble *unless* this is the min negative number. So, + * trouble iff sign bit set && (positive || some bit set other + * than the sign bit). + */ + if ((Py_ssize_t)x < 0 && (sign > 0 || (x << 1) != 0)) + goto overflow; + return (Py_ssize_t)x * sign; + + overflow: + PyErr_SetString(PyExc_OverflowError, + "long int too large to convert to int"); + return -1; +} + /* Get a C unsigned long int from a long int object. Returns -1 and sets an error condition if overflow occurs. */ @@ -243,7 +293,7 @@ PyLong_AsUnsignedLong(PyObject *vv) { register PyLongObject *v; unsigned long x, prev; - int i; + Py_ssize_t i; if (vv == NULL || !PyLong_Check(vv)) { if (vv != NULL && PyInt_Check(vv)) { @@ -286,7 +336,8 @@ PyLong_AsUnsignedLongMask(PyObject *vv) { register PyLongObject *v; unsigned long x; - int i, sign; + Py_ssize_t i; + int sign; if (vv == NULL || !PyLong_Check(vv)) { if (vv != NULL && PyInt_Check(vv)) @@ -324,7 +375,7 @@ _PyLong_NumBits(PyObject *vv) { PyLongObject *v = (PyLongObject *)vv; size_t result = 0; - int ndigits; + Py_ssize_t ndigits; assert(v != NULL); assert(PyLong_Check(v)); @@ -334,7 +385,7 @@ _PyLong_NumBits(PyObject *vv) digit msd = v->ob_digit[ndigits - 1]; result = (ndigits - 1) * SHIFT; - if (result / SHIFT != (size_t)ndigits - 1) + if (result / SHIFT != ndigits - 1) goto Overflow; do { ++result; @@ -464,7 +515,7 @@ _PyLong_AsByteArray(PyLongObject* v, int little_endian, int is_signed) { int i; /* index into v->ob_digit */ - int ndigits; /* |v->ob_size| */ + Py_ssize_t ndigits; /* |v->ob_size| */ twodigits accum; /* sliding register */ unsigned int accumbits; /* # bits in accum */ int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */ @@ -612,7 +663,8 @@ _PyLong_AsScaledDouble(PyObject *vv, int *exponent) PyLongObject *v; double x; const double multiplier = (double)(1L << SHIFT); - int i, sign; + Py_ssize_t i; + int sign; int nbitsneeded; if (vv == NULL || !PyLong_Check(vv)) { @@ -772,6 +824,30 @@ PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival) SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0); } +/* Create a new long int object from a C Py_ssize_t. */ + +PyObject * +_PyLong_FromSsize_t(Py_ssize_t ival) +{ + Py_ssize_t bytes = ival; + int one = 1; + return _PyLong_FromByteArray( + (unsigned char *)&bytes, + SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0); +} + +/* Create a new long int object from a C size_t. */ + +PyObject * +_PyLong_FromSize_t(size_t ival) +{ + size_t bytes = ival; + int one = 1; + return _PyLong_FromByteArray( + (unsigned char *)&bytes, + SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0); +} + /* Get a C PY_LONG_LONG int from a long int object. Return -1 and set an error if overflow occurs. */ @@ -859,7 +935,8 @@ PyLong_AsUnsignedLongLongMask(PyObject *vv) { register PyLongObject *v; unsigned PY_LONG_LONG x; - int i, sign; + Py_ssize_t i; + int sign; if (vv == NULL || !PyLong_Check(vv)) { PyErr_BadInternalCall(); @@ -920,7 +997,7 @@ convert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) { * x[m-1], and the remaining carry (0 or 1) is returned. */ static digit -v_iadd(digit *x, int m, digit *y, int n) +v_iadd(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) { int i; digit carry = 0; @@ -946,7 +1023,7 @@ v_iadd(digit *x, int m, digit *y, int n) * far as x[m-1], and the remaining borrow (0 or 1) is returned. */ static digit -v_isub(digit *x, int m, digit *y, int n) +v_isub(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) { int i; digit borrow = 0; @@ -980,10 +1057,10 @@ mul1(PyLongObject *a, wdigit n) static PyLongObject * muladd1(PyLongObject *a, wdigit n, wdigit extra) { - int size_a = ABS(a->ob_size); + Py_ssize_t size_a = ABS(a->ob_size); PyLongObject *z = _PyLong_New(size_a+1); twodigits carry = extra; - int i; + Py_ssize_t i; if (z == NULL) return NULL; @@ -1003,7 +1080,7 @@ muladd1(PyLongObject *a, wdigit n, wdigit extra) immutable. */ static digit -inplace_divrem1(digit *pout, digit *pin, int size, digit n) +inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n) { twodigits rem = 0; @@ -1026,7 +1103,7 @@ inplace_divrem1(digit *pout, digit *pin, int size, digit n) static PyLongObject * divrem1(PyLongObject *a, digit n, digit *prem) { - const int size = ABS(a->ob_size); + const Py_ssize_t size = ABS(a->ob_size); PyLongObject *z; assert(n > 0 && n <= MASK); @@ -1046,8 +1123,8 @@ long_format(PyObject *aa, int base, int addL) { register PyLongObject *a = (PyLongObject *)aa; PyStringObject *str; - int i; - const int size_a = ABS(a->ob_size); + Py_ssize_t i; + const Py_ssize_t size_a = ABS(a->ob_size); char *p; int bits; char sign = '\0'; @@ -1107,7 +1184,7 @@ long_format(PyObject *aa, int base, int addL) /* Not 0, and base not a power of 2. Divide repeatedly by base, but for speed use the highest power of base that fits in a digit. */ - int size = size_a; + Py_ssize_t size = size_a; digit *pin = a->ob_digit; PyLongObject *scratch; /* powbasw <- largest power of base that fits in a digit. */ @@ -1200,7 +1277,7 @@ long_from_binary_base(char **str, int base) char *p = *str; char *start = p; int bits_per_char; - int n; + Py_ssize_t n; PyLongObject *z; twodigits accum; int bits_in_accum; @@ -1261,7 +1338,7 @@ long_from_binary_base(char **str, int base) bits_in_accum += bits_per_char; if (bits_in_accum >= SHIFT) { *pdigit++ = (digit)(accum & MASK); - assert(pdigit - z->ob_digit <= n); + assert(pdigit - z->ob_digit <= (int)n); accum >>= SHIFT; bits_in_accum -= SHIFT; assert(bits_in_accum < SHIFT); @@ -1270,7 +1347,7 @@ long_from_binary_base(char **str, int base) if (bits_in_accum) { assert(bits_in_accum <= SHIFT); *pdigit++ = (digit)accum; - assert(pdigit - z->ob_digit <= n); + assert(pdigit - z->ob_digit <= (int)n); } while (pdigit - z->ob_digit < n) *pdigit++ = 0; @@ -1356,7 +1433,7 @@ PyLong_FromString(char *str, char **pend, int base) #ifdef Py_USING_UNICODE PyObject * -PyLong_FromUnicode(Py_UNICODE *u, int length, int base) +PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base) { PyObject *result; char *buffer = PyMem_MALLOC(length+1); @@ -1387,7 +1464,7 @@ static int long_divrem(PyLongObject *a, PyLongObject *b, PyLongObject **pdiv, PyLongObject **prem) { - int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size); + Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size); PyLongObject *z; if (size_b == 0) { @@ -1433,12 +1510,12 @@ long_divrem(PyLongObject *a, PyLongObject *b, static PyLongObject * x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem) { - int size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size); + Py_ssize_t size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size); digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1)); PyLongObject *v = mul1(v1, d); PyLongObject *w = mul1(w1, d); PyLongObject *a; - int j, k; + Py_ssize_t j, k; if (v == NULL || w == NULL) { Py_XDECREF(v); @@ -1550,7 +1627,7 @@ long_str(PyObject *v) static int long_compare(PyLongObject *a, PyLongObject *b) { - int sign; + Py_ssize_t sign; if (a->ob_size != b->ob_size) { if (ABS(a->ob_size) == 0 && ABS(b->ob_size) == 0) @@ -1559,7 +1636,7 @@ long_compare(PyLongObject *a, PyLongObject *b) sign = a->ob_size - b->ob_size; } else { - int i = ABS(a->ob_size); + Py_ssize_t i = ABS(a->ob_size); while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) ; if (i < 0) @@ -1577,7 +1654,8 @@ static long long_hash(PyLongObject *v) { long x; - int i, sign; + Py_ssize_t i; + int sign; /* This is designed so that Python ints and longs with the same value hash to the same value, otherwise comparisons @@ -1608,7 +1686,7 @@ long_hash(PyLongObject *v) static PyLongObject * x_add(PyLongObject *a, PyLongObject *b) { - int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size); + Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size); PyLongObject *z; int i; digit carry = 0; @@ -1616,7 +1694,7 @@ x_add(PyLongObject *a, PyLongObject *b) /* Ensure a is the larger of the two: */ if (size_a < size_b) { { PyLongObject *temp = a; a = b; b = temp; } - { int size_temp = size_a; + { Py_ssize_t size_temp = size_a; size_a = size_b; size_b = size_temp; } } @@ -1642,9 +1720,9 @@ x_add(PyLongObject *a, PyLongObject *b) static PyLongObject * x_sub(PyLongObject *a, PyLongObject *b) { - int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size); + Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size); PyLongObject *z; - int i; + Py_ssize_t i; int sign = 1; digit borrow = 0; @@ -1652,7 +1730,7 @@ x_sub(PyLongObject *a, PyLongObject *b) if (size_a < size_b) { sign = -1; { PyLongObject *temp = a; a = b; b = temp; } - { int size_temp = size_a; + { Py_ssize_t size_temp = size_a; size_a = size_b; size_b = size_temp; } } @@ -1752,9 +1830,9 @@ static PyLongObject * x_mul(PyLongObject *a, PyLongObject *b) { PyLongObject *z; - int size_a = ABS(a->ob_size); - int size_b = ABS(b->ob_size); - int i; + Py_ssize_t size_a = ABS(a->ob_size); + Py_ssize_t size_b = ABS(b->ob_size); + Py_ssize_t i; z = _PyLong_New(size_a + size_b); if (z == NULL) @@ -1840,11 +1918,11 @@ x_mul(PyLongObject *a, PyLongObject *b) Returns 0 on success, -1 on failure. */ static int -kmul_split(PyLongObject *n, int size, PyLongObject **high, PyLongObject **low) +kmul_split(PyLongObject *n, Py_ssize_t size, PyLongObject **high, PyLongObject **low) { PyLongObject *hi, *lo; - int size_lo, size_hi; - const int size_n = ABS(n->ob_size); + Py_ssize_t size_lo, size_hi; + const Py_ssize_t size_n = ABS(n->ob_size); size_lo = MIN(size_n, size); size_hi = size_n - size_lo; @@ -1873,16 +1951,16 @@ static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b); static PyLongObject * k_mul(PyLongObject *a, PyLongObject *b) { - int asize = ABS(a->ob_size); - int bsize = ABS(b->ob_size); + Py_ssize_t asize = ABS(a->ob_size); + Py_ssize_t bsize = ABS(b->ob_size); PyLongObject *ah = NULL; PyLongObject *al = NULL; PyLongObject *bh = NULL; PyLongObject *bl = NULL; PyLongObject *ret = NULL; PyLongObject *t1, *t2, *t3; - int shift; /* the number of digits we split off */ - int i; + Py_ssize_t shift; /* the number of digits we split off */ + Py_ssize_t i; /* (ah*X+al)(bh*X+bl) = ah*bh*X*X + (ah*bl + al*bh)*X + al*bl * Let k = (ah+al)*(bh+bl) = ah*bl + al*bh + ah*bh + al*bl @@ -2094,9 +2172,9 @@ ah*bh and al*bl too. static PyLongObject * k_lopsided_mul(PyLongObject *a, PyLongObject *b) { - const int asize = ABS(a->ob_size); - int bsize = ABS(b->ob_size); - int nbdone; /* # of b digits already multiplied */ + const Py_ssize_t asize = ABS(a->ob_size); + Py_ssize_t bsize = ABS(b->ob_size); + Py_ssize_t nbdone; /* # of b digits already multiplied */ PyLongObject *ret; PyLongObject *bslice = NULL; @@ -2117,7 +2195,7 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b) nbdone = 0; while (bsize > 0) { PyLongObject *product; - const int nbtouse = MIN(bsize, asize); + const Py_ssize_t nbtouse = MIN(bsize, asize); /* Multiply the next slice of b by a. */ memcpy(bslice->ob_digit, b->ob_digit + nbdone, @@ -2353,7 +2431,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x) int negativeOutput = 0; /* if x<0 return negative output */ PyLongObject *z = NULL; /* accumulated result */ - int i, j, k; /* counters */ + Py_ssize_t i, j, k; /* counters */ PyLongObject *temp = NULL; /* 5-ary values. If the exponent is large enough, table is @@ -2597,7 +2675,7 @@ long_rshift(PyLongObject *v, PyLongObject *w) PyLongObject *a, *b; PyLongObject *z = NULL; long shiftby; - int newsize, wordshift, loshift, hishift, i, j; + Py_ssize_t newsize, wordshift, loshift, hishift, i, j; digit lomask, himask; CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); @@ -2664,7 +2742,7 @@ long_lshift(PyObject *v, PyObject *w) PyLongObject *a, *b; PyLongObject *z = NULL; long shiftby; - int oldsize, newsize, wordshift, remshift, i, j; + Py_ssize_t oldsize, newsize, wordshift, remshift, i, j; twodigits accum; CONVERT_BINOP(v, w, &a, &b); @@ -2723,7 +2801,7 @@ long_bitwise(PyLongObject *a, { digit maska, maskb; /* 0 or MASK */ int negz; - int size_a, size_b, size_z; + Py_ssize_t size_a, size_b, size_z; PyLongObject *z; int i; digit diga, digb; @@ -2965,7 +3043,7 @@ static PyObject * long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyLongObject *tmp, *new; - int i, n; + Py_ssize_t i, n; assert(PyType_IsSubtype(type, &PyLong_Type)); tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds); diff --git a/Objects/methodobject.c b/Objects/methodobject.c index 3a205f5..5e920a2 100644 --- a/Objects/methodobject.c +++ b/Objects/methodobject.c @@ -65,7 +65,7 @@ PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); - int size; + long size; switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) { case METH_VARARGS: @@ -81,7 +81,7 @@ PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) if (size == 0) return (*meth)(self, NULL); PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%d given)", + "%.200s() takes no arguments (%ld given)", f->m_ml->ml_name, size); return NULL; } @@ -92,7 +92,7 @@ PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) if (size == 1) return (*meth)(self, PyTuple_GET_ITEM(arg, 0)); PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%d given)", + "%.200s() takes exactly one argument (%ld given)", f->m_ml->ml_name, size); return NULL; } diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c index 76a4ab3..dfcf39c 100644 --- a/Objects/moduleobject.c +++ b/Objects/moduleobject.c @@ -104,7 +104,7 @@ _PyModule_Clear(PyObject *m) None, rather than deleting them from the dictionary, to avoid rehashing the dictionary (to some extent). */ - int pos; + Py_ssize_t pos; PyObject *key, *value; PyObject *d; diff --git a/Objects/object.c b/Objects/object.c index 6d6d078..2a1f45a 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -170,7 +170,7 @@ PyObject_Init(PyObject *op, PyTypeObject *tp) } PyVarObject * -PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, int size) +PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size) { if (op == NULL) return (PyVarObject *) PyErr_NoMemory(); @@ -192,7 +192,7 @@ _PyObject_New(PyTypeObject *tp) } PyVarObject * -_PyObject_NewVar(PyTypeObject *tp, int nitems) +_PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems) { PyVarObject *op; const size_t size = _PyObject_VAR_SIZE(tp, nitems); @@ -1175,7 +1175,7 @@ _PyObject_GetDictPtr(PyObject *obj) if (dictoffset == 0) return NULL; if (dictoffset < 0) { - int tsize; + Py_ssize_t tsize; size_t size; tsize = ((PyVarObject *)obj)->ob_size; @@ -1237,7 +1237,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name) /* Inline _PyType_Lookup */ { - int i, n; + Py_ssize_t i, n; PyObject *mro, *base, *dict; /* Look in tp_dict of types in MRO */ @@ -1278,7 +1278,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name) if (dictoffset != 0) { PyObject *dict; if (dictoffset < 0) { - int tsize; + Py_ssize_t tsize; size_t size; tsize = ((PyVarObject *)obj)->ob_size; @@ -1414,7 +1414,7 @@ PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value) int PyObject_IsTrue(PyObject *v) { - int res; + Py_ssize_t res; if (v == Py_True) return 1; if (v == Py_False) @@ -1432,7 +1432,8 @@ PyObject_IsTrue(PyObject *v) res = (*v->ob_type->tp_as_sequence->sq_length)(v); else return 1; - return (res > 0) ? 1 : res; + /* if it is negative, it should be either -1 or -2 */ + return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int); } /* equivalent of 'not v' @@ -1556,7 +1557,7 @@ merge_class_dict(PyObject* dict, PyObject* aclass) PyErr_Clear(); else { /* We have no guarantee that bases is a real tuple */ - int i, n; + Py_ssize_t i, n; n = PySequence_Size(bases); /* This better be right */ if (n < 0) PyErr_Clear(); @@ -1949,7 +1950,7 @@ PyTypeObject *_Py_cobject_hack = &PyCObject_Type; /* Hack to force loading of abstract.o */ -int (*_Py_abstract_hack)(PyObject *) = PyObject_Size; +Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size; /* Python's malloc wrappers (see pymem.h) */ @@ -1992,7 +1993,7 @@ Py_ReprEnter(PyObject *obj) { PyObject *dict; PyObject *list; - int i; + Py_ssize_t i; dict = PyThreadState_GetDict(); if (dict == NULL) @@ -2020,7 +2021,7 @@ Py_ReprLeave(PyObject *obj) { PyObject *dict; PyObject *list; - int i; + Py_ssize_t i; dict = PyThreadState_GetDict(); if (dict == NULL) diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c index 266b4c6..090abda 100644 --- a/Objects/obmalloc.c +++ b/Objects/obmalloc.c @@ -541,8 +541,8 @@ error: /* This is only useful when running memory debuggers such as * Purify or Valgrind. Uncomment to use. * -#define Py_USING_MEMORY_DEBUGGER */ +#define Py_USING_MEMORY_DEBUGGER #ifdef Py_USING_MEMORY_DEBUGGER @@ -816,7 +816,7 @@ PyObject_Realloc(void *p, size_t nbytes) { void *bp; poolp pool; - uint size; + size_t size; if (p == NULL) return PyObject_Malloc(nbytes); @@ -1005,6 +1005,8 @@ _PyObject_DebugMalloc(size_t nbytes) bumpserialno(); total = nbytes + 16; +#if SIZEOF_SIZE_T < 8 + /* XXX do this check only on 32-bit machines */ if (total < nbytes || (total >> 31) > 1) { /* overflow, or we can't represent it in 4 bytes */ /* Obscure: can't do (total >> 32) != 0 instead, because @@ -1013,12 +1015,13 @@ _PyObject_DebugMalloc(size_t nbytes) size_t is an unsigned type. */ return NULL; } +#endif p = (uchar *)PyObject_Malloc(total); if (p == NULL) return NULL; - write4(p, nbytes); + write4(p, (ulong)nbytes); p[4] = p[5] = p[6] = p[7] = FORBIDDENBYTE; if (nbytes > 0) @@ -1081,7 +1084,7 @@ _PyObject_DebugRealloc(void *p, size_t nbytes) if (q == NULL) return NULL; - write4(q, nbytes); + write4(q, (ulong)nbytes); assert(q[4] == FORBIDDENBYTE && q[5] == FORBIDDENBYTE && q[6] == FORBIDDENBYTE && diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c index cfd9100..a9c0b55 100644 --- a/Objects/rangeobject.c +++ b/Objects/rangeobject.c @@ -91,27 +91,27 @@ generates the numbers in the range on demand. For looping, this is \n\ slightly faster than range() and more memory efficient."); static PyObject * -range_item(rangeobject *r, int i) +range_item(rangeobject *r, Py_ssize_t i) { if (i < 0 || i >= r->len) { PyErr_SetString(PyExc_IndexError, "xrange object index out of range"); return NULL; } - return PyInt_FromLong(r->start + (i % r->len) * r->step); + return PyInt_FromSsize_t(r->start + (i % r->len) * r->step); } -static int +static Py_ssize_t range_length(rangeobject *r) { -#if LONG_MAX != INT_MAX +#if LONG_MAX != INT_MAX /* XXX ssize_t_max */ if (r->len > INT_MAX) { PyErr_SetString(PyExc_ValueError, "xrange object size cannot be reported"); return -1; } #endif - return (int)(r->len); + return (Py_ssize_t)(r->len); } static PyObject * @@ -137,10 +137,10 @@ range_repr(rangeobject *r) } static PySequenceMethods range_as_sequence = { - (inquiry)range_length, /* sq_length */ + (lenfunc)range_length, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ - (intargfunc)range_item, /* sq_item */ + (ssizeargfunc)range_item, /* sq_item */ 0, /* sq_slice */ }; diff --git a/Objects/setobject.c b/Objects/setobject.c index baa2d01..0041a10 100644 --- a/Objects/setobject.c +++ b/Objects/setobject.c @@ -51,8 +51,8 @@ NULL if the rich comparison returns an error. static setentry * set_lookkey(PySetObject *so, PyObject *key, register long hash) { - register int i; - register unsigned int perturb; + register Py_ssize_t i; + register size_t perturb; register setentry *freeslot; register unsigned int mask = so->mask; setentry *table = so->table; @@ -129,8 +129,8 @@ set_lookkey(PySetObject *so, PyObject *key, register long hash) static setentry * set_lookkey_string(PySetObject *so, PyObject *key, register long hash) { - register int i; - register unsigned int perturb; + register Py_ssize_t i; + register size_t perturb; register setentry *freeslot; register unsigned int mask = so->mask; setentry *table = so->table; @@ -468,9 +468,10 @@ set_clear_internal(PySetObject *so) * mutates the table. */ static int -set_next(PySetObject *so, int *pos_ptr, setentry **entry_ptr) +set_next(PySetObject *so, Py_ssize_t *pos_ptr, setentry **entry_ptr) { - register int i, mask; + Py_ssize_t i; + int mask; register setentry *table; assert (PyAnySet_Check(so)); @@ -517,7 +518,7 @@ static int set_tp_print(PySetObject *so, FILE *fp, int flags) { setentry *entry; - int pos=0; + Py_ssize_t pos=0; char *emit = ""; /* No separator emitted on first pass */ char *separator = ", "; @@ -551,7 +552,7 @@ set_repr(PySetObject *so) return result; } -static int +static Py_ssize_t set_len(PyObject *so) { return ((PySetObject *)so)->used; @@ -673,7 +674,7 @@ PyDoc_STRVAR(pop_doc, "Remove and return an arbitrary set element."); static int set_traverse(PySetObject *so, visitproc visit, void *arg) { - int pos = 0; + Py_ssize_t pos = 0; setentry *entry; while (set_next(so, &pos, &entry)) @@ -687,7 +688,7 @@ frozenset_hash(PyObject *self) PySetObject *so = (PySetObject *)self; long h, hash = 1927868237L; setentry *entry; - int pos = 0; + Py_ssize_t pos = 0; if (so->hash != -1) return so->hash; @@ -752,7 +753,7 @@ setiter_dealloc(setiterobject *si) static PyObject * setiter_len(setiterobject *si) { - int len = 0; + long len = 0; if (si->si_set != NULL && si->si_used == si->si_set->used) len = si->len; return PyInt_FromLong(len); @@ -847,7 +848,7 @@ set_update_internal(PySetObject *so, PyObject *other) if (PyDict_Check(other)) { PyObject *value; - int pos = 0; + Py_ssize_t pos = 0; while (PyDict_Next(other, &pos, &key, &value)) { if (set_add_key(so, key) == -1) return -1; @@ -1121,7 +1122,7 @@ set_intersection(PySetObject *so, PyObject *other) return NULL; if (PyAnySet_Check(other)) { - int pos = 0; + Py_ssize_t pos = 0; setentry *entry; if (PySet_GET_SIZE(other) > PySet_GET_SIZE(so)) { @@ -1222,7 +1223,7 @@ set_difference_update_internal(PySetObject *so, PyObject *other) if (PyAnySet_Check(other)) { setentry *entry; - int pos = 0; + Py_ssize_t pos = 0; while (set_next((PySetObject *)other, &pos, &entry)) set_discard_entry(so, entry); @@ -1266,7 +1267,7 @@ set_difference(PySetObject *so, PyObject *other) { PyObject *result; setentry *entry; - int pos = 0; + Py_ssize_t pos = 0; if (!PyAnySet_Check(other) && !PyDict_Check(other)) { result = set_copy(so); @@ -1340,7 +1341,7 @@ set_symmetric_difference_update(PySetObject *so, PyObject *other) { PySetObject *otherset; PyObject *key; - int pos = 0; + Py_ssize_t pos = 0; setentry *entry; if ((PyObject *)so == other) @@ -1442,7 +1443,7 @@ static PyObject * set_issubset(PySetObject *so, PyObject *other) { setentry *entry; - int pos = 0; + Py_ssize_t pos = 0; if (!PyAnySet_Check(other)) { PyObject *tmp, *result; @@ -1687,7 +1688,7 @@ set_init(PySetObject *self, PyObject *args, PyObject *kwds) } static PySequenceMethods set_as_sequence = { - (inquiry)set_len, /* sq_length */ + (lenfunc)set_len, /* sq_length */ 0, /* sq_concat */ 0, /* sq_repeat */ 0, /* sq_item */ diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c index f5ed898..3b37dbb 100644 --- a/Objects/sliceobject.c +++ b/Objects/sliceobject.c @@ -80,9 +80,10 @@ PySlice_New(PyObject *start, PyObject *stop, PyObject *step) } int -PySlice_GetIndices(PySliceObject *r, int length, - int *start, int *stop, int *step) +PySlice_GetIndices(PySliceObject *r, Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step) { + /* XXX support long ints */ if (r->step == Py_None) { *step = 1; } else { @@ -110,12 +111,12 @@ PySlice_GetIndices(PySliceObject *r, int length, } int -PySlice_GetIndicesEx(PySliceObject *r, int length, - int *start, int *stop, int *step, int *slicelength) +PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length, + Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength) { /* this is harder to get right than you might think */ - int defstart, defstop; + Py_ssize_t defstart, defstop; if (r->step == Py_None) { *step = 1; @@ -230,7 +231,7 @@ static PyMemberDef slice_members[] = { static PyObject* slice_indices(PySliceObject* self, PyObject* len) { - int ilen, start, stop, step, slicelength; + Py_ssize_t ilen, start, stop, step, slicelength; ilen = PyInt_AsLong(len); diff --git a/Objects/stringobject.c b/Objects/stringobject.c index 7c3ab09..a8e1cb6 100644 --- a/Objects/stringobject.c +++ b/Objects/stringobject.c @@ -49,7 +49,7 @@ static PyObject *interned; parameter (for PyString_FromString()). */ PyObject * -PyString_FromStringAndSize(const char *str, int size) +PyString_FromStringAndSize(const char *str, Py_ssize_t size) { register PyStringObject *op; assert(size >= 0); @@ -154,7 +154,7 @@ PyObject * PyString_FromFormatV(const char *format, va_list vargs) { va_list count; - int n = 0; + Py_ssize_t n = 0; const char* f; char *s; PyObject* string; @@ -235,7 +235,8 @@ PyString_FromFormatV(const char *format, va_list vargs) for (f = format; *f; f++) { if (*f == '%') { const char* p = f++; - int i, longflag = 0; + Py_ssize_t i; + int longflag = 0; /* parse the width.precision part (we're only interested in the precision value, if any) */ n = 0; @@ -330,7 +331,7 @@ PyString_FromFormat(const char *format, ...) PyObject *PyString_Decode(const char *s, - int size, + Py_ssize_t size, const char *encoding, const char *errors) { @@ -410,7 +411,7 @@ PyObject *PyString_AsDecodedString(PyObject *str, } PyObject *PyString_Encode(const char *s, - int size, + Py_ssize_t size, const char *encoding, const char *errors) { @@ -519,16 +520,16 @@ string_dealloc(PyObject *op) specified encoding. */ PyObject *PyString_DecodeEscape(const char *s, - int len, + Py_ssize_t len, const char *errors, - int unicode, + Py_ssize_t unicode, const char *recode_encoding) { int c; char *p, *buf; const char *end; PyObject *v; - int newlen = recode_encoding ? 4*len:len; + Py_ssize_t newlen = recode_encoding ? 4*len:len; v = PyString_FromStringAndSize((char *)NULL, newlen); if (v == NULL) return NULL; @@ -542,7 +543,7 @@ PyObject *PyString_DecodeEscape(const char *s, PyObject *u, *w; char *r; const char* t; - int rn; + Py_ssize_t rn; t = s; /* Decode non-ASCII bytes as UTF-8. */ while (t < end && (*t & 0x80)) t++; @@ -658,18 +659,18 @@ PyObject *PyString_DecodeEscape(const char *s, } } if (p-buf < newlen) - _PyString_Resize(&v, (int)(p - buf)); + _PyString_Resize(&v, p - buf); return v; failed: Py_DECREF(v); return NULL; } -static int +static Py_ssize_t string_getsize(register PyObject *op) { char *s; - int len; + Py_ssize_t len; if (PyString_AsStringAndSize(op, &s, &len)) return -1; return len; @@ -679,13 +680,13 @@ static /*const*/ char * string_getbuffer(register PyObject *op) { char *s; - int len; + Py_ssize_t len; if (PyString_AsStringAndSize(op, &s, &len)) return NULL; return s; } -int +Py_ssize_t PyString_Size(register PyObject *op) { if (!PyString_Check(op)) @@ -704,7 +705,7 @@ PyString_AsString(register PyObject *op) int PyString_AsStringAndSize(register PyObject *obj, register char **s, - register int *len) + register Py_ssize_t *len) { if (s == NULL) { PyErr_BadInternalCall(); @@ -731,7 +732,7 @@ PyString_AsStringAndSize(register PyObject *obj, *s = PyString_AS_STRING(obj); if (len != NULL) *len = PyString_GET_SIZE(obj); - else if ((int)strlen(*s) != PyString_GET_SIZE(obj)) { + else if (strlen(*s) != PyString_GET_SIZE(obj)) { PyErr_SetString(PyExc_TypeError, "expected string without null bytes"); return -1; @@ -744,7 +745,7 @@ PyString_AsStringAndSize(register PyObject *obj, static int string_print(PyStringObject *op, FILE *fp, int flags) { - int i; + Py_ssize_t i; char c; int quote; @@ -809,7 +810,7 @@ PyString_Repr(PyObject *obj, int smartquotes) return NULL; } else { - register int i; + register Py_ssize_t i; register char c; register char *p; int quote; @@ -876,7 +877,7 @@ string_str(PyObject *s) } } -static int +static Py_ssize_t string_length(PyStringObject *a) { return a->ob_size; @@ -885,7 +886,7 @@ string_length(PyStringObject *a) static PyObject * string_concat(register PyStringObject *a, register PyObject *bb) { - register unsigned int size; + register size_t size; register PyStringObject *op; if (!PyString_Check(bb)) { #ifdef Py_USING_UNICODE @@ -909,6 +910,7 @@ string_concat(register PyStringObject *a, register PyObject *bb) return (PyObject *)a; } size = a->ob_size + b->ob_size; + /* XXX check overflow */ /* Inline PyObject_NewVar */ op = (PyStringObject *)PyObject_MALLOC(sizeof(PyStringObject) + size); if (op == NULL) @@ -916,19 +918,19 @@ string_concat(register PyStringObject *a, register PyObject *bb) PyObject_INIT_VAR(op, &PyString_Type, size); op->ob_shash = -1; op->ob_sstate = SSTATE_NOT_INTERNED; - memcpy(op->ob_sval, a->ob_sval, (int) a->ob_size); - memcpy(op->ob_sval + a->ob_size, b->ob_sval, (int) b->ob_size); + memcpy(op->ob_sval, a->ob_sval, a->ob_size); + memcpy(op->ob_sval + a->ob_size, b->ob_sval, b->ob_size); op->ob_sval[size] = '\0'; return (PyObject *) op; #undef b } static PyObject * -string_repeat(register PyStringObject *a, register int n) +string_repeat(register PyStringObject *a, register Py_ssize_t n) { - register int i; - register int j; - register int size; + register Py_ssize_t i; + register Py_ssize_t j; + register Py_ssize_t size; register PyStringObject *op; size_t nbytes; if (n < 0) @@ -966,8 +968,8 @@ string_repeat(register PyStringObject *a, register int n) } i = 0; if (i < size) { - memcpy(op->ob_sval, a->ob_sval, (int) a->ob_size); - i = (int) a->ob_size; + memcpy(op->ob_sval, a->ob_sval, a->ob_size); + i = a->ob_size; } while (i < size) { j = (i <= size-i) ? i : size-i; @@ -980,7 +982,8 @@ string_repeat(register PyStringObject *a, register int n) /* String slice a[i:j] consists of characters a[i] ... a[j-1] */ static PyObject * -string_slice(register PyStringObject *a, register int i, register int j) +string_slice(register PyStringObject *a, register Py_ssize_t i, + register Py_ssize_t j) /* j -- may be negative! */ { if (i < 0) @@ -996,7 +999,7 @@ string_slice(register PyStringObject *a, register int i, register int j) } if (j < i) j = i; - return PyString_FromStringAndSize(a->ob_sval + i, (int) (j-i)); + return PyString_FromStringAndSize(a->ob_sval + i, j-i); } static int @@ -1005,7 +1008,7 @@ string_contains(PyObject *a, PyObject *el) char *s = PyString_AS_STRING(a); const char *sub = PyString_AS_STRING(el); char *last; - int len_sub = PyString_GET_SIZE(el); + Py_ssize_t len_sub = PyString_GET_SIZE(el); int shortsub; char firstchar, lastchar; @@ -1047,7 +1050,7 @@ string_contains(PyObject *a, PyObject *el) } static PyObject * -string_item(PyStringObject *a, register int i) +string_item(PyStringObject *a, register Py_ssize_t i) { PyObject *v; char *pchar; @@ -1072,8 +1075,8 @@ static PyObject* string_richcompare(PyStringObject *a, PyStringObject *b, int op) { int c; - int len_a, len_b; - int min_len; + Py_ssize_t len_a, len_b; + Py_ssize_t min_len; PyObject *result; /* Make sure both arguments are strings. */ @@ -1145,7 +1148,7 @@ _PyString_Eq(PyObject *o1, PyObject *o2) static long string_hash(PyStringObject *a) { - register int len; + register Py_ssize_t len; register unsigned char *p; register long x; @@ -1166,14 +1169,8 @@ string_hash(PyStringObject *a) static PyObject* string_subscript(PyStringObject* self, PyObject* item) { - if (PyInt_Check(item)) { - long i = PyInt_AS_LONG(item); - if (i < 0) - i += PyString_GET_SIZE(self); - return string_item(self,i); - } - else if (PyLong_Check(item)) { - long i = PyLong_AsLong(item); + if (PyInt_Check(item) || PyLong_Check(item)) { + Py_ssize_t i = PyInt_AsSsize_t(item); if (i == -1 && PyErr_Occurred()) return NULL; if (i < 0) @@ -1181,7 +1178,7 @@ string_subscript(PyStringObject* self, PyObject* item) return string_item(self,i); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength, cur, i; + Py_ssize_t start, stop, step, slicelength, cur, i; char* source_buf; char* result_buf; PyObject* result; @@ -1219,8 +1216,8 @@ string_subscript(PyStringObject* self, PyObject* item) } } -static int -string_buffer_getreadbuf(PyStringObject *self, int index, const void **ptr) +static Py_ssize_t +string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **ptr) { if ( index != 0 ) { PyErr_SetString(PyExc_SystemError, @@ -1231,24 +1228,24 @@ string_buffer_getreadbuf(PyStringObject *self, int index, const void **ptr) return self->ob_size; } -static int -string_buffer_getwritebuf(PyStringObject *self, int index, const void **ptr) +static Py_ssize_t +string_buffer_getwritebuf(PyStringObject *self, Py_ssize_t index, const void **ptr) { PyErr_SetString(PyExc_TypeError, "Cannot use string as modifiable buffer"); return -1; } -static int -string_buffer_getsegcount(PyStringObject *self, int *lenp) +static Py_ssize_t +string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp) { if ( lenp ) *lenp = self->ob_size; return 1; } -static int -string_buffer_getcharbuf(PyStringObject *self, int index, const char **ptr) +static Py_ssize_t +string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **ptr) { if ( index != 0 ) { PyErr_SetString(PyExc_SystemError, @@ -1260,27 +1257,27 @@ string_buffer_getcharbuf(PyStringObject *self, int index, const char **ptr) } static PySequenceMethods string_as_sequence = { - (inquiry)string_length, /*sq_length*/ + (lenfunc)string_length, /*sq_length*/ (binaryfunc)string_concat, /*sq_concat*/ - (intargfunc)string_repeat, /*sq_repeat*/ - (intargfunc)string_item, /*sq_item*/ - (intintargfunc)string_slice, /*sq_slice*/ + (ssizeargfunc)string_repeat, /*sq_repeat*/ + (ssizeargfunc)string_item, /*sq_item*/ + (ssizessizeargfunc)string_slice, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ (objobjproc)string_contains /*sq_contains*/ }; static PyMappingMethods string_as_mapping = { - (inquiry)string_length, + (lenfunc)string_length, (binaryfunc)string_subscript, 0, }; static PyBufferProcs string_as_buffer = { - (getreadbufferproc)string_buffer_getreadbuf, - (getwritebufferproc)string_buffer_getwritebuf, - (getsegcountproc)string_buffer_getsegcount, - (getcharbufferproc)string_buffer_getcharbuf, + (readbufferproc)string_buffer_getreadbuf, + (writebufferproc)string_buffer_getwritebuf, + (segcountproc)string_buffer_getsegcount, + (charbufferproc)string_buffer_getcharbuf, }; @@ -1319,9 +1316,9 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"}; Py_DECREF(str); static PyObject * -split_whitespace(const char *s, int len, int maxsplit) +split_whitespace(const char *s, Py_ssize_t len, int maxsplit) { - int i, j; + Py_ssize_t i, j; PyObject *str; PyObject *list = PyList_New(0); @@ -1353,9 +1350,9 @@ split_whitespace(const char *s, int len, int maxsplit) } static PyObject * -split_char(const char *s, int len, char ch, int maxcount) +split_char(const char *s, Py_ssize_t len, char ch, int maxcount) { - register int i, j; + register Py_ssize_t i, j; PyObject *str; PyObject *list = PyList_New(0); @@ -1392,7 +1389,8 @@ whitespace string is a separator."); static PyObject * string_split(PyStringObject *self, PyObject *args) { - int len = PyString_GET_SIZE(self), n, i, j, err; + Py_ssize_t len = PyString_GET_SIZE(self), n, i, j; + int err; int maxsplit = -1; const char *s = PyString_AS_STRING(self), *sub; PyObject *list, *item, *subobj = Py_None; @@ -1430,7 +1428,7 @@ string_split(PyStringObject *self, PyObject *args) if (s[i] == sub[0] && memcmp(s+i, sub, n) == 0) { if (maxsplit-- <= 0) break; - item = PyString_FromStringAndSize(s+j, (int)(i-j)); + item = PyString_FromStringAndSize(s+j, i-j); if (item == NULL) goto fail; err = PyList_Append(list, item); @@ -1442,7 +1440,7 @@ string_split(PyStringObject *self, PyObject *args) else i++; } - item = PyString_FromStringAndSize(s+j, (int)(len-j)); + item = PyString_FromStringAndSize(s+j, len-j); if (item == NULL) goto fail; err = PyList_Append(list, item); @@ -1458,9 +1456,9 @@ string_split(PyStringObject *self, PyObject *args) } static PyObject * -rsplit_whitespace(const char *s, int len, int maxsplit) +rsplit_whitespace(const char *s, Py_ssize_t len, int maxsplit) { - int i, j; + Py_ssize_t i, j; PyObject *str; PyObject *list = PyList_New(0); @@ -1492,9 +1490,9 @@ rsplit_whitespace(const char *s, int len, int maxsplit) } static PyObject * -rsplit_char(const char *s, int len, char ch, int maxcount) +rsplit_char(const char *s, Py_ssize_t len, char ch, int maxcount) { - register int i, j; + register Py_ssize_t i, j; PyObject *str; PyObject *list = PyList_New(0); @@ -1532,7 +1530,8 @@ is a separator."); static PyObject * string_rsplit(PyStringObject *self, PyObject *args) { - int len = PyString_GET_SIZE(self), n, i, j, err; + Py_ssize_t len = PyString_GET_SIZE(self), n, i, j; + int err; int maxsplit = -1; const char *s = PyString_AS_STRING(self), *sub; PyObject *list, *item, *subobj = Py_None; @@ -1571,7 +1570,7 @@ string_rsplit(PyStringObject *self, PyObject *args) if (s[i] == sub[0] && memcmp(s+i, sub, n) == 0) { if (maxsplit-- <= 0) break; - item = PyString_FromStringAndSize(s+i+n, (int)(j-i-n)); + item = PyString_FromStringAndSize(s+i+n, j-i-n); if (item == NULL) goto fail; err = PyList_Insert(list, 0, item); @@ -1610,12 +1609,12 @@ static PyObject * string_join(PyStringObject *self, PyObject *orig) { char *sep = PyString_AS_STRING(self); - const int seplen = PyString_GET_SIZE(self); + const Py_ssize_t seplen = PyString_GET_SIZE(self); PyObject *res = NULL; char *p; - int seqlen = 0; + Py_ssize_t seqlen = 0; size_t sz = 0; - int i; + Py_ssize_t i; PyObject *seq, *item; seq = PySequence_Fast(orig, ""); @@ -1663,7 +1662,7 @@ string_join(PyStringObject *self, PyObject *orig) PyErr_Format(PyExc_TypeError, "sequence item %i: expected string," " %.80s found", - i, item->ob_type->tp_name); + /*XXX*/(int)i, item->ob_type->tp_name); Py_DECREF(seq); return NULL; } @@ -1679,7 +1678,7 @@ string_join(PyStringObject *self, PyObject *orig) } /* Allocate result space. */ - res = PyString_FromStringAndSize((char*)NULL, (int)sz); + res = PyString_FromStringAndSize((char*)NULL, sz); if (res == NULL) { Py_DECREF(seq); return NULL; @@ -1712,7 +1711,7 @@ _PyString_Join(PyObject *sep, PyObject *x) } static void -string_adjust_indices(int *start, int *end, int len) +string_adjust_indices(Py_ssize_t *start, Py_ssize_t *end, Py_ssize_t len) { if (*end > len) *end = len; @@ -1726,14 +1725,15 @@ string_adjust_indices(int *start, int *end, int len) *start = 0; } -static long +static Py_ssize_t string_find_internal(PyStringObject *self, PyObject *args, int dir) { const char *s = PyString_AS_STRING(self), *sub; - int len = PyString_GET_SIZE(self); - int n, i = 0, last = INT_MAX; + Py_ssize_t len = PyString_GET_SIZE(self); + Py_ssize_t n, i = 0, last = INT_MAX; PyObject *subobj; + /* XXX ssize_t i */ if (!PyArg_ParseTuple(args, "O|O&O&:find/rfind/index/rindex", &subobj, _PyEval_SliceIndex, &i, _PyEval_SliceIndex, &last)) return -2; @@ -1759,13 +1759,13 @@ string_find_internal(PyStringObject *self, PyObject *args, int dir) return (long)i; } else { - int j; + Py_ssize_t j; if (n == 0 && i <= last) - return (long)last; + return last; for (j = last-n; j >= i; --j) if (s[j] == sub[0] && memcmp(&s[j], sub, n) == 0) - return (long)j; + return j; } return -1; @@ -1784,10 +1784,10 @@ Return -1 on failure."); static PyObject * string_find(PyStringObject *self, PyObject *args) { - long result = string_find_internal(self, args, +1); + Py_ssize_t result = string_find_internal(self, args, +1); if (result == -2) return NULL; - return PyInt_FromLong(result); + return PyInt_FromSsize_t(result); } @@ -1799,7 +1799,7 @@ Like S.find() but raise ValueError when the substring is not found."); static PyObject * string_index(PyStringObject *self, PyObject *args) { - long result = string_find_internal(self, args, +1); + Py_ssize_t result = string_find_internal(self, args, +1); if (result == -2) return NULL; if (result == -1) { @@ -1807,7 +1807,7 @@ string_index(PyStringObject *self, PyObject *args) "substring not found"); return NULL; } - return PyInt_FromLong(result); + return PyInt_FromSsize_t(result); } @@ -1823,10 +1823,10 @@ Return -1 on failure."); static PyObject * string_rfind(PyStringObject *self, PyObject *args) { - long result = string_find_internal(self, args, -1); + Py_ssize_t result = string_find_internal(self, args, -1); if (result == -2) return NULL; - return PyInt_FromLong(result); + return PyInt_FromSsize_t(result); } @@ -1838,7 +1838,7 @@ Like S.rfind() but raise ValueError when the substring is not found."); static PyObject * string_rindex(PyStringObject *self, PyObject *args) { - long result = string_find_internal(self, args, -1); + Py_ssize_t result = string_find_internal(self, args, -1); if (result == -2) return NULL; if (result == -1) { @@ -1846,7 +1846,7 @@ string_rindex(PyStringObject *self, PyObject *args) "substring not found"); return NULL; } - return PyInt_FromLong(result); + return PyInt_FromSsize_t(result); } @@ -1854,10 +1854,10 @@ static PyObject * do_xstrip(PyStringObject *self, int striptype, PyObject *sepobj) { char *s = PyString_AS_STRING(self); - int len = PyString_GET_SIZE(self); + Py_ssize_t len = PyString_GET_SIZE(self); char *sep = PyString_AS_STRING(sepobj); - int seplen = PyString_GET_SIZE(sepobj); - int i, j; + Py_ssize_t seplen = PyString_GET_SIZE(sepobj); + Py_ssize_t i, j; i = 0; if (striptype != RIGHTSTRIP) { @@ -1887,7 +1887,7 @@ static PyObject * do_strip(PyStringObject *self, int striptype) { char *s = PyString_AS_STRING(self); - int len = PyString_GET_SIZE(self), i, j; + Py_ssize_t len = PyString_GET_SIZE(self), i, j; i = 0; if (striptype != RIGHTSTRIP) { @@ -2014,7 +2014,7 @@ static PyObject * string_lower(PyStringObject *self) { char *s = PyString_AS_STRING(self), *s_new; - int i, n = PyString_GET_SIZE(self); + Py_ssize_t i, n = PyString_GET_SIZE(self); PyObject *new; new = PyString_FromStringAndSize(NULL, n); @@ -2042,7 +2042,7 @@ static PyObject * string_upper(PyStringObject *self) { char *s = PyString_AS_STRING(self), *s_new; - int i, n = PyString_GET_SIZE(self); + Py_ssize_t i, n = PyString_GET_SIZE(self); PyObject *new; new = PyString_FromStringAndSize(NULL, n); @@ -2071,7 +2071,7 @@ static PyObject* string_title(PyStringObject *self) { char *s = PyString_AS_STRING(self), *s_new; - int i, n = PyString_GET_SIZE(self); + Py_ssize_t i, n = PyString_GET_SIZE(self); int previous_is_cased = 0; PyObject *new; @@ -2106,7 +2106,7 @@ static PyObject * string_capitalize(PyStringObject *self) { char *s = PyString_AS_STRING(self), *s_new; - int i, n = PyString_GET_SIZE(self); + Py_ssize_t i, n = PyString_GET_SIZE(self); PyObject *new; new = PyString_FromStringAndSize(NULL, n); @@ -2144,9 +2144,9 @@ static PyObject * string_count(PyStringObject *self, PyObject *args) { const char *s = PyString_AS_STRING(self), *sub, *t; - int len = PyString_GET_SIZE(self), n; - int i = 0, last = INT_MAX; - int m, r; + Py_ssize_t len = PyString_GET_SIZE(self), n; + Py_ssize_t i = 0, last = INT_MAX; + Py_ssize_t m, r; PyObject *subobj; if (!PyArg_ParseTuple(args, "O|O&O&:count", &subobj, @@ -2159,7 +2159,7 @@ string_count(PyStringObject *self, PyObject *args) } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) { - int count; + Py_ssize_t count; count = PyUnicode_Count((PyObject *)self, subobj, i, last); if (count == -1) return NULL; @@ -2174,7 +2174,7 @@ string_count(PyStringObject *self, PyObject *args) m = last + 1 - n; if (n == 0) - return PyInt_FromLong((long) (m-i)); + return PyInt_FromSsize_t(m-i); r = 0; while (i < m) { @@ -2191,7 +2191,7 @@ string_count(PyStringObject *self, PyObject *args) break; i = t - s; } - return PyInt_FromLong((long) r); + return PyInt_FromSsize_t(r); } PyDoc_STRVAR(swapcase__doc__, @@ -2204,7 +2204,7 @@ static PyObject * string_swapcase(PyStringObject *self) { char *s = PyString_AS_STRING(self), *s_new; - int i, n = PyString_GET_SIZE(self); + Py_ssize_t i, n = PyString_GET_SIZE(self); PyObject *new; new = PyString_FromStringAndSize(NULL, n); @@ -2240,10 +2240,10 @@ string_translate(PyStringObject *self, PyObject *args) { register char *input, *output; register const char *table; - register int i, c, changed = 0; + register Py_ssize_t i, c, changed = 0; PyObject *input_obj = (PyObject*)self; const char *table1, *output_start, *del_table=NULL; - int inlen, tablen, dellen = 0; + Py_ssize_t inlen, tablen, dellen = 0; PyObject *result; int trans_table[256]; PyObject *tableobj, *delobj = NULL; @@ -2357,10 +2357,10 @@ string_translate(PyStringObject *self, PyObject *args) found, or -1 if not found. If len of PAT is greater than length of MEM, the function returns -1. */ -static int -mymemfind(const char *mem, int len, const char *pat, int pat_len) +static Py_ssize_t +mymemfind(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len) { - register int ii; + register Py_ssize_t ii; /* pattern can not occur in the last pat_len-1 chars */ len -= pat_len; @@ -2380,11 +2380,11 @@ mymemfind(const char *mem, int len, const char *pat, int pat_len) meaning mem=1111 and pat==11 returns 2. mem=11111 and pat==11 also return 2. */ -static int -mymemcnt(const char *mem, int len, const char *pat, int pat_len) +static Py_ssize_t +mymemcnt(const char *mem, Py_ssize_t len, const char *pat, Py_ssize_t pat_len) { - register int offset = 0; - int nfound = 0; + register Py_ssize_t offset = 0; + Py_ssize_t nfound = 0; while (len >= 0) { offset = mymemfind(mem, len, pat, pat_len); @@ -2417,15 +2417,15 @@ mymemcnt(const char *mem, int len, const char *pat, int pat_len) NULL if an error occurred. */ static char * -mymemreplace(const char *str, int len, /* input string */ - const char *pat, int pat_len, /* pattern string to find */ - const char *sub, int sub_len, /* substitution string */ - int count, /* number of replacements */ - int *out_len) +mymemreplace(const char *str, Py_ssize_t len, /* input string */ + const char *pat, Py_ssize_t pat_len, /* pattern string to find */ + const char *sub, Py_ssize_t sub_len, /* substitution string */ + Py_ssize_t count, /* number of replacements */ + Py_ssize_t *out_len) { char *out_s; char *new_s; - int nfound, offset, new_len; + Py_ssize_t nfound, offset, new_len; if (len == 0 || (pat_len == 0 && sub_len == 0) || pat_len > len) goto return_same; @@ -2508,8 +2508,8 @@ string_replace(PyStringObject *self, PyObject *args) { const char *str = PyString_AS_STRING(self), *sub, *repl; char *new_s; - const int len = PyString_GET_SIZE(self); - int sub_len, repl_len, out_len; + const Py_ssize_t len = PyString_GET_SIZE(self); + Py_ssize_t sub_len, repl_len, out_len; int count = -1; PyObject *new; PyObject *subobj, *replobj; @@ -2578,11 +2578,11 @@ static PyObject * string_startswith(PyStringObject *self, PyObject *args) { const char* str = PyString_AS_STRING(self); - int len = PyString_GET_SIZE(self); + Py_ssize_t len = PyString_GET_SIZE(self); const char* prefix; - int plen; - int start = 0; - int end = INT_MAX; + Py_ssize_t plen; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *subobj; if (!PyArg_ParseTuple(args, "O|O&O&:startswith", &subobj, @@ -2594,7 +2594,7 @@ string_startswith(PyStringObject *self, PyObject *args) } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) { - int rc; + Py_ssize_t rc; rc = PyUnicode_Tailmatch((PyObject *)self, subobj, start, end, -1); if (rc == -1) @@ -2629,11 +2629,11 @@ static PyObject * string_endswith(PyStringObject *self, PyObject *args) { const char* str = PyString_AS_STRING(self); - int len = PyString_GET_SIZE(self); + Py_ssize_t len = PyString_GET_SIZE(self); const char* suffix; - int slen; - int start = 0; - int end = INT_MAX; + Py_ssize_t slen; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *subobj; if (!PyArg_ParseTuple(args, "O|O&O&:endswith", &subobj, @@ -2645,7 +2645,7 @@ string_endswith(PyStringObject *self, PyObject *args) } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(subobj)) { - int rc; + Py_ssize_t rc; rc = PyUnicode_Tailmatch((PyObject *)self, subobj, start, end, +1); if (rc == -1) @@ -2756,7 +2756,7 @@ string_expandtabs(PyStringObject *self, PyObject *args) { const char *e, *p; char *q; - int i, j; + Py_ssize_t i, j; PyObject *u; int tabsize = 8; @@ -2807,7 +2807,7 @@ string_expandtabs(PyStringObject *self, PyObject *args) } static PyObject * -pad(PyStringObject *self, int left, int right, char fill) +pad(PyStringObject *self, Py_ssize_t left, Py_ssize_t right, char fill) { PyObject *u; @@ -2894,11 +2894,11 @@ PyDoc_STRVAR(center__doc__, static PyObject * string_center(PyStringObject *self, PyObject *args) { - int marg, left; - int width; + Py_ssize_t marg, left; + long width; char fillchar = ' '; - if (!PyArg_ParseTuple(args, "i|c:center", &width, &fillchar)) + if (!PyArg_ParseTuple(args, "l|c:center", &width, &fillchar)) return NULL; if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) { @@ -2921,12 +2921,12 @@ PyDoc_STRVAR(zfill__doc__, static PyObject * string_zfill(PyStringObject *self, PyObject *args) { - int fill; + long fill; PyObject *s; char *p; int width; - if (!PyArg_ParseTuple(args, "i:zfill", &width)) + if (!PyArg_ParseTuple(args, "l:zfill", &width)) return NULL; if (PyString_GET_SIZE(self) >= width) { @@ -3209,9 +3209,9 @@ is given and true."); static PyObject* string_splitlines(PyStringObject *self, PyObject *args) { - register int i; - register int j; - int len; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len; int keepends = 0; PyObject *list; PyObject *str; @@ -3228,7 +3228,7 @@ string_splitlines(PyStringObject *self, PyObject *args) goto onError; for (i = j = 0; i < len; ) { - int eol; + Py_ssize_t eol; /* Find a line and append it */ while (i < len && data[i] != '\n' && data[i] != '\r') @@ -3340,7 +3340,7 @@ static PyObject * str_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *tmp, *pnew; - int n; + Py_ssize_t n; assert(PyType_IsSubtype(type, &PyString_Type)); tmp = string_new(&PyString_Type, args, kwds); @@ -3521,7 +3521,7 @@ PyString_ConcatAndDel(register PyObject **pv, register PyObject *w) */ int -_PyString_Resize(PyObject **pv, int newsize) +_PyString_Resize(PyObject **pv, Py_ssize_t newsize) { register PyObject *v; register PyStringObject *sv; @@ -3625,7 +3625,7 @@ formatfloat(char *buf, size_t buflen, int flags, (flags&F_ALT) ? "#" : "", prec, type); PyOS_ascii_formatd(buf, buflen, fmt, x); - return strlen(buf); + return (int)strlen(buf); } /* _PyString_FormatLong emulates the format codes d, u, o, x and X, and @@ -3655,7 +3655,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type, { PyObject *result = NULL; char *buf; - int i; + Py_ssize_t i; int sign; /* 1 if '-', else 0 */ int len; /* number of characters */ int numdigits; /* len == numnondigits + numdigits */ @@ -3832,7 +3832,7 @@ formatint(char *buf, size_t buflen, int flags, PyOS_snprintf(buf, buflen, fmt, -x); else PyOS_snprintf(buf, buflen, fmt, x); - return strlen(buf); + return (int)strlen(buf); } static int @@ -3865,7 +3865,8 @@ PyObject * PyString_Format(PyObject *format, PyObject *args) { char *fmt, *res; - int fmtcnt, rescnt, reslen, arglen, argidx; + int arglen, argidx; + Py_ssize_t reslen, rescnt, fmtcnt; int args_owned = 0; PyObject *result, *orig_args; #ifdef Py_USING_UNICODE @@ -3911,7 +3912,7 @@ PyString_Format(PyObject *format, PyObject *args) else { /* Got a format specifier */ int flags = 0; - int width = -1; + Py_ssize_t width = -1; int prec = -1; int c = '\0'; int fill; @@ -3930,7 +3931,7 @@ PyString_Format(PyObject *format, PyObject *args) fmt++; if (*fmt == '(') { char *keystart; - int keylen; + Py_ssize_t keylen; PyObject *key; int pcount = 1; @@ -4393,7 +4394,7 @@ void _Py_ReleaseInternedStrings(void) { PyObject *keys; PyStringObject *s; - int i, n; + Py_ssize_t i, n; if (interned == NULL || !PyDict_Check(interned)) return; diff --git a/Objects/structseq.c b/Objects/structseq.c index ac3cf03..b035ca2 100644 --- a/Objects/structseq.c +++ b/Objects/structseq.c @@ -40,7 +40,7 @@ PyStructSequence_New(PyTypeObject *type) static void structseq_dealloc(PyStructSequence *obj) { - int i, size; + Py_ssize_t i, size; size = REAL_SIZE(obj); for (i = 0; i < size; ++i) { @@ -49,14 +49,14 @@ structseq_dealloc(PyStructSequence *obj) PyObject_Del(obj); } -static int +static Py_ssize_t structseq_length(PyStructSequence *obj) { return VISIBLE_SIZE(obj); } static PyObject* -structseq_item(PyStructSequence *obj, int i) +structseq_item(PyStructSequence *obj, Py_ssize_t i) { if (i < 0 || i >= VISIBLE_SIZE(obj)) { PyErr_SetString(PyExc_IndexError, "tuple index out of range"); @@ -67,10 +67,10 @@ structseq_item(PyStructSequence *obj, int i) } static PyObject* -structseq_slice(PyStructSequence *obj, int low, int high) +structseq_slice(PyStructSequence *obj, Py_ssize_t low, Py_ssize_t high) { PyTupleObject *np; - int i; + Py_ssize_t i; if (low < 0) low = 0; @@ -96,7 +96,7 @@ structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) PyObject *dict = NULL; PyObject *ob; PyStructSequence *res = NULL; - int len, min_len, max_len, i, n_unnamed_fields; + Py_ssize_t len, min_len, max_len, i, n_unnamed_fields; static const char *kwlist[] = {"sequence", "dict", 0}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:structseq", @@ -125,7 +125,7 @@ structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if (min_len != max_len) { if (len < min_len) { PyErr_Format(PyExc_TypeError, - "%.500s() takes an at least %d-sequence (%d-sequence given)", + "%.500s() takes an at least %ld-sequence (%ld-sequence given)", type->tp_name, min_len, len); Py_DECREF(arg); return NULL; @@ -133,7 +133,7 @@ structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if (len > max_len) { PyErr_Format(PyExc_TypeError, - "%.500s() takes an at most %d-sequence (%d-sequence given)", + "%.500s() takes an at most %ld-sequence (%ld-sequence given)", type->tp_name, max_len, len); Py_DECREF(arg); return NULL; @@ -142,7 +142,7 @@ structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) else { if (len != min_len) { PyErr_Format(PyExc_TypeError, - "%.500s() takes a %d-sequence (%d-sequence given)", + "%.500s() takes a %ld-sequence (%ld-sequence given)", type->tp_name, min_len, len); Py_DECREF(arg); return NULL; @@ -200,7 +200,7 @@ structseq_concat(PyStructSequence *obj, PyObject *b) } static PyObject * -structseq_repeat(PyStructSequence *obj, int n) +structseq_repeat(PyStructSequence *obj, Py_ssize_t n) { PyObject *tup, *result; tup = make_tuple(obj); @@ -284,11 +284,11 @@ structseq_reduce(PyStructSequence* self) } static PySequenceMethods structseq_as_sequence = { - (inquiry)structseq_length, + (lenfunc)structseq_length, (binaryfunc)structseq_concat, /* sq_concat */ - (intargfunc)structseq_repeat, /* sq_repeat */ - (intargfunc)structseq_item, /* sq_item */ - (intintargfunc)structseq_slice, /* sq_slice */ + (ssizeargfunc)structseq_repeat, /* sq_repeat */ + (ssizeargfunc)structseq_item, /* sq_item */ + (ssizessizeargfunc)structseq_slice, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)structseq_contains, /* sq_contains */ diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c index 8ea29f0..2de2899 100644 --- a/Objects/tupleobject.c +++ b/Objects/tupleobject.c @@ -24,10 +24,10 @@ int tuple_zero_allocs; #endif PyObject * -PyTuple_New(register int size) +PyTuple_New(register Py_ssize_t size) { register PyTupleObject *op; - int i; + Py_ssize_t i; if (size < 0) { PyErr_BadInternalCall(); return NULL; @@ -57,7 +57,7 @@ PyTuple_New(register int size) else #endif { - int nbytes = size * sizeof(PyObject *); + Py_ssize_t nbytes = size * sizeof(PyObject *); /* Check for overflow */ if (nbytes / sizeof(PyObject *) != (size_t)size || (nbytes += sizeof(PyTupleObject) - sizeof(PyObject *)) @@ -82,7 +82,7 @@ PyTuple_New(register int size) return (PyObject *) op; } -int +Py_ssize_t PyTuple_Size(register PyObject *op) { if (!PyTuple_Check(op)) { @@ -94,7 +94,7 @@ PyTuple_Size(register PyObject *op) } PyObject * -PyTuple_GetItem(register PyObject *op, register int i) +PyTuple_GetItem(register PyObject *op, register Py_ssize_t i) { if (!PyTuple_Check(op)) { PyErr_BadInternalCall(); @@ -108,7 +108,7 @@ PyTuple_GetItem(register PyObject *op, register int i) } int -PyTuple_SetItem(register PyObject *op, register int i, PyObject *newitem) +PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem) { register PyObject *olditem; register PyObject **p; @@ -131,9 +131,9 @@ PyTuple_SetItem(register PyObject *op, register int i, PyObject *newitem) } PyObject * -PyTuple_Pack(int n, ...) +PyTuple_Pack(Py_ssize_t n, ...) { - int i; + Py_ssize_t i; PyObject *o; PyObject *result; PyObject **items; @@ -159,8 +159,8 @@ PyTuple_Pack(int n, ...) static void tupledealloc(register PyTupleObject *op) { - register int i; - register int len = op->ob_size; + register Py_ssize_t i; + register Py_ssize_t len = op->ob_size; PyObject_GC_UnTrack(op); Py_TRASHCAN_SAFE_BEGIN(op) if (len > 0) { @@ -187,7 +187,7 @@ done: static int tupleprint(PyTupleObject *op, FILE *fp, int flags) { - int i; + Py_ssize_t i; fprintf(fp, "("); for (i = 0; i < op->ob_size; i++) { if (i > 0) @@ -204,7 +204,7 @@ tupleprint(PyTupleObject *op, FILE *fp, int flags) static PyObject * tuplerepr(PyTupleObject *v) { - int i, n; + Py_ssize_t i, n; PyObject *s, *temp; PyObject *pieces, *result = NULL; @@ -268,7 +268,7 @@ static long tuplehash(PyTupleObject *v) { register long x, y; - register int len = v->ob_size; + register Py_ssize_t len = v->ob_size; register PyObject **p; long mult = 1000003L; x = 0x345678L; @@ -286,7 +286,7 @@ tuplehash(PyTupleObject *v) return x; } -static int +static Py_ssize_t tuplelength(PyTupleObject *a) { return a->ob_size; @@ -295,7 +295,8 @@ tuplelength(PyTupleObject *a) static int tuplecontains(PyTupleObject *a, PyObject *el) { - int i, cmp; + Py_ssize_t i; + int cmp; for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i) cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i), @@ -304,7 +305,7 @@ tuplecontains(PyTupleObject *a, PyObject *el) } static PyObject * -tupleitem(register PyTupleObject *a, register int i) +tupleitem(register PyTupleObject *a, register Py_ssize_t i) { if (i < 0 || i >= a->ob_size) { PyErr_SetString(PyExc_IndexError, "tuple index out of range"); @@ -315,12 +316,13 @@ tupleitem(register PyTupleObject *a, register int i) } static PyObject * -tupleslice(register PyTupleObject *a, register int ilow, register int ihigh) +tupleslice(register PyTupleObject *a, register Py_ssize_t ilow, + register Py_ssize_t ihigh) { register PyTupleObject *np; PyObject **src, **dest; - register int i; - int len; + register Py_ssize_t i; + Py_ssize_t len; if (ilow < 0) ilow = 0; if (ihigh > a->ob_size) @@ -346,7 +348,7 @@ tupleslice(register PyTupleObject *a, register int ilow, register int ihigh) } PyObject * -PyTuple_GetSlice(PyObject *op, int i, int j) +PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j) { if (op == NULL || !PyTuple_Check(op)) { PyErr_BadInternalCall(); @@ -358,8 +360,8 @@ PyTuple_GetSlice(PyObject *op, int i, int j) static PyObject * tupleconcat(register PyTupleObject *a, register PyObject *bb) { - register int size; - register int i; + register Py_ssize_t size; + register Py_ssize_t i; PyObject **src, **dest; PyTupleObject *np; if (!PyTuple_Check(bb)) { @@ -395,10 +397,10 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb) } static PyObject * -tuplerepeat(PyTupleObject *a, int n) +tuplerepeat(PyTupleObject *a, Py_ssize_t n) { - int i, j; - int size; + Py_ssize_t i, j; + Py_ssize_t size; PyTupleObject *np; PyObject **p, **items; if (n < 0) @@ -434,13 +436,13 @@ tuplerepeat(PyTupleObject *a, int n) static int tupletraverse(PyTupleObject *o, visitproc visit, void *arg) { - int i, err; + Py_ssize_t i; PyObject *x; for (i = o->ob_size; --i >= 0; ) { x = o->ob_item[i]; if (x != NULL) { - err = visit(x, arg); + int err = visit(x, arg); if (err) return err; } @@ -452,8 +454,8 @@ static PyObject * tuplerichcompare(PyObject *v, PyObject *w, int op) { PyTupleObject *vt, *wt; - int i; - int vlen, wlen; + Py_ssize_t i; + Py_ssize_t vlen, wlen; if (!PyTuple_Check(v) || !PyTuple_Check(w)) { Py_INCREF(Py_NotImplemented); @@ -545,7 +547,7 @@ static PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *tmp, *new, *item; - int i, n; + Py_ssize_t i, n; assert(PyType_IsSubtype(type, &PyTuple_Type)); tmp = tuple_new(&PyTuple_Type, args, kwds); @@ -571,11 +573,11 @@ PyDoc_STRVAR(tuple_doc, "If the argument is a tuple, the return value is the same object."); static PySequenceMethods tuple_as_sequence = { - (inquiry)tuplelength, /* sq_length */ + (lenfunc)tuplelength, /* sq_length */ (binaryfunc)tupleconcat, /* sq_concat */ - (intargfunc)tuplerepeat, /* sq_repeat */ - (intargfunc)tupleitem, /* sq_item */ - (intintargfunc)tupleslice, /* sq_slice */ + (ssizeargfunc)tuplerepeat, /* sq_repeat */ + (ssizeargfunc)tupleitem, /* sq_item */ + (ssizessizeargfunc)tupleslice, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)tuplecontains, /* sq_contains */ @@ -584,14 +586,8 @@ static PySequenceMethods tuple_as_sequence = { static PyObject* tuplesubscript(PyTupleObject* self, PyObject* item) { - if (PyInt_Check(item)) { - long i = PyInt_AS_LONG(item); - if (i < 0) - i += PyTuple_GET_SIZE(self); - return tupleitem(self, i); - } - else if (PyLong_Check(item)) { - long i = PyLong_AsLong(item); + if (PyInt_Check(item) || PyLong_Check(item)) { + Py_ssize_t i = PyInt_AsSsize_t(item); if (i == -1 && PyErr_Occurred()) return NULL; if (i < 0) @@ -599,7 +595,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item) return tupleitem(self, i); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength, cur, i; + Py_ssize_t start, stop, step, slicelength, cur, i; PyObject* result; PyObject* it; PyObject **src, **dest; @@ -648,7 +644,7 @@ static PyMethodDef tuple_methods[] = { }; static PyMappingMethods tuple_as_mapping = { - (inquiry)tuplelength, + (lenfunc)tuplelength, (binaryfunc)tuplesubscript, 0 }; @@ -707,12 +703,12 @@ PyTypeObject PyTuple_Type = { known to some other part of the code. */ int -_PyTuple_Resize(PyObject **pv, int newsize) +_PyTuple_Resize(PyObject **pv, Py_ssize_t newsize) { register PyTupleObject *v; register PyTupleObject *sv; - int i; - int oldsize; + Py_ssize_t i; + Py_ssize_t oldsize; v = (PyTupleObject *) *pv; if (v == NULL || v->ob_type != &PyTuple_Type || @@ -854,7 +850,7 @@ tupleiter_next(tupleiterobject *it) static PyObject * tupleiter_len(tupleiterobject *it) { - int len = 0; + long len = 0; if (it->it_seq) len = PyTuple_GET_SIZE(it->it_seq) - it->it_index; return PyInt_FromLong(len); diff --git a/Objects/typeobject.c b/Objects/typeobject.c index 03f1adb..f52a87f 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -145,7 +145,7 @@ mro_subclasses(PyTypeObject *type, PyObject* temp) { PyTypeObject *subclass; PyObject *ref, *subclasses, *old_mro; - int i, n; + Py_ssize_t i, n; subclasses = type->tp_subclasses; if (subclasses == NULL) @@ -184,7 +184,8 @@ mro_subclasses(PyTypeObject *type, PyObject* temp) static int type_set_bases(PyTypeObject *type, PyObject *value, void *context) { - int i, r = 0; + Py_ssize_t i; + int r = 0; PyObject *ob, *temp; PyTypeObject *new_base, *old_base; PyObject *old_bases, *old_mro; @@ -443,7 +444,7 @@ type_call(PyTypeObject *type, PyObject *args, PyObject *kwds) } PyObject * -PyType_GenericAlloc(PyTypeObject *type, int nitems) +PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems) { PyObject *obj; const size_t size = _PyObject_VAR_SIZE(type, nitems+1); @@ -483,7 +484,7 @@ PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds) static int traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg) { - int i, n; + Py_ssize_t i, n; PyMemberDef *mp; n = type->ob_size; @@ -548,7 +549,7 @@ subtype_traverse(PyObject *self, visitproc visit, void *arg) static void clear_slots(PyTypeObject *type, PyObject *self) { - int i, n; + Py_ssize_t i, n; PyMemberDef *mp; n = type->ob_size; @@ -825,7 +826,7 @@ PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b) if (mro != NULL) { /* Deal with multiple inheritance without recursion by walking the MRO tuple */ - int i, n; + Py_ssize_t i, n; assert(PyTuple_Check(mro)); n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { @@ -970,7 +971,7 @@ static int fill_classic_mro(PyObject *mro, PyObject *cls) { PyObject *bases, *base; - int i, n; + Py_ssize_t i, n; assert(PyList_Check(mro)); assert(PyClass_Check(cls)); @@ -1037,7 +1038,7 @@ classic_mro(PyObject *cls) static int tail_contains(PyObject *list, int whence, PyObject *o) { - int j, size; + Py_ssize_t j, size; size = PyList_GET_SIZE(list); for (j = whence+1; j < size; j++) { @@ -1068,7 +1069,7 @@ class_name(PyObject *cls) static int check_duplicates(PyObject *list) { - int i, j, n; + Py_ssize_t i, j, n; /* Let's use a quadratic time algorithm, assuming that the bases lists is short. */ @@ -1101,7 +1102,7 @@ check_duplicates(PyObject *list) static void set_mro_error(PyObject *to_merge, int *remain) { - int i, n, off, to_merge_size; + Py_ssize_t i, n, off, to_merge_size; char buf[1000]; PyObject *k, *v; PyObject *set = PyDict_New(); @@ -1136,9 +1137,9 @@ consistent method resolution\norder (MRO) for bases"); static int pmerge(PyObject *acc, PyObject* to_merge) { - int i, j, to_merge_size; + Py_ssize_t i, j, to_merge_size, empty_cnt; int *remain; - int ok, empty_cnt; + int ok; to_merge_size = PyList_GET_SIZE(to_merge); @@ -1206,7 +1207,8 @@ pmerge(PyObject *acc, PyObject* to_merge) { static PyObject * mro_implementation(PyTypeObject *type) { - int i, n, ok; + Py_ssize_t i, n; + int ok; PyObject *bases, *result; PyObject *to_merge, *bases_aslist; @@ -1309,7 +1311,7 @@ mro_internal(PyTypeObject *type) if (tuple == NULL) return -1; if (checkit) { - int i, len; + Py_ssize_t i, len; PyObject *cls; PyTypeObject *solid; @@ -1350,7 +1352,7 @@ mro_internal(PyTypeObject *type) static PyTypeObject * best_base(PyObject *bases) { - int i, n; + Py_ssize_t i, n; PyTypeObject *base, *winner, *candidate, *base_i; PyObject *base_proto; @@ -1532,7 +1534,7 @@ static int valid_identifier(PyObject *s) { unsigned char *p; - int i, n; + Py_ssize_t i, n; if (!PyString_Check(s)) { PyErr_SetString(PyExc_TypeError, @@ -1564,7 +1566,7 @@ _unicode_to_string(PyObject *slots, int nslots) PyObject *tmp = slots; PyObject *o, *o1; int i; - intintargfunc copy = slots->ob_type->tp_as_sequence->sq_slice; + ssizessizeargfunc copy = slots->ob_type->tp_as_sequence->sq_slice; for (i = 0; i < nslots; i++) { if (PyUnicode_Check(o = PyTuple_GET_ITEM(tmp, i))) { if (tmp == slots) { @@ -1596,7 +1598,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) PyTypeObject *type, *base, *tmptype, *winner; PyHeapTypeObject *et; PyMemberDef *mp; - int i, nbases, nslots, slotoffset, add_dict, add_weak; + Py_ssize_t i, nbases, nslots, slotoffset, add_dict, add_weak; int j, may_add_dict, may_add_weak; assert(args != NULL && PyTuple_Check(args)); @@ -1604,8 +1606,8 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) /* Special case: type(x) should return x->ob_type */ { - const int nargs = PyTuple_GET_SIZE(args); - const int nkwds = kwds == NULL ? 0 : PyDict_Size(kwds); + const Py_ssize_t nargs = PyTuple_GET_SIZE(args); + const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds); if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) { PyObject *x = PyTuple_GET_ITEM(args, 0); @@ -1999,7 +2001,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds) PyObject * _PyType_Lookup(PyTypeObject *type, PyObject *name) { - int i, n; + Py_ssize_t i, n; PyObject *mro, *res, *base, *dict; /* Look in tp_dict of types in MRO */ @@ -2154,7 +2156,7 @@ static PyObject * type_subclasses(PyTypeObject *type, PyObject *args_ignored) { PyObject *list, *raw, *ref; - int i, n; + Py_ssize_t i, n; list = PyList_New(0); if (list == NULL) @@ -2587,7 +2589,7 @@ reduce_2(PyObject *obj) PyObject *getstate = NULL, *state = NULL, *names = NULL; PyObject *slots = NULL, *listitems = NULL, *dictitems = NULL; PyObject *copy_reg = NULL, *newobj = NULL, *res = NULL; - int i, n; + Py_ssize_t i, n; cls = PyObject_GetAttrString(obj, "__class__"); if (cls == NULL) @@ -3155,7 +3157,7 @@ PyType_Ready(PyTypeObject *type) { PyObject *dict, *bases; PyTypeObject *base; - int i, n; + Py_ssize_t i, n; if (type->tp_flags & Py_TPFLAGS_READY) { assert(type->tp_dict != NULL); @@ -3340,7 +3342,7 @@ add_subclass(PyTypeObject *base, PyTypeObject *type) static void remove_subclass(PyTypeObject *base, PyTypeObject *type) { - int i; + Py_ssize_t i; PyObject *list, *ref; list = base->tp_subclasses; @@ -3370,9 +3372,10 @@ check_num_args(PyObject *ob, int n) } if (n == PyTuple_GET_SIZE(ob)) return 1; + /* XXX %zd? */ PyErr_Format( PyExc_TypeError, - "expected %d arguments, got %d", n, PyTuple_GET_SIZE(ob)); + "expected %d arguments, got %d", n, (int)PyTuple_GET_SIZE(ob)); return 0; } @@ -3385,10 +3388,10 @@ check_num_args(PyObject *ob, int n) entries, one regular and one with reversed arguments. */ static PyObject * -wrap_inquiry(PyObject *self, PyObject *args, void *wrapped) +wrap_lenfunc(PyObject *self, PyObject *args, void *wrapped) { - inquiry func = (inquiry)wrapped; - int res; + lenfunc func = (lenfunc)wrapped; + Py_ssize_t res; if (!check_num_args(args, 0)) return NULL; @@ -3525,28 +3528,28 @@ wrap_unaryfunc(PyObject *self, PyObject *args, void *wrapped) } static PyObject * -wrap_intargfunc(PyObject *self, PyObject *args, void *wrapped) +wrap_ssizeargfunc(PyObject *self, PyObject *args, void *wrapped) { - intargfunc func = (intargfunc)wrapped; - int i; + ssizeargfunc func = (ssizeargfunc)wrapped; + Py_ssize_t i; - if (!PyArg_ParseTuple(args, "i", &i)) + if (!PyArg_ParseTuple(args, "n", &i)) return NULL; return (*func)(self, i); } -static int +static Py_ssize_t getindex(PyObject *self, PyObject *arg) { - int i; + Py_ssize_t i; - i = PyInt_AsLong(arg); + i = PyInt_AsSsize_t(arg); if (i == -1 && PyErr_Occurred()) return -1; if (i < 0) { PySequenceMethods *sq = self->ob_type->tp_as_sequence; if (sq && sq->sq_length) { - int n = (*sq->sq_length)(self); + Py_ssize_t n = (*sq->sq_length)(self); if (n < 0) return -1; i += n; @@ -3558,9 +3561,9 @@ getindex(PyObject *self, PyObject *arg) static PyObject * wrap_sq_item(PyObject *self, PyObject *args, void *wrapped) { - intargfunc func = (intargfunc)wrapped; + ssizeargfunc func = (ssizeargfunc)wrapped; PyObject *arg; - int i; + Py_ssize_t i; if (PyTuple_GET_SIZE(args) == 1) { arg = PyTuple_GET_ITEM(args, 0); @@ -3575,12 +3578,12 @@ wrap_sq_item(PyObject *self, PyObject *args, void *wrapped) } static PyObject * -wrap_intintargfunc(PyObject *self, PyObject *args, void *wrapped) +wrap_ssizessizeargfunc(PyObject *self, PyObject *args, void *wrapped) { - intintargfunc func = (intintargfunc)wrapped; - int i, j; + ssizessizeargfunc func = (ssizessizeargfunc)wrapped; + Py_ssize_t i, j; - if (!PyArg_ParseTuple(args, "ii", &i, &j)) + if (!PyArg_ParseTuple(args, "nn", &i, &j)) return NULL; return (*func)(self, i, j); } @@ -3588,8 +3591,9 @@ wrap_intintargfunc(PyObject *self, PyObject *args, void *wrapped) static PyObject * wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped) { - intobjargproc func = (intobjargproc)wrapped; - int i, res; + ssizeobjargproc func = (ssizeobjargproc)wrapped; + Py_ssize_t i; + int res; PyObject *arg, *value; if (!PyArg_UnpackTuple(args, "", 2, 2, &arg, &value)) @@ -3607,8 +3611,9 @@ wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped) static PyObject * wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped) { - intobjargproc func = (intobjargproc)wrapped; - int i, res; + ssizeobjargproc func = (ssizeobjargproc)wrapped; + Py_ssize_t i; + int res; PyObject *arg; if (!check_num_args(args, 1)) @@ -3625,13 +3630,14 @@ wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped) } static PyObject * -wrap_intintobjargproc(PyObject *self, PyObject *args, void *wrapped) +wrap_ssizessizeobjargproc(PyObject *self, PyObject *args, void *wrapped) { - intintobjargproc func = (intintobjargproc)wrapped; - int i, j, res; + ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped; + Py_ssize_t i, j; + int res; PyObject *value; - if (!PyArg_ParseTuple(args, "iiO", &i, &j, &value)) + if (!PyArg_ParseTuple(args, "nnO", &i, &j, &value)) return NULL; res = (*func)(self, i, j, value); if (res == -1 && PyErr_Occurred()) @@ -3643,10 +3649,11 @@ wrap_intintobjargproc(PyObject *self, PyObject *args, void *wrapped) static PyObject * wrap_delslice(PyObject *self, PyObject *args, void *wrapped) { - intintobjargproc func = (intintobjargproc)wrapped; - int i, j, res; + ssizessizeobjargproc func = (ssizessizeobjargproc)wrapped; + Py_ssize_t i, j; + int res; - if (!PyArg_ParseTuple(args, "ii", &i, &j)) + if (!PyArg_ParseTuple(args, "nn", &i, &j)) return NULL; res = (*func)(self, i, j, NULL); if (res == -1 && PyErr_Occurred()) @@ -4099,23 +4106,23 @@ FUNCNAME(PyObject *self, ARG1TYPE arg1, ARG2TYPE arg2) \ "(" ARGCODES ")", arg1, arg2); \ } -static int +static Py_ssize_t slot_sq_length(PyObject *self) { static PyObject *len_str; PyObject *res = call_method(self, "__len__", &len_str, "()"); - long temp; - int len; + Py_ssize_t temp; + Py_ssize_t len; if (res == NULL) return -1; - temp = PyInt_AsLong(res); + temp = PyInt_AsSsize_t(res); len = (int)temp; Py_DECREF(res); if (len == -1 && PyErr_Occurred()) return -1; -#if SIZEOF_INT < SIZEOF_LONG - /* Overflow check -- range of PyInt is more than C int */ +#if SIZEOF_SIZE_T < SIZEOF_LONG + /* Overflow check -- range of PyInt is more than C ssize_t */ if (len != temp) { PyErr_SetString(PyExc_OverflowError, "__len__() should return 0 <= outcome < 2**31"); @@ -4133,7 +4140,7 @@ slot_sq_length(PyObject *self) /* Super-optimized version of slot_sq_item. Other slots could do the same... */ static PyObject * -slot_sq_item(PyObject *self, int i) +slot_sq_item(PyObject *self, Py_ssize_t i) { static PyObject *getitem_str; PyObject *func, *args = NULL, *ival = NULL, *retval = NULL; @@ -4175,10 +4182,10 @@ slot_sq_item(PyObject *self, int i) return NULL; } -SLOT2(slot_sq_slice, "__getslice__", int, int, "ii") +SLOT2(slot_sq_slice, "__getslice__", Py_ssize_t, Py_ssize_t, "nn") static int -slot_sq_ass_item(PyObject *self, int index, PyObject *value) +slot_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value) { PyObject *res; static PyObject *delitem_str, *setitem_str; @@ -4196,7 +4203,7 @@ slot_sq_ass_item(PyObject *self, int index, PyObject *value) } static int -slot_sq_ass_slice(PyObject *self, int i, int j, PyObject *value) +slot_sq_ass_slice(PyObject *self, Py_ssize_t i, Py_ssize_t j, PyObject *value) { PyObject *res; static PyObject *delslice_str, *setslice_str; @@ -4428,7 +4435,7 @@ half_compare(PyObject *self, PyObject *other) { PyObject *func, *args, *res; static PyObject *cmp_str; - int c; + Py_ssize_t c; func = lookup_method(self, "__cmp__", &cmp_str); if (func == NULL) { @@ -4806,7 +4813,7 @@ slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject *new_str; PyObject *func; PyObject *newargs, *x; - int i, n; + Py_ssize_t i, n; if (new_str == NULL) { new_str = PyString_InternFromString("__new__"); @@ -4953,7 +4960,7 @@ typedef struct wrapperbase slotdef; "x." NAME "(y) <==> " DOC) static slotdef slotdefs[] = { - SQSLOT("__len__", sq_length, slot_sq_length, wrap_inquiry, + SQSLOT("__len__", sq_length, slot_sq_length, wrap_lenfunc, "x.__len__() <==> len(x)"), /* Heap types defining __add__/__mul__ have sq_concat/sq_repeat == NULL. The logic in abstract.c always falls back to nb_add/nb_multiply in @@ -4962,13 +4969,13 @@ static slotdef slotdefs[] = { test_descr.notimplemented() */ SQSLOT("__add__", sq_concat, NULL, wrap_binaryfunc, "x.__add__(y) <==> x+y"), - SQSLOT("__mul__", sq_repeat, NULL, wrap_intargfunc, + SQSLOT("__mul__", sq_repeat, NULL, wrap_ssizeargfunc, "x.__mul__(n) <==> x*n"), - SQSLOT("__rmul__", sq_repeat, NULL, wrap_intargfunc, + SQSLOT("__rmul__", sq_repeat, NULL, wrap_ssizeargfunc, "x.__rmul__(n) <==> n*x"), SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item, "x.__getitem__(y) <==> x[y]"), - SQSLOT("__getslice__", sq_slice, slot_sq_slice, wrap_intintargfunc, + SQSLOT("__getslice__", sq_slice, slot_sq_slice, wrap_ssizessizeargfunc, "x.__getslice__(i, j) <==> x[i:j]\n\ \n\ Use of negative indices is not supported."), @@ -4977,7 +4984,7 @@ static slotdef slotdefs[] = { SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_delitem, "x.__delitem__(y) <==> del x[y]"), SQSLOT("__setslice__", sq_ass_slice, slot_sq_ass_slice, - wrap_intintobjargproc, + wrap_ssizessizeobjargproc, "x.__setslice__(i, j, y) <==> x[i:j]=y\n\ \n\ Use of negative indices is not supported."), @@ -4990,9 +4997,9 @@ static slotdef slotdefs[] = { SQSLOT("__iadd__", sq_inplace_concat, NULL, wrap_binaryfunc, "x.__iadd__(y) <==> x+=y"), SQSLOT("__imul__", sq_inplace_repeat, NULL, - wrap_intargfunc, "x.__imul__(y) <==> x*=y"), + wrap_ssizeargfunc, "x.__imul__(y) <==> x*=y"), - MPSLOT("__len__", mp_length, slot_mp_length, wrap_inquiry, + MPSLOT("__len__", mp_length, slot_mp_length, wrap_lenfunc, "x.__len__() <==> len(x)"), MPSLOT("__getitem__", mp_subscript, slot_mp_subscript, wrap_binaryfunc, @@ -5152,9 +5159,10 @@ static slotdef slotdefs[] = { proper indirection pointer (as_buffer, etc.); it returns NULL if the indirection pointer is NULL. */ static void ** -slotptr(PyTypeObject *type, int offset) +slotptr(PyTypeObject *type, int ioffset) { char *ptr; + long offset = ioffset; /* Note: this depends on the order of the members of PyHeapTypeObject! */ assert(offset >= 0); @@ -5320,7 +5328,9 @@ slotdef_cmp(const void *aa, const void *bb) if (c != 0) return c; else - return a - b; + /* Cannot use a-b, as this gives off_t, + which may lose precision when converted to int. */ + return (a > b) ? 1 : (a < b) ? -1 : 0; } /* Initialize the slotdefs table by adding interned string objects for the @@ -5417,7 +5427,7 @@ recurse_down_subclasses(PyTypeObject *type, PyObject *name, { PyTypeObject *subclass; PyObject *ref, *subclasses, *dict; - int i, n; + Py_ssize_t i, n; subclasses = type->tp_subclasses; if (subclasses == NULL) @@ -5570,7 +5580,7 @@ super_getattro(PyObject *self, PyObject *name) PyObject *mro, *res, *tmp, *dict; PyTypeObject *starttype; descrgetfunc f; - int i, n; + Py_ssize_t i, n; starttype = su->obj_type; mro = starttype->tp_mro; diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index 037c45c..43ef061 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -119,7 +119,7 @@ PyUnicode_GetMax(void) static int unicode_resize(register PyUnicodeObject *unicode, - int length) + Py_ssize_t length) { void *oldstr; @@ -154,7 +154,8 @@ int unicode_resize(register PyUnicodeObject *unicode, return -1; } unicode->str[length] = 0; - unicode->length = length; + assert(length < INT_MAX); + unicode->length = (int)length; reset: /* Reset the object caches */ @@ -176,7 +177,7 @@ int unicode_resize(register PyUnicodeObject *unicode, */ static -PyUnicodeObject *_PyUnicode_New(int length) +PyUnicodeObject *_PyUnicode_New(Py_ssize_t length) { register PyUnicodeObject *unicode; @@ -225,7 +226,8 @@ PyUnicodeObject *_PyUnicode_New(int length) */ unicode->str[0] = 0; unicode->str[length] = 0; - unicode->length = length; + assert(lengthlength = (int)length; unicode->hash = -1; unicode->defenc = NULL; return unicode; @@ -263,7 +265,7 @@ void unicode_dealloc(register PyUnicodeObject *unicode) } } -int PyUnicode_Resize(PyObject **unicode, int length) +int PyUnicode_Resize(PyObject **unicode, Py_ssize_t length) { register PyUnicodeObject *v; @@ -303,7 +305,7 @@ int PyUnicode_Resize(PyObject **unicode, int length) PyUnicode_Resize(((PyObject **)(unicodevar)), length) PyObject *PyUnicode_FromUnicode(const Py_UNICODE *u, - int size) + Py_ssize_t size) { PyUnicodeObject *unicode; @@ -347,7 +349,7 @@ PyObject *PyUnicode_FromUnicode(const Py_UNICODE *u, #ifdef HAVE_WCHAR_H PyObject *PyUnicode_FromWideChar(register const wchar_t *w, - int size) + Py_ssize_t size) { PyUnicodeObject *unicode; @@ -376,9 +378,9 @@ PyObject *PyUnicode_FromWideChar(register const wchar_t *w, return (PyObject *)unicode; } -int PyUnicode_AsWideChar(PyUnicodeObject *unicode, - register wchar_t *w, - int size) +Py_ssize_t PyUnicode_AsWideChar(PyUnicodeObject *unicode, + wchar_t *w, + Py_ssize_t size) { if (unicode == NULL) { PyErr_BadInternalCall(); @@ -455,7 +457,7 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj, const char *errors) { const char *s = NULL; - int len; + Py_ssize_t len; PyObject *v; if (obj == NULL) { @@ -520,7 +522,7 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj, } PyObject *PyUnicode_Decode(const char *s, - int size, + Py_ssize_t size, const char *encoding, const char *errors) { @@ -588,7 +590,7 @@ PyObject *PyUnicode_AsDecodedObject(PyObject *unicode, } PyObject *PyUnicode_Encode(const Py_UNICODE *s, - int size, + Py_ssize_t size, const char *encoding, const char *errors) { @@ -696,7 +698,7 @@ Py_UNICODE *PyUnicode_AsUnicode(PyObject *unicode) return NULL; } -int PyUnicode_GetSize(PyObject *unicode) +Py_ssize_t PyUnicode_GetSize(PyObject *unicode) { if (!PyUnicode_Check(unicode)) { PyErr_BadArgument(); @@ -742,18 +744,18 @@ int PyUnicode_SetDefaultEncoding(const char *encoding) static int unicode_decode_call_errorhandler(const char *errors, PyObject **errorHandler, const char *encoding, const char *reason, - const char *input, int insize, int *startinpos, int *endinpos, PyObject **exceptionObject, const char **inptr, - PyObject **output, int *outpos, Py_UNICODE **outptr) + const char *input, Py_ssize_t insize, Py_ssize_t *startinpos, Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr, + PyObject **output, Py_ssize_t *outpos, Py_UNICODE **outptr) { - static char *argparse = "O!i;decoding error handler must return (unicode, int) tuple"; + static char *argparse = "O!n;decoding error handler must return (unicode, int) tuple"; PyObject *restuple = NULL; PyObject *repunicode = NULL; - int outsize = PyUnicode_GET_SIZE(*output); - int requiredsize; - int newpos; + Py_ssize_t outsize = PyUnicode_GET_SIZE(*output); + Py_ssize_t requiredsize; + Py_ssize_t newpos; Py_UNICODE *repptr; - int repsize; + Py_ssize_t repsize; int res = -1; if (*errorHandler == NULL) { @@ -789,7 +791,8 @@ int unicode_decode_call_errorhandler(const char *errors, PyObject **errorHandler if (newpos<0) newpos = insize+newpos; if (newpos<0 || newpos>insize) { - PyErr_Format(PyExc_IndexError, "position %d from error handler out of bounds", newpos); + /* XXX %zd? */ + PyErr_Format(PyExc_IndexError, "position %d from error handler out of bounds", (int)newpos); goto onError; } @@ -887,13 +890,13 @@ char utf7_special[128] = { } PyObject *PyUnicode_DecodeUTF7(const char *s, - int size, + Py_ssize_t size, const char *errors) { const char *starts = s; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; const char *e; PyUnicodeObject *unicode; Py_UNICODE *p; @@ -1023,16 +1026,16 @@ onError: PyObject *PyUnicode_EncodeUTF7(const Py_UNICODE *s, - int size, + Py_ssize_t size, int encodeSetO, int encodeWhiteSpace, const char *errors) { PyObject *v; /* It might be possible to tighten this worst case */ - unsigned int cbAllocated = 5 * size; + Py_ssize_t cbAllocated = 5 * size; int inShift = 0; - int i = 0; + Py_ssize_t i = 0; unsigned int bitsleft = 0; unsigned long charsleft = 0; char * out; @@ -1147,22 +1150,22 @@ char utf8_code_length[256] = { }; PyObject *PyUnicode_DecodeUTF8(const char *s, - int size, + Py_ssize_t size, const char *errors) { return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL); } PyObject *PyUnicode_DecodeUTF8Stateful(const char *s, - int size, + Py_ssize_t size, const char *errors, - int *consumed) + Py_ssize_t *consumed) { const char *starts = s; int n; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; const char *e; PyUnicodeObject *unicode; Py_UNICODE *p; @@ -1347,15 +1350,15 @@ onError: */ PyObject * PyUnicode_EncodeUTF8(const Py_UNICODE *s, - int size, + Py_ssize_t size, const char *errors) { #define MAX_SHORT_UNICHARS 300 /* largest size we'll do on the stack */ - int i; /* index into s of next input byte */ + Py_ssize_t i; /* index into s of next input byte */ PyObject *v; /* result string object */ char *p; /* next free byte in output buffer */ - int nallocated; /* number of result bytes allocated */ + Py_ssize_t nallocated; /* number of result bytes allocated */ int nneeded; /* number of result bytes needed */ char stackbuf[MAX_SHORT_UNICHARS * 4]; @@ -1455,7 +1458,7 @@ PyObject *PyUnicode_AsUTF8String(PyObject *unicode) PyObject * PyUnicode_DecodeUTF16(const char *s, - int size, + Py_ssize_t size, const char *errors, int *byteorder) { @@ -1464,15 +1467,15 @@ PyUnicode_DecodeUTF16(const char *s, PyObject * PyUnicode_DecodeUTF16Stateful(const char *s, - int size, + Py_ssize_t size, const char *errors, int *byteorder, - int *consumed) + Py_ssize_t *consumed) { const char *starts = s; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; PyUnicodeObject *unicode; Py_UNICODE *p; const unsigned char *q, *e; @@ -1630,7 +1633,7 @@ onError: PyObject * PyUnicode_EncodeUTF16(const Py_UNICODE *s, - int size, + Py_ssize_t size, const char *errors, int byteorder) { @@ -1716,13 +1719,13 @@ PyObject *PyUnicode_AsUTF16String(PyObject *unicode) static _PyUnicode_Name_CAPI *ucnhash_CAPI = NULL; PyObject *PyUnicode_DecodeUnicodeEscape(const char *s, - int size, + Py_ssize_t size, const char *errors) { const char *starts = s; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; int i; PyUnicodeObject *v; Py_UNICODE *p; @@ -1896,7 +1899,7 @@ PyObject *PyUnicode_DecodeUnicodeEscape(const char *s, /* found a name. look it up in the unicode database */ message = "unknown Unicode character name"; s++; - if (ucnhash_CAPI->getcode(start, s-start-1, &chr)) + if (ucnhash_CAPI->getcode(start, (int)(s-start-1), &chr)) goto store; } } @@ -1962,12 +1965,12 @@ onError: */ static const Py_UNICODE *findchar(const Py_UNICODE *s, - int size, + Py_ssize_t size, Py_UNICODE ch); static PyObject *unicodeescape_string(const Py_UNICODE *s, - int size, + Py_ssize_t size, int quotes) { PyObject *repr; @@ -2093,7 +2096,7 @@ PyObject *unicodeescape_string(const Py_UNICODE *s, } PyObject *PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, - int size) + Py_ssize_t size) { return unicodeescape_string(s, size, 0); } @@ -2111,13 +2114,13 @@ PyObject *PyUnicode_AsUnicodeEscapeString(PyObject *unicode) /* --- Raw Unicode Escape Codec ------------------------------------------- */ PyObject *PyUnicode_DecodeRawUnicodeEscape(const char *s, - int size, + Py_ssize_t size, const char *errors) { const char *starts = s; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; PyUnicodeObject *v; Py_UNICODE *p; const char *end; @@ -2216,7 +2219,7 @@ PyObject *PyUnicode_DecodeRawUnicodeEscape(const char *s, } PyObject *PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, - int size) + Py_ssize_t size) { PyObject *repr; char *p; @@ -2284,13 +2287,13 @@ PyObject *PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode) /* --- Unicode Internal Codec ------------------------------------------- */ PyObject *_PyUnicode_DecodeUnicodeInternal(const char *s, - int size, + Py_ssize_t size, const char *errors) { const char *starts = s; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; PyUnicodeObject *v; Py_UNICODE *p; const char *end; @@ -2361,7 +2364,7 @@ PyObject *_PyUnicode_DecodeUnicodeInternal(const char *s, /* --- Latin-1 Codec ------------------------------------------------------ */ PyObject *PyUnicode_DecodeLatin1(const char *s, - int size, + Py_ssize_t size, const char *errors) { PyUnicodeObject *v; @@ -2391,8 +2394,8 @@ PyObject *PyUnicode_DecodeLatin1(const char *s, /* create or adjust a UnicodeEncodeError */ static void make_encode_exception(PyObject **exceptionObject, const char *encoding, - const Py_UNICODE *unicode, int size, - int startpos, int endpos, + const Py_UNICODE *unicode, Py_ssize_t size, + Py_ssize_t startpos, Py_ssize_t endpos, const char *reason) { if (*exceptionObject == NULL) { @@ -2416,8 +2419,8 @@ static void make_encode_exception(PyObject **exceptionObject, /* raises a UnicodeEncodeError */ static void raise_encode_exception(PyObject **exceptionObject, const char *encoding, - const Py_UNICODE *unicode, int size, - int startpos, int endpos, + const Py_UNICODE *unicode, Py_ssize_t size, + Py_ssize_t startpos, Py_ssize_t endpos, const char *reason) { make_encode_exception(exceptionObject, @@ -2433,11 +2436,11 @@ static void raise_encode_exception(PyObject **exceptionObject, static PyObject *unicode_encode_call_errorhandler(const char *errors, PyObject **errorHandler, const char *encoding, const char *reason, - const Py_UNICODE *unicode, int size, PyObject **exceptionObject, - int startpos, int endpos, - int *newpos) + const Py_UNICODE *unicode, Py_ssize_t size, PyObject **exceptionObject, + Py_ssize_t startpos, Py_ssize_t endpos, + Py_ssize_t *newpos) { - static char *argparse = "O!i;encoding error handler must return (unicode, int) tuple"; + static char *argparse = "O!n;encoding error handler must return (unicode, int) tuple"; PyObject *restuple; PyObject *resunicode; @@ -2470,7 +2473,8 @@ static PyObject *unicode_encode_call_errorhandler(const char *errors, if (*newpos<0) *newpos = size+*newpos; if (*newpos<0 || *newpos>size) { - PyErr_Format(PyExc_IndexError, "position %d from error handler out of bounds", *newpos); + /* XXX %zd? */ + PyErr_Format(PyExc_IndexError, "position %d from error handler out of bounds", (int)*newpos); Py_DECREF(restuple); return NULL; } @@ -2480,7 +2484,7 @@ static PyObject *unicode_encode_call_errorhandler(const char *errors, } static PyObject *unicode_encode_ucs1(const Py_UNICODE *p, - int size, + Py_ssize_t size, const char *errors, int limit) { @@ -2494,8 +2498,8 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p, /* pointer into the output */ char *str; /* current output position */ - int respos = 0; - int ressize; + Py_ssize_t respos = 0; + Py_ssize_t ressize; char *encoding = (limit == 256) ? "latin-1" : "ascii"; char *reason = (limit == 256) ? "ordinal not in range(256)" : "ordinal not in range(128)"; PyObject *errorHandler = NULL; @@ -2524,12 +2528,12 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p, ++p; } else { - int unicodepos = p-startp; - int requiredsize; + Py_ssize_t unicodepos = p-startp; + Py_ssize_t requiredsize; PyObject *repunicode; - int repsize; - int newpos; - int respos; + Py_ssize_t repsize; + Py_ssize_t newpos; + Py_ssize_t respos; Py_UNICODE *uni2; /* startpos for collecting unencodable chars */ const Py_UNICODE *collstart = p; @@ -2655,7 +2659,7 @@ static PyObject *unicode_encode_ucs1(const Py_UNICODE *p, } PyObject *PyUnicode_EncodeLatin1(const Py_UNICODE *p, - int size, + Py_ssize_t size, const char *errors) { return unicode_encode_ucs1(p, size, errors, 256); @@ -2675,15 +2679,15 @@ PyObject *PyUnicode_AsLatin1String(PyObject *unicode) /* --- 7-bit ASCII Codec -------------------------------------------------- */ PyObject *PyUnicode_DecodeASCII(const char *s, - int size, + Py_ssize_t size, const char *errors) { const char *starts = s; PyUnicodeObject *v; Py_UNICODE *p; - int startinpos; - int endinpos; - int outpos; + Py_ssize_t startinpos; + Py_ssize_t endinpos; + Py_ssize_t outpos; const char *e; PyObject *errorHandler = NULL; PyObject *exc = NULL; @@ -2734,7 +2738,7 @@ PyObject *PyUnicode_DecodeASCII(const char *s, } PyObject *PyUnicode_EncodeASCII(const Py_UNICODE *p, - int size, + Py_ssize_t size, const char *errors) { return unicode_encode_ucs1(p, size, errors, 128); @@ -2756,14 +2760,16 @@ PyObject *PyUnicode_AsASCIIString(PyObject *unicode) /* --- MBCS codecs for Windows -------------------------------------------- */ PyObject *PyUnicode_DecodeMBCS(const char *s, - int size, + Py_ssize_t size, const char *errors) { PyUnicodeObject *v; Py_UNICODE *p; + DWORD usize; /* First get the size of the result */ - DWORD usize = MultiByteToWideChar(CP_ACP, 0, s, size, NULL, 0); + assert(size < INT_MAX); + usize = MultiByteToWideChar(CP_ACP, 0, s, (int)size, NULL, 0); if (size > 0 && usize==0) return PyErr_SetFromWindowsErrWithFilename(0, NULL); @@ -2773,7 +2779,7 @@ PyObject *PyUnicode_DecodeMBCS(const char *s, if (usize == 0) return (PyObject *)v; p = PyUnicode_AS_UNICODE(v); - if (0 == MultiByteToWideChar(CP_ACP, 0, s, size, p, usize)) { + if (0 == MultiByteToWideChar(CP_ACP, 0, s, (int)size, p, usize)) { Py_DECREF(v); return PyErr_SetFromWindowsErrWithFilename(0, NULL); } @@ -2782,7 +2788,7 @@ PyObject *PyUnicode_DecodeMBCS(const char *s, } PyObject *PyUnicode_EncodeMBCS(const Py_UNICODE *p, - int size, + Py_ssize_t size, const char *errors) { PyObject *repr; @@ -2794,7 +2800,8 @@ PyObject *PyUnicode_EncodeMBCS(const Py_UNICODE *p, return PyString_FromString(""); /* First get the size of the result */ - mbcssize = WideCharToMultiByte(CP_ACP, 0, p, size, NULL, 0, NULL, NULL); + assert(size extrachars) { /* resize first */ - int oldpos = (int)(p - PyUnicode_AS_UNICODE(v)); - int needed = (targetsize - extrachars) + \ + Py_ssize_t oldpos = p - PyUnicode_AS_UNICODE(v); + Py_ssize_t needed = (targetsize - extrachars) + \ (targetsize << 2); extrachars += needed; if (_PyUnicode_Resize(&v, @@ -3041,7 +3049,7 @@ static PyObject *charmapencode_lookup(Py_UNICODE c, PyObject *mapping) reallocation error occurred. The caller must decref the result */ static PyObject *charmapencode_output(Py_UNICODE c, PyObject *mapping, - PyObject **outobj, int *outpos) + PyObject **outobj, Py_ssize_t *outpos) { PyObject *rep = charmapencode_lookup(c, mapping); @@ -3051,9 +3059,9 @@ PyObject *charmapencode_output(Py_UNICODE c, PyObject *mapping, return rep; else { char *outstart = PyString_AS_STRING(*outobj); - int outsize = PyString_GET_SIZE(*outobj); + Py_ssize_t outsize = PyString_GET_SIZE(*outobj); if (PyInt_Check(rep)) { - int requiredsize = *outpos+1; + Py_ssize_t requiredsize = *outpos+1; if (outsizesize) { - PyErr_Format(PyExc_IndexError, "position %d from error handler out of bounds", *newpos); + /* XXX %zd? */ + PyErr_Format(PyExc_IndexError, "position %d from error handler out of bounds", (int)*newpos); Py_DECREF(restuple); return NULL; } @@ -3426,12 +3438,12 @@ if not reallocate and adjust various state variables. Return 0 on success, -1 on error */ static int charmaptranslate_makespace(PyObject **outobj, Py_UNICODE **outp, - int requiredsize) + Py_ssize_t requiredsize) { - int oldsize = PyUnicode_GET_SIZE(*outobj); + Py_ssize_t oldsize = PyUnicode_GET_SIZE(*outobj); if (requiredsize > oldsize) { /* remember old output position */ - int outpos = *outp-PyUnicode_AS_UNICODE(*outobj); + Py_ssize_t outpos = *outp-PyUnicode_AS_UNICODE(*outobj); /* exponentially overallocate to minimize reallocations */ if (requiredsize < 2 * oldsize) requiredsize = 2 * oldsize; @@ -3449,7 +3461,7 @@ int charmaptranslate_makespace(PyObject **outobj, Py_UNICODE **outp, Return 0 on success, -1 on error. */ static int charmaptranslate_output(const Py_UNICODE *startinp, const Py_UNICODE *curinp, - int insize, PyObject *mapping, PyObject **outobj, Py_UNICODE **outp, + Py_ssize_t insize, PyObject *mapping, PyObject **outobj, Py_UNICODE **outp, PyObject **res) { if (charmaptranslate_lookup(*curinp, mapping, res)) @@ -3465,14 +3477,14 @@ int charmaptranslate_output(const Py_UNICODE *startinp, const Py_UNICODE *curinp *(*outp)++ = (Py_UNICODE)PyInt_AS_LONG(*res); } else if (PyUnicode_Check(*res)) { - int repsize = PyUnicode_GET_SIZE(*res); + Py_ssize_t repsize = PyUnicode_GET_SIZE(*res); if (repsize==1) { /* no overflow check, because we know that the space is enough */ *(*outp)++ = *PyUnicode_AS_UNICODE(*res); } else if (repsize!=0) { /* more than one character */ - int requiredsize = (*outp-PyUnicode_AS_UNICODE(*outobj)) + + Py_ssize_t requiredsize = (*outp-PyUnicode_AS_UNICODE(*outobj)) + (insize - (curinp-startinp)) + repsize - 1; if (charmaptranslate_makespace(outobj, outp, requiredsize)) @@ -3487,7 +3499,7 @@ int charmaptranslate_output(const Py_UNICODE *startinp, const Py_UNICODE *curinp } PyObject *PyUnicode_TranslateCharmap(const Py_UNICODE *p, - int size, + Py_ssize_t size, PyObject *mapping, const char *errors) { @@ -3499,7 +3511,7 @@ PyObject *PyUnicode_TranslateCharmap(const Py_UNICODE *p, /* pointer into the output */ Py_UNICODE *str; /* current output position */ - int respos = 0; + Py_ssize_t respos = 0; char *reason = "character maps to "; PyObject *errorHandler = NULL; PyObject *exc = NULL; @@ -3534,8 +3546,8 @@ PyObject *PyUnicode_TranslateCharmap(const Py_UNICODE *p, ++p; else { /* untranslatable character */ PyObject *repunicode = NULL; /* initialize to prevent gcc warning */ - int repsize; - int newpos; + Py_ssize_t repsize; + Py_ssize_t newpos; Py_UNICODE *uni2; /* startpos for collecting untranslatable chars */ const Py_UNICODE *collstart = p; @@ -3652,7 +3664,7 @@ PyObject *PyUnicode_Translate(PyObject *str, /* --- Decimal Encoder ---------------------------------------------------- */ int PyUnicode_EncodeDecimal(Py_UNICODE *s, - int length, + Py_ssize_t length, char *output, const char *errors) { @@ -3676,8 +3688,8 @@ int PyUnicode_EncodeDecimal(Py_UNICODE *s, register Py_UNICODE ch = *p; int decimal; PyObject *repunicode; - int repsize; - int newpos; + Py_ssize_t repsize; + Py_ssize_t newpos; Py_UNICODE *uni2; Py_UNICODE *collstart; Py_UNICODE *collend; @@ -3783,10 +3795,10 @@ int PyUnicode_EncodeDecimal(Py_UNICODE *s, /* --- Helpers ------------------------------------------------------------ */ static -int count(PyUnicodeObject *self, - int start, - int end, - PyUnicodeObject *substring) +Py_ssize_t count(PyUnicodeObject *self, + Py_ssize_t start, + Py_ssize_t end, + PyUnicodeObject *substring) { int count = 0; @@ -3816,12 +3828,12 @@ int count(PyUnicodeObject *self, return count; } -int PyUnicode_Count(PyObject *str, +Py_ssize_t PyUnicode_Count(PyObject *str, PyObject *substr, - int start, - int end) + Py_ssize_t start, + Py_ssize_t end) { - int result; + Py_ssize_t result; str = PyUnicode_FromObject(str); if (str == NULL) @@ -3842,10 +3854,10 @@ int PyUnicode_Count(PyObject *str, } static -int findstring(PyUnicodeObject *self, +Py_ssize_t findstring(PyUnicodeObject *self, PyUnicodeObject *substring, - int start, - int end, + Py_ssize_t start, + Py_ssize_t end, int direction) { if (start < 0) @@ -3878,13 +3890,13 @@ int findstring(PyUnicodeObject *self, return -1; } -int PyUnicode_Find(PyObject *str, +Py_ssize_t PyUnicode_Find(PyObject *str, PyObject *substr, - int start, - int end, + Py_ssize_t start, + Py_ssize_t end, int direction) { - int result; + Py_ssize_t result; str = PyUnicode_FromObject(str); if (str == NULL) @@ -3906,8 +3918,8 @@ int PyUnicode_Find(PyObject *str, static int tailmatch(PyUnicodeObject *self, PyUnicodeObject *substring, - int start, - int end, + Py_ssize_t start, + Py_ssize_t end, int direction) { if (start < 0) @@ -3940,13 +3952,13 @@ int tailmatch(PyUnicodeObject *self, return 0; } -int PyUnicode_Tailmatch(PyObject *str, +Py_ssize_t PyUnicode_Tailmatch(PyObject *str, PyObject *substr, - int start, - int end, + Py_ssize_t start, + Py_ssize_t end, int direction) { - int result; + Py_ssize_t result; str = PyUnicode_FromObject(str); if (str == NULL) @@ -3967,7 +3979,7 @@ int PyUnicode_Tailmatch(PyObject *str, static const Py_UNICODE *findchar(const Py_UNICODE *s, - int size, + Py_ssize_t size, Py_UNICODE ch) { /* like wcschr, but doesn't stop at NULL characters */ @@ -4011,7 +4023,7 @@ PyObject *fixup(PyUnicodeObject *self, static int fixupper(PyUnicodeObject *self) { - int len = self->length; + Py_ssize_t len = self->length; Py_UNICODE *s = self->str; int status = 0; @@ -4032,7 +4044,7 @@ int fixupper(PyUnicodeObject *self) static int fixlower(PyUnicodeObject *self) { - int len = self->length; + Py_ssize_t len = self->length; Py_UNICODE *s = self->str; int status = 0; @@ -4053,7 +4065,7 @@ int fixlower(PyUnicodeObject *self) static int fixswapcase(PyUnicodeObject *self) { - int len = self->length; + Py_ssize_t len = self->length; Py_UNICODE *s = self->str; int status = 0; @@ -4074,7 +4086,7 @@ int fixswapcase(PyUnicodeObject *self) static int fixcapitalize(PyUnicodeObject *self) { - int len = self->length; + Py_ssize_t len = self->length; Py_UNICODE *s = self->str; int status = 0; @@ -4145,7 +4157,7 @@ PyUnicode_Join(PyObject *separator, PyObject *seq) size_t res_used; /* # used bytes */ Py_UNICODE *res_p; /* pointer to free byte in res's string area */ PyObject *fseq; /* PySequence_Fast(seq) */ - int seqlen; /* len(fseq) -- number of items in sequence */ + Py_ssize_t seqlen; /* len(fseq) -- number of items in sequence */ PyObject *item; int i; @@ -4285,8 +4297,8 @@ PyUnicode_Join(PyObject *separator, PyObject *seq) static PyUnicodeObject *pad(PyUnicodeObject *self, - int left, - int right, + Py_ssize_t left, + Py_ssize_t right, Py_UNICODE fill) { PyUnicodeObject *u; @@ -4338,11 +4350,11 @@ PyUnicodeObject *pad(PyUnicodeObject *self, static PyObject *split_whitespace(PyUnicodeObject *self, PyObject *list, - int maxcount) + Py_ssize_t maxcount) { - register int i; - register int j; - int len = self->length; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len = self->length; PyObject *str; for (i = j = 0; i < len; ) { @@ -4374,9 +4386,9 @@ PyObject *split_whitespace(PyUnicodeObject *self, PyObject *PyUnicode_Splitlines(PyObject *string, int keepends) { - register int i; - register int j; - int len; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len; PyObject *list; PyObject *str; Py_UNICODE *data; @@ -4392,7 +4404,7 @@ PyObject *PyUnicode_Splitlines(PyObject *string, goto onError; for (i = j = 0; i < len; ) { - int eol; + Py_ssize_t eol; /* Find a line and append it */ while (i < len && !Py_UNICODE_ISLINEBREAK(data[i])) @@ -4429,11 +4441,11 @@ static PyObject *split_char(PyUnicodeObject *self, PyObject *list, Py_UNICODE ch, - int maxcount) + Py_ssize_t maxcount) { - register int i; - register int j; - int len = self->length; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len = self->length; PyObject *str; for (i = j = 0; i < len; ) { @@ -4459,12 +4471,12 @@ static PyObject *split_substring(PyUnicodeObject *self, PyObject *list, PyUnicodeObject *substring, - int maxcount) + Py_ssize_t maxcount) { - register int i; - register int j; - int len = self->length; - int sublen = substring->length; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len = self->length; + Py_ssize_t sublen = substring->length; PyObject *str; for (i = j = 0; i <= len - sublen; ) { @@ -4489,11 +4501,11 @@ PyObject *split_substring(PyUnicodeObject *self, static PyObject *rsplit_whitespace(PyUnicodeObject *self, PyObject *list, - int maxcount) + Py_ssize_t maxcount) { - register int i; - register int j; - int len = self->length; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len = self->length; PyObject *str; for (i = j = len - 1; i >= 0; ) { @@ -4526,11 +4538,11 @@ static PyObject *rsplit_char(PyUnicodeObject *self, PyObject *list, Py_UNICODE ch, - int maxcount) + Py_ssize_t maxcount) { - register int i; - register int j; - int len = self->length; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len = self->length; PyObject *str; for (i = j = len - 1; i >= 0; ) { @@ -4556,12 +4568,12 @@ static PyObject *rsplit_substring(PyUnicodeObject *self, PyObject *list, PyUnicodeObject *substring, - int maxcount) + Py_ssize_t maxcount) { - register int i; - register int j; - int len = self->length; - int sublen = substring->length; + register Py_ssize_t i; + register Py_ssize_t j; + Py_ssize_t len = self->length; + Py_ssize_t sublen = substring->length; PyObject *str; for (i = len - sublen, j = len; i >= 0; ) { @@ -4590,7 +4602,7 @@ PyObject *rsplit_substring(PyUnicodeObject *self, static PyObject *split(PyUnicodeObject *self, PyUnicodeObject *substring, - int maxcount) + Py_ssize_t maxcount) { PyObject *list; @@ -4619,7 +4631,7 @@ PyObject *split(PyUnicodeObject *self, static PyObject *rsplit(PyUnicodeObject *self, PyUnicodeObject *substring, - int maxcount) + Py_ssize_t maxcount) { PyObject *list; @@ -4649,7 +4661,7 @@ static PyObject *replace(PyUnicodeObject *self, PyUnicodeObject *str1, PyUnicodeObject *str2, - int maxcount) + Py_ssize_t maxcount) { PyUnicodeObject *u; @@ -4686,7 +4698,7 @@ PyObject *replace(PyUnicodeObject *self, } } else { - int n, i; + Py_ssize_t n, i; Py_UNICODE *p; /* replace strings */ @@ -4778,7 +4790,7 @@ unicode_capwords(PyUnicodeObject *self) { PyObject *list; PyObject *item; - int i; + Py_ssize_t i; /* Split into words */ list = split(self, NULL, -1); @@ -4840,8 +4852,8 @@ done using the specified fill character (default is a space)"); static PyObject * unicode_center(PyUnicodeObject *self, PyObject *args) { - int marg, left; - int width; + Py_ssize_t marg, left; + Py_ssize_t width; Py_UNICODE fillchar = ' '; if (!PyArg_ParseTuple(args, "i|O&:center", &width, convert_uc, &fillchar)) @@ -4879,7 +4891,7 @@ static short utf16Fixup[32] = static int unicode_compare(PyUnicodeObject *str1, PyUnicodeObject *str2) { - int len1, len2; + Py_ssize_t len1, len2; Py_UNICODE *s1 = str1->str; Py_UNICODE *s2 = str2->str; @@ -4913,7 +4925,7 @@ unicode_compare(PyUnicodeObject *str1, PyUnicodeObject *str2) static int unicode_compare(PyUnicodeObject *str1, PyUnicodeObject *str2) { - register int len1, len2; + register Py_ssize_t len1, len2; Py_UNICODE *s1 = str1->str; Py_UNICODE *s2 = str2->str; @@ -4975,7 +4987,8 @@ int PyUnicode_Contains(PyObject *container, PyObject *element) { PyUnicodeObject *u = NULL, *v = NULL; - int result, size; + int result; + Py_ssize_t size; register const Py_UNICODE *lhs, *end, *rhs; /* Coerce the two arguments */ @@ -5076,8 +5089,8 @@ static PyObject * unicode_count(PyUnicodeObject *self, PyObject *args) { PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *result; if (!PyArg_ParseTuple(args, "O|O&O&:count", &substring, @@ -5190,7 +5203,7 @@ unicode_expandtabs(PyUnicodeObject *self, PyObject *args) Py_UNICODE *e; Py_UNICODE *p; Py_UNICODE *q; - int i, j; + Py_ssize_t i, j; PyUnicodeObject *u; int tabsize = 8; @@ -5253,8 +5266,8 @@ static PyObject * unicode_find(PyUnicodeObject *self, PyObject *args) { PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *result; if (!PyArg_ParseTuple(args, "O|O&O&:find", &substring, @@ -5265,14 +5278,14 @@ unicode_find(PyUnicodeObject *self, PyObject *args) if (substring == NULL) return NULL; - result = PyInt_FromLong(findstring(self, substring, start, end, 1)); + result = PyInt_FromSsize_t(findstring(self, substring, start, end, 1)); Py_DECREF(substring); return result; } static PyObject * -unicode_getitem(PyUnicodeObject *self, int index) +unicode_getitem(PyUnicodeObject *self, Py_ssize_t index) { if (index < 0 || index >= self->length) { PyErr_SetString(PyExc_IndexError, "string index out of range"); @@ -5291,7 +5304,7 @@ unicode_hash(PyUnicodeObject *self) strings and Unicode objects behave in the same way as dictionary keys. */ - register int len; + register Py_ssize_t len; register Py_UNICODE *p; register long x; @@ -5317,10 +5330,10 @@ Like S.find() but raise ValueError when the substring is not found."); static PyObject * unicode_index(PyUnicodeObject *self, PyObject *args) { - int result; + Py_ssize_t result; PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; if (!PyArg_ParseTuple(args, "O|O&O&:index", &substring, _PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end)) @@ -5338,7 +5351,7 @@ unicode_index(PyUnicodeObject *self, PyObject *args) PyErr_SetString(PyExc_ValueError, "substring not found"); return NULL; } - return PyInt_FromLong(result); + return PyInt_FromSsize_t(result); } PyDoc_STRVAR(islower__doc__, @@ -5643,7 +5656,7 @@ unicode_join(PyObject *self, PyObject *data) return PyUnicode_Join(self, data); } -static int +static Py_ssize_t unicode_length(PyUnicodeObject *self) { return self->length; @@ -5707,10 +5720,10 @@ PyObject * _PyUnicode_XStrip(PyUnicodeObject *self, int striptype, PyObject *sepobj) { Py_UNICODE *s = PyUnicode_AS_UNICODE(self); - int len = PyUnicode_GET_SIZE(self); + Py_ssize_t len = PyUnicode_GET_SIZE(self); Py_UNICODE *sep = PyUnicode_AS_UNICODE(sepobj); - int seplen = PyUnicode_GET_SIZE(sepobj); - int i, j; + Py_ssize_t seplen = PyUnicode_GET_SIZE(sepobj); + Py_ssize_t i, j; i = 0; if (striptype != RIGHTSTRIP) { @@ -5740,7 +5753,7 @@ static PyObject * do_strip(PyUnicodeObject *self, int striptype) { Py_UNICODE *s = PyUnicode_AS_UNICODE(self); - int len = PyUnicode_GET_SIZE(self), i, j; + Py_ssize_t len = PyUnicode_GET_SIZE(self), i, j; i = 0; if (striptype != RIGHTSTRIP) { @@ -5851,11 +5864,11 @@ unicode_rstrip(PyUnicodeObject *self, PyObject *args) static PyObject* -unicode_repeat(PyUnicodeObject *str, int len) +unicode_repeat(PyUnicodeObject *str, Py_ssize_t len) { PyUnicodeObject *u; Py_UNICODE *p; - int nchars; + Py_ssize_t nchars; size_t nbytes; if (len < 0) @@ -5899,7 +5912,7 @@ unicode_repeat(PyUnicodeObject *str, int len) PyObject *PyUnicode_Replace(PyObject *obj, PyObject *subobj, PyObject *replobj, - int maxcount) + Py_ssize_t maxcount) { PyObject *self; PyObject *str1; @@ -5942,10 +5955,10 @@ unicode_replace(PyUnicodeObject *self, PyObject *args) { PyUnicodeObject *str1; PyUnicodeObject *str2; - int maxcount = -1; + Py_ssize_t maxcount = -1; PyObject *result; - if (!PyArg_ParseTuple(args, "OO|i:replace", &str1, &str2, &maxcount)) + if (!PyArg_ParseTuple(args, "OO|n:replace", &str1, &str2, &maxcount)) return NULL; str1 = (PyUnicodeObject *)PyUnicode_FromObject((PyObject *)str1); if (str1 == NULL) @@ -5984,8 +5997,8 @@ static PyObject * unicode_rfind(PyUnicodeObject *self, PyObject *args) { PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *result; if (!PyArg_ParseTuple(args, "O|O&O&:rfind", &substring, @@ -5996,7 +6009,7 @@ unicode_rfind(PyUnicodeObject *self, PyObject *args) if (substring == NULL) return NULL; - result = PyInt_FromLong(findstring(self, substring, start, end, -1)); + result = PyInt_FromSsize_t(findstring(self, substring, start, end, -1)); Py_DECREF(substring); return result; @@ -6010,10 +6023,10 @@ Like S.rfind() but raise ValueError when the substring is not found."); static PyObject * unicode_rindex(PyUnicodeObject *self, PyObject *args) { - int result; + Py_ssize_t result; PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; if (!PyArg_ParseTuple(args, "O|O&O&:rindex", &substring, _PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end)) @@ -6030,7 +6043,7 @@ unicode_rindex(PyUnicodeObject *self, PyObject *args) PyErr_SetString(PyExc_ValueError, "substring not found"); return NULL; } - return PyInt_FromLong(result); + return PyInt_FromSsize_t(result); } PyDoc_STRVAR(rjust__doc__, @@ -6057,7 +6070,7 @@ unicode_rjust(PyUnicodeObject *self, PyObject *args) } static PyObject* -unicode_slice(PyUnicodeObject *self, int start, int end) +unicode_slice(PyUnicodeObject *self, Py_ssize_t start, Py_ssize_t end) { /* standard clamping */ if (start < 0) @@ -6080,7 +6093,7 @@ unicode_slice(PyUnicodeObject *self, int start, int end) PyObject *PyUnicode_Split(PyObject *s, PyObject *sep, - int maxsplit) + Py_ssize_t maxsplit) { PyObject *result; @@ -6114,9 +6127,9 @@ static PyObject* unicode_split(PyUnicodeObject *self, PyObject *args) { PyObject *substring = Py_None; - int maxcount = -1; + Py_ssize_t maxcount = -1; - if (!PyArg_ParseTuple(args, "|Oi:split", &substring, &maxcount)) + if (!PyArg_ParseTuple(args, "|On:split", &substring, &maxcount)) return NULL; if (substring == Py_None) @@ -6129,7 +6142,7 @@ unicode_split(PyUnicodeObject *self, PyObject *args) PyObject *PyUnicode_RSplit(PyObject *s, PyObject *sep, - int maxsplit) + Py_ssize_t maxsplit) { PyObject *result; @@ -6164,9 +6177,9 @@ static PyObject* unicode_rsplit(PyUnicodeObject *self, PyObject *args) { PyObject *substring = Py_None; - int maxcount = -1; + Py_ssize_t maxcount = -1; - if (!PyArg_ParseTuple(args, "|Oi:rsplit", &substring, &maxcount)) + if (!PyArg_ParseTuple(args, "|On:rsplit", &substring, &maxcount)) return NULL; if (substring == Py_None) @@ -6251,11 +6264,11 @@ of the specified width. The string x is never truncated."); static PyObject * unicode_zfill(PyUnicodeObject *self, PyObject *args) { - int fill; + Py_ssize_t fill; PyUnicodeObject *u; - int width; - if (!PyArg_ParseTuple(args, "i:zfill", &width)) + Py_ssize_t width; + if (!PyArg_ParseTuple(args, "n:zfill", &width)) return NULL; if (self->length >= width) { @@ -6306,8 +6319,8 @@ unicode_startswith(PyUnicodeObject *self, PyObject *args) { PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *result; if (!PyArg_ParseTuple(args, "O|O&O&:startswith", &substring, @@ -6337,8 +6350,8 @@ unicode_endswith(PyUnicodeObject *self, PyObject *args) { PyUnicodeObject *substring; - int start = 0; - int end = INT_MAX; + Py_ssize_t start = 0; + Py_ssize_t end = INT_MAX; PyObject *result; if (!PyArg_ParseTuple(args, "O|O&O&:endswith", &substring, @@ -6439,11 +6452,11 @@ static PyNumberMethods unicode_as_number = { }; static PySequenceMethods unicode_as_sequence = { - (inquiry) unicode_length, /* sq_length */ + (lenfunc) unicode_length, /* sq_length */ (binaryfunc) PyUnicode_Concat, /* sq_concat */ - (intargfunc) unicode_repeat, /* sq_repeat */ - (intargfunc) unicode_getitem, /* sq_item */ - (intintargfunc) unicode_slice, /* sq_slice */ + (ssizeargfunc) unicode_repeat, /* sq_repeat */ + (ssizeargfunc) unicode_getitem, /* sq_item */ + (ssizessizeargfunc) unicode_slice, /* sq_slice */ 0, /* sq_ass_item */ 0, /* sq_ass_slice */ (objobjproc)PyUnicode_Contains, /*sq_contains*/ @@ -6452,20 +6465,15 @@ static PySequenceMethods unicode_as_sequence = { static PyObject* unicode_subscript(PyUnicodeObject* self, PyObject* item) { - if (PyInt_Check(item)) { - long i = PyInt_AS_LONG(item); - if (i < 0) - i += PyUnicode_GET_SIZE(self); - return unicode_getitem(self, i); - } else if (PyLong_Check(item)) { - long i = PyLong_AsLong(item); + if (PyInt_Check(item) || PyLong_Check(item)) { + Py_ssize_t i = PyInt_AsSsize_t(item); if (i == -1 && PyErr_Occurred()) return NULL; if (i < 0) i += PyUnicode_GET_SIZE(self); return unicode_getitem(self, i); } else if (PySlice_Check(item)) { - int start, stop, step, slicelength, cur, i; + Py_ssize_t start, stop, step, slicelength, cur, i; Py_UNICODE* source_buf; Py_UNICODE* result_buf; PyObject* result; @@ -6499,14 +6507,14 @@ unicode_subscript(PyUnicodeObject* self, PyObject* item) } static PyMappingMethods unicode_as_mapping = { - (inquiry)unicode_length, /* mp_length */ + (lenfunc)unicode_length, /* mp_length */ (binaryfunc)unicode_subscript, /* mp_subscript */ (objobjargproc)0, /* mp_ass_subscript */ }; -static int +static Py_ssize_t unicode_buffer_getreadbuf(PyUnicodeObject *self, - int index, + Py_ssize_t index, const void **ptr) { if (index != 0) { @@ -6518,8 +6526,8 @@ unicode_buffer_getreadbuf(PyUnicodeObject *self, return PyUnicode_GET_DATA_SIZE(self); } -static int -unicode_buffer_getwritebuf(PyUnicodeObject *self, int index, +static Py_ssize_t +unicode_buffer_getwritebuf(PyUnicodeObject *self, Py_ssize_t index, const void **ptr) { PyErr_SetString(PyExc_TypeError, @@ -6529,7 +6537,7 @@ unicode_buffer_getwritebuf(PyUnicodeObject *self, int index, static int unicode_buffer_getsegcount(PyUnicodeObject *self, - int *lenp) + Py_ssize_t *lenp) { if (lenp) *lenp = PyUnicode_GET_DATA_SIZE(self); @@ -6538,7 +6546,7 @@ unicode_buffer_getsegcount(PyUnicodeObject *self, static int unicode_buffer_getcharbuf(PyUnicodeObject *self, - int index, + Py_ssize_t index, const void **ptr) { PyObject *str; @@ -6558,9 +6566,9 @@ unicode_buffer_getcharbuf(PyUnicodeObject *self, /* Helpers for PyUnicode_Format() */ static PyObject * -getnextarg(PyObject *args, int arglen, int *p_argidx) +getnextarg(PyObject *args, Py_ssize_t arglen, Py_ssize_t *p_argidx) { - int argidx = *p_argidx; + Py_ssize_t argidx = *p_argidx; if (argidx < arglen) { (*p_argidx)++; if (arglen < 0) @@ -6579,11 +6587,11 @@ getnextarg(PyObject *args, int arglen, int *p_argidx) #define F_ALT (1<<3) #define F_ZERO (1<<4) -static int +static Py_ssize_t strtounicode(Py_UNICODE *buffer, const char *charbuffer) { - register long i; - long len = strlen(charbuffer); + register Py_ssize_t i; + Py_ssize_t len = strlen(charbuffer); for (i = len - 1; i >= 0; i--) buffer[i] = (Py_UNICODE) charbuffer[i]; @@ -6594,14 +6602,16 @@ static int doubletounicode(Py_UNICODE *buffer, size_t len, const char *format, double x) { PyOS_ascii_formatd((char *)buffer, len, format, x); - return strtounicode(buffer, (char *)buffer); + return Py_SAFE_DOWNCAST(strtounicode(buffer, (char *)buffer), + Py_ssize_t, int); } static int longtounicode(Py_UNICODE *buffer, size_t len, const char *format, long x) { PyOS_snprintf((char *)buffer, len, format, x); - return strtounicode(buffer, (char *)buffer); + return Py_SAFE_DOWNCAST(strtounicode(buffer, (char *)buffer), + Py_ssize_t, int); } /* XXX To save some code duplication, formatfloat/long/int could have been @@ -6620,6 +6630,7 @@ formatfloat(Py_UNICODE *buf, worst case length = 3 + 10 (len of INT_MAX) + 1 = 14 (use 20)*/ char fmt[20]; double x; + Py_ssize_t result; x = PyFloat_AsDouble(v); if (x == -1.0 && PyErr_Occurred()) @@ -6691,6 +6702,7 @@ formatint(Py_UNICODE *buf, char fmt[64]; /* plenty big enough! */ char *sign; long x; + Py_ssize_t result; x = PyInt_AsLong(v); if (x == -1 && PyErr_Occurred()) @@ -6814,7 +6826,7 @@ PyObject *PyUnicode_Format(PyObject *format, PyObject *args) { Py_UNICODE *fmt, *res; - int fmtcnt, rescnt, reslen, arglen, argidx; + Py_ssize_t fmtcnt, rescnt, reslen, arglen, argidx; int args_owned = 0; PyUnicodeObject *result = NULL; PyObject *dict = NULL; @@ -6863,7 +6875,7 @@ PyObject *PyUnicode_Format(PyObject *format, else { /* Got a format specifier */ int flags = 0; - int width = -1; + Py_ssize_t width = -1; int prec = -1; Py_UNICODE c = '\0'; Py_UNICODE fill; @@ -6871,13 +6883,13 @@ PyObject *PyUnicode_Format(PyObject *format, PyObject *temp = NULL; Py_UNICODE *pbuf; Py_UNICODE sign; - int len; + Py_ssize_t len; Py_UNICODE formatbuf[FORMATBUFLEN]; /* For format{float,int,char}() */ fmt++; if (*fmt == '(') { Py_UNICODE *keystart; - int keylen; + Py_ssize_t keylen; PyObject *key; int pcount = 1; @@ -7235,10 +7247,10 @@ PyObject *PyUnicode_Format(PyObject *format, } static PyBufferProcs unicode_as_buffer = { - (getreadbufferproc) unicode_buffer_getreadbuf, - (getwritebufferproc) unicode_buffer_getwritebuf, - (getsegcountproc) unicode_buffer_getsegcount, - (getcharbufferproc) unicode_buffer_getcharbuf, + (readbufferproc) unicode_buffer_getreadbuf, + (writebufferproc) unicode_buffer_getwritebuf, + (segcountproc) unicode_buffer_getsegcount, + (charbufferproc) unicode_buffer_getcharbuf, }; static PyObject * @@ -7269,7 +7281,7 @@ static PyObject * unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyUnicodeObject *tmp, *pnew; - int n; + Py_ssize_t n; assert(PyType_IsSubtype(type, &PyUnicode_Type)); tmp = (PyUnicodeObject *)unicode_new(&PyUnicode_Type, args, kwds); diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c index fd99a63..39c5db2 100644 --- a/Objects/weakrefobject.c +++ b/Objects/weakrefobject.c @@ -520,7 +520,7 @@ proxy_dealloc(PyWeakReference *self) /* sequence slots */ static PyObject * -proxy_slice(PyWeakReference *proxy, int i, int j) +proxy_slice(PyWeakReference *proxy, Py_ssize_t i, Py_ssize_t j) { if (!proxy_checkref(proxy)) return NULL; @@ -528,7 +528,7 @@ proxy_slice(PyWeakReference *proxy, int i, int j) } static int -proxy_ass_slice(PyWeakReference *proxy, int i, int j, PyObject *value) +proxy_ass_slice(PyWeakReference *proxy, Py_ssize_t i, Py_ssize_t j, PyObject *value) { if (!proxy_checkref(proxy)) return -1; @@ -546,7 +546,7 @@ proxy_contains(PyWeakReference *proxy, PyObject *value) /* mapping slots */ -static int +static Py_ssize_t proxy_length(PyWeakReference *proxy) { if (!proxy_checkref(proxy)) @@ -625,18 +625,18 @@ static PyNumberMethods proxy_as_number = { }; static PySequenceMethods proxy_as_sequence = { - (inquiry)proxy_length, /*sq_length*/ + (lenfunc)proxy_length, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ 0, /*sq_item*/ - (intintargfunc)proxy_slice, /*sq_slice*/ + (ssizessizeargfunc)proxy_slice, /*sq_slice*/ 0, /*sq_ass_item*/ - (intintobjargproc)proxy_ass_slice, /*sq_ass_slice*/ + (ssizessizeobjargproc)proxy_ass_slice, /*sq_ass_slice*/ (objobjproc)proxy_contains, /* sq_contains */ }; static PyMappingMethods proxy_as_mapping = { - (inquiry)proxy_length, /*mp_length*/ + (lenfunc)proxy_length, /*mp_length*/ (binaryfunc)proxy_getitem, /*mp_subscript*/ (objobjargproc)proxy_setitem, /*mp_ass_subscript*/ }; @@ -886,7 +886,7 @@ PyObject_ClearWeakRefs(PyObject *object) } if (*list != NULL) { PyWeakReference *current = *list; - int count = _PyWeakref_GetWeakrefCount(current); + Py_ssize_t count = _PyWeakref_GetWeakrefCount(current); int restore_error = PyErr_Occurred() ? 1 : 0; PyObject *err_type, *err_value, *err_tb; @@ -904,7 +904,7 @@ PyObject_ClearWeakRefs(PyObject *object) } else { PyObject *tuple = PyTuple_New(count * 2); - int i = 0; + Py_ssize_t i = 0; for (i = 0; i < count; ++i) { PyWeakReference *next = current->wr_next; diff --git a/PC/getpathp.c b/PC/getpathp.c index 3b4f452..0701d73 100644 --- a/PC/getpathp.c +++ b/PC/getpathp.c @@ -169,7 +169,8 @@ join(char *buffer, char *stuff) static int gotlandmark(char *landmark) { - int n, ok; + int ok; + Py_ssize_t n; n = strlen(prefix); join(prefix, landmark); @@ -302,10 +303,11 @@ getpythonregpath(HKEY keyBase, int skipcore) dataSize--; } if (ppPaths[index]) { - int len = _tcslen(ppPaths[index]); + Py_ssize_t len = _tcslen(ppPaths[index]); _tcsncpy(szCur, ppPaths[index], len); szCur += len; - dataSize -= len; + assert(dataSize > len); + dataSize -= (int)len; } } if (skipcore) @@ -632,7 +634,7 @@ calculate_path(void) char lookBuf[MAXPATHLEN+1]; char *look = buf - 1; /* 'buf' is at the end of the buffer */ while (1) { - int nchars; + Py_ssize_t nchars; char *lookEnd = look; /* 'look' will end up one character before the start of the path in question - even if this diff --git a/PC/import_nt.c b/PC/import_nt.c index f937df8..e7d152a 100644 --- a/PC/import_nt.c +++ b/PC/import_nt.c @@ -18,7 +18,7 @@ extern const char *PyWin_DLLVersionString; FILE *PyWin_FindRegisteredModule(const char *moduleName, struct filedescr **ppFileDesc, char *pathBuf, - int pathLen) + Py_ssize_t pathLen) { char *moduleKey; const char keyPrefix[] = "Software\\Python\\PythonCore\\"; @@ -53,13 +53,14 @@ FILE *PyWin_FindRegisteredModule(const char *moduleName, "Software\\Python\\PythonCore\\%s\\Modules\\%s%s", PyWin_DLLVersionString, moduleName, debugString); - modNameSize = pathLen; + assert(pathLen < INT_MAX); + modNameSize = (int)pathLen; regStat = RegQueryValue(keyBase, moduleKey, pathBuf, &modNameSize); if (regStat != ERROR_SUCCESS) { /* No user setting - lookup in machine settings */ keyBase = HKEY_LOCAL_MACHINE; /* be anal - failure may have reset size param */ - modNameSize = pathLen; + modNameSize = (int)pathLen; regStat = RegQueryValue(keyBase, moduleKey, pathBuf, &modNameSize); diff --git a/PC/pyconfig.h b/PC/pyconfig.h index bb16cfb..149cd6f 100644 --- a/PC/pyconfig.h +++ b/PC/pyconfig.h @@ -117,6 +117,14 @@ MS_CORE_DLL. #endif #endif /* MS_WIN64 */ +/* Define like size_t, omitting the "unsigned" */ +#ifdef MS_WIN64 +typedef __int64 ssize_t; +#else +typedef _W64 int ssize_t; +#endif +#define HAVE_SSIZE_T 1 + #if defined(MS_WIN32) && !defined(MS_WIN64) #ifdef _M_IX86 #define COMPILER _Py_PASTE_VERSION("32 bit (Intel)") @@ -253,6 +261,7 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ # define SIZEOF_OFF_T 4 # define SIZEOF_FPOS_T 8 # define SIZEOF_HKEY 8 +# define SIZEOF_SIZE_T 8 /* configure.in defines HAVE_LARGEFILE_SUPPORT iff HAVE_LONG_LONG, sizeof(off_t) > sizeof(long), and sizeof(PY_LONG_LONG) >= sizeof(off_t). On Win64 the second condition is not true, but if fpos_t replaces off_t @@ -267,6 +276,7 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ # define SIZEOF_OFF_T 4 # define SIZEOF_FPOS_T 8 # define SIZEOF_HKEY 4 +# define SIZEOF_SIZE_T 4 #endif #ifdef _DEBUG diff --git a/Parser/parsetok.c b/Parser/parsetok.c index 2b1255f..48236a7 100644 --- a/Parser/parsetok.c +++ b/Parser/parsetok.c @@ -185,8 +185,9 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret, if (tok->lineno <= 1 && tok->done == E_EOF) err_ret->error = E_EOF; err_ret->lineno = tok->lineno; - err_ret->offset = tok->cur - tok->buf; if (tok->buf != NULL) { + assert(tok->cur - tok->buf < INT_MAX); + err_ret->offset = (int)(tok->cur - tok->buf); size_t len = tok->inp - tok->buf; err_ret->text = (char *) PyObject_MALLOC(len + 1); if (err_ret->text != NULL) { diff --git a/Parser/tokenizer.c b/Parser/tokenizer.c index 3b1d6a6..646a7c1 100644 --- a/Parser/tokenizer.c +++ b/Parser/tokenizer.c @@ -170,7 +170,7 @@ error_ret(struct tok_state *tok) /* XXX */ } static char * -new_string(const char *s, int len) +new_string(const char *s, Py_ssize_t len) { char* result = PyMem_NEW(char, len + 1); if (result != NULL) { @@ -206,9 +206,9 @@ get_normal_name(char *s) /* for utf-8 and latin-1 */ /* Return the coding spec in S, or NULL if none is found. */ static char * -get_coding_spec(const char *s, int size) +get_coding_spec(const char *s, Py_ssize_t size) { - int i; + Py_ssize_t i; /* Coding spec must be in a comment, and that comment must be * the only statement on the source code line. */ for (i = 0; i < size - 6; i++) { @@ -253,7 +253,7 @@ get_coding_spec(const char *s, int size) Return 1 on success, 0 on failure. */ static int -check_coding_spec(const char* line, int size, struct tok_state *tok, +check_coding_spec(const char* line, Py_ssize_t size, struct tok_state *tok, int set_readline(struct tok_state *, const char *)) { char * cs; @@ -820,7 +820,7 @@ tok_nextc(register struct tok_state *tok) } else { int done = 0; - int cur = 0; + Py_ssize_t cur = 0; char *pt; if (tok->start == NULL) { if (tok->buf == NULL) { @@ -854,10 +854,10 @@ tok_nextc(register struct tok_state *tok) tok->lineno++; /* Read until '\n' or EOF */ while (!done) { - int curstart = tok->start == NULL ? -1 : - tok->start - tok->buf; - int curvalid = tok->inp - tok->buf; - int newsize = curvalid + BUFSIZ; + Py_ssize_t curstart = tok->start == NULL ? -1 : + tok->start - tok->buf; + Py_ssize_t curvalid = tok->inp - tok->buf; + Py_ssize_t newsize = curvalid + BUFSIZ; char *newbuf = tok->buf; PyMem_RESIZE(newbuf, char, newsize); if (newbuf == NULL) { @@ -1390,7 +1390,7 @@ tok_get(register struct tok_state *tok, char **p_start, char **p_end) letter_quote: /* String */ if (c == '\'' || c == '"') { - int quote2 = tok->cur - tok->start + 1; + Py_ssize_t quote2 = tok->cur - tok->start + 1; int quote = c; int triple = 0; int tripcount = 0; diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c index 362294f..4f607d6 100644 --- a/Python/bltinmodule.c +++ b/Python/bltinmodule.c @@ -405,7 +405,7 @@ builtin_compile(PyObject *self, PyObject *args) int supplied_flags = 0; PyCompilerFlags cf; PyObject *result = NULL, *cmd, *tmp = NULL; - int length; + Py_ssize_t length; if (!PyArg_ParseTuple(args, "Oss|ii:compile", &cmd, &filename, &startstr, &supplied_flags, &dont_inherit)) @@ -824,7 +824,7 @@ builtin_map(PyObject *self, PyObject *args) PyObject *func, *result; sequence *seqs = NULL, *sqp; - int n, len; + Py_ssize_t n, len; register int i, j; n = PyTuple_Size(args); @@ -1163,12 +1163,12 @@ In the second form, the callable is called until it returns the sentinel."); static PyObject * builtin_len(PyObject *self, PyObject *v) { - long res; + Py_ssize_t res; res = PyObject_Size(v); if (res < 0 && PyErr_Occurred()) return NULL; - return PyInt_FromLong(res); + return PyInt_FromSsize_t(res); } PyDoc_STRVAR(len_doc, @@ -2346,8 +2346,8 @@ static PyObject * filtertuple(PyObject *func, PyObject *tuple) { PyObject *result; - register int i, j; - int len = PyTuple_Size(tuple); + Py_ssize_t i, j; + Py_ssize_t len = PyTuple_Size(tuple); if (len == 0) { if (PyTuple_CheckExact(tuple)) @@ -2417,9 +2417,9 @@ static PyObject * filterstring(PyObject *func, PyObject *strobj) { PyObject *result; - register int i, j; - int len = PyString_Size(strobj); - int outlen = len; + Py_ssize_t i, j; + Py_ssize_t len = PyString_Size(strobj); + Py_ssize_t outlen = len; if (func == Py_None) { /* If it's a real string we can return the original, diff --git a/Python/ceval.c b/Python/ceval.c index 501a9a0..0f2b173 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -599,7 +599,7 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throw) /* Code access macros */ -#define INSTR_OFFSET() (next_instr - first_instr) +#define INSTR_OFFSET() ((int)(next_instr - first_instr)) #define NEXTOP() (*next_instr++) #define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2]) #define PEEKARG() ((next_instr[2]<<8) + next_instr[1]) @@ -637,7 +637,9 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throw) /* Stack manipulation macros */ -#define STACK_LEVEL() (stack_pointer - f->f_valuestack) +/* The stack can grow at most MAXINT deep, as co_nlocals and + co_stacksize are ints. */ +#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack)) #define EMPTY() (STACK_LEVEL() == 0) #define TOP() (stack_pointer[-1]) #define SECOND() (stack_pointer[-2]) @@ -3857,7 +3859,7 @@ ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk) called by the SLICE opcode with v and/or w equal to NULL. */ int -_PyEval_SliceIndex(PyObject *v, int *pi) +_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi) { if (v != NULL) { long x; @@ -3906,6 +3908,7 @@ _PyEval_SliceIndex(PyObject *v, int *pi) return 0; } /* Truncate -- very long indices are truncated anyway */ + /* XXX truncate by ssize maximum */ if (x > INT_MAX) x = INT_MAX; else if (x < -INT_MAX) @@ -3925,7 +3928,7 @@ apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */ PySequenceMethods *sq = tp->tp_as_sequence; if (sq && sq->sq_slice && ISINT(v) && ISINT(w)) { - int ilow = 0, ihigh = INT_MAX; + Py_ssize_t ilow = 0, ihigh = INT_MAX; if (!_PyEval_SliceIndex(v, &ilow)) return NULL; if (!_PyEval_SliceIndex(w, &ihigh)) @@ -3952,7 +3955,7 @@ assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x) PySequenceMethods *sq = tp->tp_as_sequence; if (sq && sq->sq_slice && ISINT(v) && ISINT(w)) { - int ilow = 0, ihigh = INT_MAX; + Py_ssize_t ilow = 0, ihigh = INT_MAX; if (!_PyEval_SliceIndex(v, &ilow)) return -1; if (!_PyEval_SliceIndex(w, &ihigh)) diff --git a/Python/codecs.c b/Python/codecs.c index 5c521fb..2fcd6c5 100644 --- a/Python/codecs.c +++ b/Python/codecs.c @@ -460,7 +460,7 @@ PyObject *PyCodec_StrictErrors(PyObject *exc) #ifdef Py_USING_UNICODE PyObject *PyCodec_IgnoreErrors(PyObject *exc) { - int end; + Py_ssize_t end; if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) { if (PyUnicodeEncodeError_GetEnd(exc, &end)) return NULL; @@ -478,16 +478,16 @@ PyObject *PyCodec_IgnoreErrors(PyObject *exc) return NULL; } /* ouch: passing NULL, 0, pos gives None instead of u'' */ - return Py_BuildValue("(u#i)", &end, 0, end); + return Py_BuildValue("(u#n)", &end, 0, end); } PyObject *PyCodec_ReplaceErrors(PyObject *exc) { PyObject *restuple; - int start; - int end; - int i; + Py_ssize_t start; + Py_ssize_t end; + Py_ssize_t i; if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) { PyObject *res; @@ -502,7 +502,7 @@ PyObject *PyCodec_ReplaceErrors(PyObject *exc) for (p = PyUnicode_AS_UNICODE(res), i = start; i= 0); @@ -407,7 +407,7 @@ static int tuple_of_constants(unsigned char *codestr, int n, PyObject *consts) { PyObject *newconst, *constant; - int i, arg, len_consts; + Py_ssize_t i, arg, len_consts; /* Pre-conditions */ assert(PyList_CheckExact(consts)); @@ -458,7 +458,8 @@ static int fold_binops_on_constants(unsigned char *codestr, PyObject *consts) { PyObject *newconst, *v, *w; - int len_consts, opcode, size; + Py_ssize_t len_consts, size; + int opcode; /* Pre-conditions */ assert(PyList_CheckExact(consts)); @@ -551,7 +552,8 @@ static int fold_unaryops_on_constants(unsigned char *codestr, PyObject *consts) { PyObject *newconst=NULL, *v; - int len_consts, opcode; + Py_ssize_t len_consts; + int opcode; /* Pre-conditions */ assert(PyList_CheckExact(consts)); @@ -653,7 +655,8 @@ markblocks(unsigned char *code, int len) static PyObject * optimize_code(PyObject *code, PyObject* consts, PyObject *names, PyObject *lineno_obj) { - int i, j, codelen, nops, h, adj; + Py_ssize_t i, j, codelen; + int nops, h, adj; int tgt, tgttgt, opcode; unsigned char *codestr = NULL; unsigned char *lineno; @@ -989,7 +992,8 @@ static void compiler_display_symbols(PyObject *name, PyObject *symbols) { PyObject *key, *value; - int flags, pos = 0; + int flags; + Py_ssize_t pos = 0; fprintf(stderr, "block %s\n", PyString_AS_STRING(name)); while (PyDict_Next(symbols, &pos, &key, &value)) { @@ -1498,7 +1502,7 @@ static int compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o) { PyObject *t, *v; - int arg; + Py_ssize_t arg; /* necessary to make sure types aren't coerced (e.g., int and long) */ t = PyTuple_Pack(2, o, o->ob_type); @@ -4032,7 +4036,7 @@ static PyObject * dict_keys_inorder(PyObject *dict, int offset) { PyObject *tuple, *k, *v; - int i, pos = 0, size = PyDict_Size(dict); + Py_ssize_t i, pos = 0, size = PyDict_Size(dict); tuple = PyTuple_New(size); if (tuple == NULL) diff --git a/Python/exceptions.c b/Python/exceptions.c index 2e7c820..58e7c94 100644 --- a/Python/exceptions.c +++ b/Python/exceptions.c @@ -910,27 +910,34 @@ static PyMethodDef KeyError_methods[] = { #ifdef Py_USING_UNICODE static -int get_int(PyObject *exc, const char *name, int *value) +int get_int(PyObject *exc, const char *name, Py_ssize_t *value) { PyObject *attr = PyObject_GetAttrString(exc, (char *)name); if (!attr) return -1; - if (!PyInt_Check(attr)) { + if (PyInt_Check(attr)) { + *value = PyInt_AS_LONG(attr); + } else if (PyLong_Check(attr)) { + *value = (size_t)PyLong_AsLongLong(attr); + if (*value == -1) { + Py_DECREF(attr); + return -1; + } + } else { PyErr_Format(PyExc_TypeError, "%.200s attribute must be int", name); Py_DECREF(attr); return -1; } - *value = PyInt_AS_LONG(attr); Py_DECREF(attr); return 0; } static -int set_int(PyObject *exc, const char *name, int value) +int set_ssize_t(PyObject *exc, const char *name, Py_ssize_t value) { - PyObject *obj = PyInt_FromLong(value); + PyObject *obj = PyInt_FromSsize_t(value); int result; if (!obj) @@ -940,7 +947,6 @@ int set_int(PyObject *exc, const char *name, int value) return result; } - static PyObject *get_string(PyObject *exc, const char *name) { @@ -1011,16 +1017,16 @@ PyObject *PyUnicodeTranslateError_GetObject(PyObject *exc) return get_unicode(exc, "object"); } -int PyUnicodeEncodeError_GetStart(PyObject *exc, int *start) +int PyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start) { if (!get_int(exc, "start", start)) { PyObject *object = PyUnicodeEncodeError_GetObject(exc); - int size; + Py_ssize_t size; if (!object) return -1; size = PyUnicode_GET_SIZE(object); if (*start<0) - *start = 0; + *start = 0; /*XXX check for values <0*/ if (*start>=size) *start = size-1; Py_DECREF(object); @@ -1030,11 +1036,11 @@ int PyUnicodeEncodeError_GetStart(PyObject *exc, int *start) } -int PyUnicodeDecodeError_GetStart(PyObject *exc, int *start) +int PyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start) { if (!get_int(exc, "start", start)) { PyObject *object = PyUnicodeDecodeError_GetObject(exc); - int size; + Py_ssize_t size; if (!object) return -1; size = PyString_GET_SIZE(object); @@ -1049,35 +1055,35 @@ int PyUnicodeDecodeError_GetStart(PyObject *exc, int *start) } -int PyUnicodeTranslateError_GetStart(PyObject *exc, int *start) +int PyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start) { return PyUnicodeEncodeError_GetStart(exc, start); } -int PyUnicodeEncodeError_SetStart(PyObject *exc, int start) +int PyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start) { - return set_int(exc, "start", start); + return set_ssize_t(exc, "start", start); } -int PyUnicodeDecodeError_SetStart(PyObject *exc, int start) +int PyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start) { - return set_int(exc, "start", start); + return set_ssize_t(exc, "start", start); } -int PyUnicodeTranslateError_SetStart(PyObject *exc, int start) +int PyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start) { - return set_int(exc, "start", start); + return set_ssize_t(exc, "start", start); } -int PyUnicodeEncodeError_GetEnd(PyObject *exc, int *end) +int PyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end) { if (!get_int(exc, "end", end)) { PyObject *object = PyUnicodeEncodeError_GetObject(exc); - int size; + Py_ssize_t size; if (!object) return -1; size = PyUnicode_GET_SIZE(object); @@ -1092,11 +1098,11 @@ int PyUnicodeEncodeError_GetEnd(PyObject *exc, int *end) } -int PyUnicodeDecodeError_GetEnd(PyObject *exc, int *end) +int PyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end) { if (!get_int(exc, "end", end)) { PyObject *object = PyUnicodeDecodeError_GetObject(exc); - int size; + Py_ssize_t size; if (!object) return -1; size = PyString_GET_SIZE(object); @@ -1111,27 +1117,27 @@ int PyUnicodeDecodeError_GetEnd(PyObject *exc, int *end) } -int PyUnicodeTranslateError_GetEnd(PyObject *exc, int *start) +int PyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start) { return PyUnicodeEncodeError_GetEnd(exc, start); } -int PyUnicodeEncodeError_SetEnd(PyObject *exc, int end) +int PyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end) { - return set_int(exc, "end", end); + return set_ssize_t(exc, "end", end); } -int PyUnicodeDecodeError_SetEnd(PyObject *exc, int end) +int PyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end) { - return set_int(exc, "end", end); + return set_ssize_t(exc, "end", end); } -int PyUnicodeTranslateError_SetEnd(PyObject *exc, int end) +int PyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end) { - return set_int(exc, "end", end); + return set_ssize_t(exc, "end", end); } @@ -1229,8 +1235,8 @@ UnicodeEncodeError__str__(PyObject *self, PyObject *arg) { PyObject *encodingObj = NULL; PyObject *objectObj = NULL; - int start; - int end; + Py_ssize_t start; + Py_ssize_t end; PyObject *reasonObj = NULL; char buffer[1000]; PyObject *result = NULL; @@ -1270,11 +1276,12 @@ UnicodeEncodeError__str__(PyObject *self, PyObject *arg) ); } else { + /* XXX %zd? */ PyOS_snprintf(buffer, sizeof(buffer), "'%.400s' codec can't encode characters in position %d-%d: %.400s", PyString_AS_STRING(encodingObj), - start, - end-1, + (int)start, + (int)(end-1), PyString_AS_STRING(reasonObj) ); } @@ -1295,10 +1302,10 @@ static PyMethodDef UnicodeEncodeError_methods[] = { PyObject * PyUnicodeEncodeError_Create( - const char *encoding, const Py_UNICODE *object, int length, - int start, int end, const char *reason) + const char *encoding, const Py_UNICODE *object, Py_ssize_t length, + Py_ssize_t start, Py_ssize_t end, const char *reason) { - return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#iis", + return PyObject_CallFunction(PyExc_UnicodeEncodeError, "su#nns", encoding, object, length, start, end, reason); } @@ -1314,8 +1321,8 @@ UnicodeDecodeError__str__(PyObject *self, PyObject *arg) { PyObject *encodingObj = NULL; PyObject *objectObj = NULL; - int start; - int end; + Py_ssize_t start; + Py_ssize_t end; PyObject *reasonObj = NULL; char buffer[1000]; PyObject *result = NULL; @@ -1338,20 +1345,22 @@ UnicodeDecodeError__str__(PyObject *self, PyObject *arg) goto error; if (end==start+1) { + /* XXX %zd? */ PyOS_snprintf(buffer, sizeof(buffer), "'%.400s' codec can't decode byte 0x%02x in position %d: %.400s", PyString_AS_STRING(encodingObj), ((int)PyString_AS_STRING(objectObj)[start])&0xff, - start, + (int)start, PyString_AS_STRING(reasonObj) ); } else { + /* XXX %zd? */ PyOS_snprintf(buffer, sizeof(buffer), "'%.400s' codec can't decode bytes in position %d-%d: %.400s", PyString_AS_STRING(encodingObj), - start, - end-1, + (int)start, + (int)(end-1), PyString_AS_STRING(reasonObj) ); } @@ -1372,11 +1381,14 @@ static PyMethodDef UnicodeDecodeError_methods[] = { PyObject * PyUnicodeDecodeError_Create( - const char *encoding, const char *object, int length, - int start, int end, const char *reason) + const char *encoding, const char *object, Py_ssize_t length, + Py_ssize_t start, Py_ssize_t end, const char *reason) { + assert(length < INT_MAX); + assert(start < INT_MAX); + assert(end < INT_MAX); return PyObject_CallFunction(PyExc_UnicodeDecodeError, "ss#iis", - encoding, object, length, start, end, reason); + encoding, object, (int)length, (int)start, (int)end, reason); } @@ -1427,8 +1439,8 @@ static PyObject * UnicodeTranslateError__str__(PyObject *self, PyObject *arg) { PyObject *objectObj = NULL; - int start; - int end; + Py_ssize_t start; + Py_ssize_t end; PyObject *reasonObj = NULL; char buffer[1000]; PyObject *result = NULL; @@ -1450,6 +1462,7 @@ UnicodeTranslateError__str__(PyObject *self, PyObject *arg) if (end==start+1) { int badchar = (int)PyUnicode_AS_UNICODE(objectObj)[start]; char *format; + /* XXX %zd? */ if (badchar <= 0xff) format = "can't translate character u'\\x%02x' in position %d: %.400s"; else if (badchar <= 0xffff) @@ -1459,15 +1472,16 @@ UnicodeTranslateError__str__(PyObject *self, PyObject *arg) PyOS_snprintf(buffer, sizeof(buffer), format, badchar, - start, + (int)start, PyString_AS_STRING(reasonObj) ); } else { + /* XXX %zd? */ PyOS_snprintf(buffer, sizeof(buffer), "can't translate characters in position %d-%d: %.400s", - start, - end-1, + (int)start, + (int)(end-1), PyString_AS_STRING(reasonObj) ); } @@ -1487,8 +1501,8 @@ static PyMethodDef UnicodeTranslateError_methods[] = { PyObject * PyUnicodeTranslateError_Create( - const Py_UNICODE *object, int length, - int start, int end, const char *reason) + const Py_UNICODE *object, Py_ssize_t length, + Py_ssize_t start, Py_ssize_t end, const char *reason) { return PyObject_CallFunction(PyExc_UnicodeTranslateError, "u#iis", object, length, start, end, reason); @@ -1749,7 +1763,7 @@ void _PyExc_Init(void) { char *modulename = "exceptions"; - int modnamesz = strlen(modulename); + Py_ssize_t modnamesz = strlen(modulename); int i; PyObject *me, *mydict, *bltinmod, *bdict, *doc, *args; diff --git a/Python/getargs.c b/Python/getargs.c index 9bcf9bc..0615577 100644 --- a/Python/getargs.c +++ b/Python/getargs.c @@ -15,21 +15,24 @@ int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *, int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *, const char *, const char **, va_list); +#define FLAG_COMPAT 1 +#define FLAG_SIZE_T 2 + /* Forward */ static int vgetargs1(PyObject *, const char *, va_list *, int); static void seterror(int, const char *, int *, const char *, const char *); -static char *convertitem(PyObject *, const char **, va_list *, int *, char *, - size_t, PyObject **); -static char *converttuple(PyObject *, const char **, va_list *, +static char *convertitem(PyObject *, const char **, va_list *, int, int *, + char *, size_t, PyObject **); +static char *converttuple(PyObject *, const char **, va_list *, int, int *, char *, size_t, int, PyObject **); -static char *convertsimple(PyObject *, const char **, va_list *, char *, +static char *convertsimple(PyObject *, const char **, va_list *, int, char *, size_t, PyObject **); -static int convertbuffer(PyObject *, void **p, char **); +static Py_ssize_t convertbuffer(PyObject *, void **p, char **); static int vgetargskeywords(PyObject *, PyObject *, - const char *, const char **, va_list *); -static char *skipitem(const char **, va_list *); + const char *, const char **, va_list *, int); +static char *skipitem(const char **, va_list *, int); int PyArg_Parse(PyObject *args, const char *format, ...) @@ -38,7 +41,19 @@ PyArg_Parse(PyObject *args, const char *format, ...) va_list va; va_start(va, format); - retval = vgetargs1(args, format, &va, 1); + retval = vgetargs1(args, format, &va, FLAG_COMPAT); + va_end(va); + return retval; +} + +int +_PyArg_Parse_SizeT(PyObject *args, char *format, ...) +{ + int retval; + va_list va; + + va_start(va, format); + retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T); va_end(va); return retval; } @@ -56,6 +71,18 @@ PyArg_ParseTuple(PyObject *args, const char *format, ...) return retval; } +int +_PyArg_ParseTuple_SizeT(PyObject *args, char *format, ...) +{ + int retval; + va_list va; + + va_start(va, format); + retval = vgetargs1(args, format, &va, FLAG_SIZE_T); + va_end(va); + return retval; +} + int PyArg_VaParse(PyObject *args, const char *format, va_list va) @@ -75,6 +102,24 @@ PyArg_VaParse(PyObject *args, const char *format, va_list va) return vgetargs1(args, format, &lva, 0); } +int +_PyArg_VaParse_SizeT(PyObject *args, char *format, va_list va) +{ + va_list lva; + +#ifdef VA_LIST_IS_ARRAY + memcpy(lva, va, sizeof(va_list)); +#else +#ifdef __va_copy + __va_copy(lva, va); +#else + lva = va; +#endif +#endif + + return vgetargs1(args, format, &lva, FLAG_SIZE_T); +} + /* Handle cleanup of allocated memory in case of exception */ @@ -120,7 +165,7 @@ cleanreturn(int retval, PyObject *freelist) static int -vgetargs1(PyObject *args, const char *format, va_list *p_va, int compat) +vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags) { char msgbuf[256]; int levels[32]; @@ -134,8 +179,10 @@ vgetargs1(PyObject *args, const char *format, va_list *p_va, int compat) int i, len; char *msg; PyObject *freelist = NULL; - + int compat = flags & FLAG_COMPAT; + assert(compat || (args != (PyObject*)NULL)); + flags = flags & ~FLAG_COMPAT; while (endfmt == 0) { int c = *format++; @@ -204,8 +251,8 @@ vgetargs1(PyObject *args, const char *format, va_list *p_va, int compat) PyErr_SetString(PyExc_TypeError, msgbuf); return 0; } - msg = convertitem(args, &format, p_va, levels, msgbuf, - sizeof(msgbuf), &freelist); + msg = convertitem(args, &format, p_va, flags, levels, + msgbuf, sizeof(msgbuf), &freelist); if (msg == NULL) return cleanreturn(1, freelist); seterror(levels[0], msg, levels+1, fname, message); @@ -248,7 +295,8 @@ vgetargs1(PyObject *args, const char *format, va_list *p_va, int compat) if (*format == '|') format++; msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va, - levels, msgbuf, sizeof(msgbuf), &freelist); + flags, levels, msgbuf, + sizeof(msgbuf), &freelist); if (msg) { seterror(i+1, msg, levels, fname, message); return cleanreturn(0, freelist); @@ -325,8 +373,9 @@ seterror(int iarg, const char *msg, int *levels, const char *fname, */ static char * -converttuple(PyObject *arg, const char **p_format, va_list *p_va, int *levels, - char *msgbuf, size_t bufsize, int toplevel, PyObject **freelist) +converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags, + int *levels, char *msgbuf, size_t bufsize, int toplevel, + PyObject **freelist) { int level = 0; int n = 0; @@ -375,8 +424,8 @@ converttuple(PyObject *arg, const char **p_format, va_list *p_va, int *levels, char *msg; PyObject *item; item = PySequence_GetItem(arg, i); - msg = convertitem(item, &format, p_va, levels+1, msgbuf, - bufsize, freelist); + msg = convertitem(item, &format, p_va, flags, levels+1, + msgbuf, bufsize, freelist); /* PySequence_GetItem calls tp->sq_item, which INCREFs */ Py_XDECREF(item); if (msg != NULL) { @@ -393,22 +442,22 @@ converttuple(PyObject *arg, const char **p_format, va_list *p_va, int *levels, /* Convert a single item. */ static char * -convertitem(PyObject *arg, const char **p_format, va_list *p_va, int *levels, - char *msgbuf, size_t bufsize, PyObject **freelist) +convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags, + int *levels, char *msgbuf, size_t bufsize, PyObject **freelist) { char *msg; const char *format = *p_format; if (*format == '(' /* ')' */) { format++; - msg = converttuple(arg, &format, p_va, levels, msgbuf, + msg = converttuple(arg, &format, p_va, flags, levels, msgbuf, bufsize, 0, freelist); if (msg == NULL) format++; } else { - msg = convertsimple(arg, &format, p_va, msgbuf, bufsize, - freelist); + msg = convertsimple(arg, &format, p_va, flags, + msgbuf, bufsize, freelist); if (msg != NULL) levels[0] = 0; } @@ -460,9 +509,16 @@ float_argument_error(PyObject *arg) */ static char * -convertsimple(PyObject *arg, const char **p_format, va_list *p_va, +convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags, char *msgbuf, size_t bufsize, PyObject **freelist) { + /* For # codes */ +#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\ + if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \ + else q=va_arg(*p_va, int*); +#define STORE_SIZE(s) if (flags & FLAG_SIZE_T) *q2=s; else *q=s; +#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q) + const char *format = *p_format; char c = *format++; #ifdef Py_USING_UNICODE @@ -544,7 +600,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, *p = (unsigned short) ival; break; } - + case 'i': {/* signed int */ int *p = va_arg(*p_va, int *); long ival; @@ -582,6 +638,21 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, break; } + case 'n': /* Py_ssize_t */ +#if SIZEOF_SIZE_T != SIZEOF_LONG + { + Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *); + Py_ssize_t ival; + if (float_argument_error(arg)) + return converterr("integer", arg, msgbuf, bufsize); + ival = PyInt_AsSsize_t(arg); + if (ival == -1 && PyErr_Occurred()) + return converterr("integer", arg, msgbuf, bufsize); + *p = ival; + break; + } +#endif + /* Fall through from 'n' to 'l' if Py_ssize_t is int */ case 'l': {/* long int */ long *p = va_arg(*p_va, long *); long ival; @@ -679,11 +750,11 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, case 's': {/* string */ if (*format == '#') { void **p = (void **)va_arg(*p_va, char **); - int *q = va_arg(*p_va, int *); + FETCH_SIZE; if (PyString_Check(arg)) { *p = PyString_AS_STRING(arg); - *q = PyString_GET_SIZE(arg); + STORE_SIZE(PyString_GET_SIZE(arg)); } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { @@ -692,15 +763,15 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, return converterr(CONV_UNICODE, arg, msgbuf, bufsize); *p = PyString_AS_STRING(uarg); - *q = PyString_GET_SIZE(uarg); + STORE_SIZE(PyString_GET_SIZE(uarg)); } #endif else { /* any buffer-like object */ char *buf; - int count = convertbuffer(arg, p, &buf); + Py_ssize_t count = convertbuffer(arg, p, &buf); if (count < 0) return converterr(buf, arg, msgbuf, bufsize); - *q = count; + STORE_SIZE(count); } format++; } else { @@ -729,15 +800,15 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, case 'z': {/* string, may be NULL (None) */ if (*format == '#') { /* any buffer-like object */ void **p = (void **)va_arg(*p_va, char **); - int *q = va_arg(*p_va, int *); + FETCH_SIZE; if (arg == Py_None) { *p = 0; - *q = 0; + STORE_SIZE(0); } else if (PyString_Check(arg)) { *p = PyString_AS_STRING(arg); - *q = PyString_GET_SIZE(arg); + STORE_SIZE(PyString_GET_SIZE(arg)); } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(arg)) { @@ -746,15 +817,15 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, return converterr(CONV_UNICODE, arg, msgbuf, bufsize); *p = PyString_AS_STRING(uarg); - *q = PyString_GET_SIZE(uarg); + STORE_SIZE(PyString_GET_SIZE(uarg)); } #endif else { /* any buffer-like object */ char *buf; - int count = convertbuffer(arg, p, &buf); + Py_ssize_t count = convertbuffer(arg, p, &buf); if (count < 0) return converterr(buf, arg, msgbuf, bufsize); - *q = count; + STORE_SIZE(count); } format++; } else { @@ -777,7 +848,8 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, return converterr("string or None", arg, msgbuf, bufsize); if (*format == '#') { - int *q = va_arg(*p_va, int *); + FETCH_SIZE; + assert(0); // redundant with if-case if (arg == Py_None) *q = 0; else @@ -883,10 +955,10 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, trailing 0-byte */ - int *buffer_len = va_arg(*p_va, int *); + FETCH_SIZE; format++; - if (buffer_len == NULL) { + if (q == NULL && q2 == NULL) { Py_DECREF(s); return converterr( "(buffer_len is NULL)", @@ -907,7 +979,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, arg, msgbuf, bufsize); } } else { - if (size + 1 > *buffer_len) { + if (size + 1 > BUFFER_LEN) { Py_DECREF(s); return converterr( "(buffer overflow)", @@ -917,7 +989,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, memcpy(*buffer, PyString_AS_STRING(s), size + 1); - *buffer_len = size; + STORE_SIZE(size); } else { /* Using a 0-terminated buffer: @@ -961,17 +1033,17 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, case 'u': {/* raw unicode buffer (Py_UNICODE *) */ if (*format == '#') { /* any buffer-like object */ void **p = (void **)va_arg(*p_va, char **); - int *q = va_arg(*p_va, int *); + FETCH_SIZE; if (PyUnicode_Check(arg)) { *p = PyUnicode_AS_UNICODE(arg); - *q = PyUnicode_GET_SIZE(arg); + STORE_SIZE(PyUnicode_GET_SIZE(arg)); } else { char *buf; - int count = convertbuffer(arg, p, &buf); + Py_ssize_t count = convertbuffer(arg, p, &buf); if (count < 0) return converterr(buf, arg, msgbuf, bufsize); - *q = count/(sizeof(Py_UNICODE)); + STORE_SIZE(count/(sizeof(Py_UNICODE))); } format++; } else { @@ -1061,9 +1133,8 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, if ((count = pb->bf_getwritebuffer(arg, 0, p)) < 0) return converterr("(unspecified)", arg, msgbuf, bufsize); if (*format == '#') { - int *q = va_arg(*p_va, int *); - - *q = count; + FETCH_SIZE; + STORE_SIZE(count); format++; } break; @@ -1094,7 +1165,10 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, count = pb->bf_getcharbuffer(arg, 0, p); if (count < 0) return converterr("(unspecified)", arg, msgbuf, bufsize); - *va_arg(*p_va, int *) = count; + { + FETCH_SIZE; + STORE_SIZE(count); + } break; } @@ -1107,11 +1181,11 @@ convertsimple(PyObject *arg, const char **p_format, va_list *p_va, return NULL; } -static int +static Py_ssize_t convertbuffer(PyObject *arg, void **p, char **errmsg) { PyBufferProcs *pb = arg->ob_type->tp_as_buffer; - int count; + Py_ssize_t count; if (pb == NULL || pb->bf_getreadbuffer == NULL || pb->bf_getsegcount == NULL) { @@ -1151,7 +1225,32 @@ PyArg_ParseTupleAndKeywords(PyObject *args, } va_start(va, kwlist); - retval = vgetargskeywords(args, keywords, format, kwlist, &va); + retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0); + va_end(va); + return retval; +} + +int +_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args, + PyObject *keywords, + const char *format, + const char **kwlist, ...) +{ + int retval; + va_list va; + + if ((args == NULL || !PyTuple_Check(args)) || + (keywords != NULL && !PyDict_Check(keywords)) || + format == NULL || + kwlist == NULL) + { + PyErr_BadInternalCall(); + return 0; + } + + va_start(va, kwlist); + retval = vgetargskeywords(args, keywords, format, + kwlist, &va, FLAG_SIZE_T); va_end(va); return retval; } @@ -1185,14 +1284,47 @@ PyArg_VaParseTupleAndKeywords(PyObject *args, #endif #endif - retval = vgetargskeywords(args, keywords, format, kwlist, &lva); + retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0); + return retval; +} + +int +_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args, + PyObject *keywords, + const char *format, + const char **kwlist, va_list va) +{ + int retval; + va_list lva; + + if ((args == NULL || !PyTuple_Check(args)) || + (keywords != NULL && !PyDict_Check(keywords)) || + format == NULL || + kwlist == NULL) + { + PyErr_BadInternalCall(); + return 0; + } + +#ifdef VA_LIST_IS_ARRAY + memcpy(lva, va, sizeof(va_list)); +#else +#ifdef __va_copy + __va_copy(lva, va); +#else + lva = va; +#endif +#endif + + retval = vgetargskeywords(args, keywords, format, + kwlist, &lva, FLAG_SIZE_T); return retval; } static int vgetargskeywords(PyObject *args, PyObject *keywords, const char *format, - const char **kwlist, va_list *p_va) + const char **kwlist, va_list *p_va, int flags) { char msgbuf[512]; int levels[32]; @@ -1327,7 +1459,8 @@ vgetargskeywords(PyObject *args, PyObject *keywords, const char *format, if (*format == '|') format++; msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va, - levels, msgbuf, sizeof(msgbuf), &freelist); + flags, levels, msgbuf, sizeof(msgbuf), + &freelist); if (msg) { seterror(i+1, msg, levels, fname, message); return cleanreturn(0, freelist); @@ -1347,8 +1480,8 @@ vgetargskeywords(PyObject *args, PyObject *keywords, const char *format, item = PyDict_GetItemString(keywords, kwlist[i]); if (item != NULL) { Py_INCREF(item); - msg = convertitem(item, &format, p_va, levels, msgbuf, - sizeof(msgbuf), &freelist); + msg = convertitem(item, &format, p_va, flags, levels, + msgbuf, sizeof(msgbuf), &freelist); Py_DECREF(item); if (msg) { seterror(i+1, msg, levels, fname, message); @@ -1361,7 +1494,7 @@ vgetargskeywords(PyObject *args, PyObject *keywords, const char *format, else if (PyErr_Occurred()) return cleanreturn(0, freelist); else { - msg = skipitem(&format, p_va); + msg = skipitem(&format, p_va, flags); if (msg) { seterror(i+1, msg, levels, fname, message); return cleanreturn(0, freelist); @@ -1372,7 +1505,7 @@ vgetargskeywords(PyObject *args, PyObject *keywords, const char *format, /* make sure there are no extraneous keyword arguments */ if (nkeywords > 0) { PyObject *key, *value; - int pos = 0; + Py_ssize_t pos = 0; while (PyDict_Next(keywords, &pos, &key, &value)) { int match = 0; char *ks; @@ -1403,7 +1536,7 @@ vgetargskeywords(PyObject *args, PyObject *keywords, const char *format, static char * -skipitem(const char **p_format, va_list *p_va) +skipitem(const char **p_format, va_list *p_va, int flags) { const char *format = *p_format; char c = *format++; @@ -1435,6 +1568,12 @@ skipitem(const char **p_format, va_list *p_va) (void) va_arg(*p_va, void *); break; } + + case 'n': /* Py_ssize_t */ + { + (void) va_arg(*p_va, Py_ssize_t *); + break; + } /* string codes */ @@ -1458,7 +1597,10 @@ skipitem(const char **p_format, va_list *p_va) { (void) va_arg(*p_va, char **); if (*format == '#') { - (void) va_arg(*p_va, int *); + if (flags & FLAG_SIZE_T) + (void) va_arg(*p_va, Py_ssize_t *); + else + (void) va_arg(*p_va, int *); format++; } break; diff --git a/Python/import.c b/Python/import.c index 8bd25f7..e019a17 100644 --- a/Python/import.c +++ b/Python/import.c @@ -351,7 +351,7 @@ static char* sys_files[] = { void PyImport_Cleanup(void) { - int pos, ndone; + Py_ssize_t pos, ndone; char *name; PyObject *key, *value, *dict; PyInterpreterState *interp = PyThreadState_GET()->interp; @@ -689,7 +689,7 @@ make_compiled_pathname(char *pathname, char *buf, size_t buflen) Doesn't set an exception. */ static FILE * -check_compiled_module(char *pathname, long mtime, char *cpathname) +check_compiled_module(char *pathname, time_t mtime, char *cpathname) { FILE *fp; long magic; @@ -805,10 +805,11 @@ open_exclusive(char *filename) |O_BINARY /* necessary for Windows */ #endif #ifdef __VMS - , 0666, "ctxt=bin", "shr=nil"); + , 0666, "ctxt=bin", "shr=nil" #else - , 0666); + , 0666 #endif + ); if (fd < 0) return NULL; return fdopen(fd, "wb"); @@ -825,7 +826,7 @@ open_exclusive(char *filename) remove the file. */ static void -write_compiled_module(PyCodeObject *co, char *cpathname, long mtime) +write_compiled_module(PyCodeObject *co, char *cpathname, time_t mtime) { FILE *fp; @@ -850,6 +851,7 @@ write_compiled_module(PyCodeObject *co, char *cpathname, long mtime) } /* Now write the true mtime */ fseek(fp, 4L, 0); + assert(mtime < LONG_MAX); PyMarshal_WriteLongToFile(mtime, fp, Py_MARSHAL_VERSION); fflush(fp); fclose(fp); @@ -1061,10 +1063,10 @@ get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks, #ifdef MS_COREDLL extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **, - char *, int); + char *, Py_ssize_t); #endif -static int case_ok(char *, int, int, char *); +static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *); static int find_init_module(char *); /* Forward */ static struct filedescr importhookdescr = {"", "", IMP_HOOK}; @@ -1372,7 +1374,7 @@ PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd) return fd->type == PY_SOURCE || fd->type == PY_COMPILED; } -/* case_ok(char* buf, int len, int namelen, char* name) +/* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name) * The arguments here are tricky, best shown by example: * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0 * ^ ^ ^ ^ @@ -1420,7 +1422,7 @@ PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd) #endif static int -case_ok(char *buf, int len, int namelen, char *name) +case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name) { /* Pick a platform-specific implementation; the sequence of #if's here should * match the sequence just above. @@ -1891,12 +1893,12 @@ PyImport_ImportModule(const char *name) } /* Forward declarations for helper routines */ -static PyObject *get_parent(PyObject *globals, char *buf, int *p_buflen); +static PyObject *get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen); static PyObject *load_next(PyObject *mod, PyObject *altmod, - char **p_name, char *buf, int *p_buflen); + char **p_name, char *buf, Py_ssize_t *p_buflen); static int mark_miss(char *name); static int ensure_fromlist(PyObject *mod, PyObject *fromlist, - char *buf, int buflen, int recursive); + char *buf, Py_ssize_t buflen, int recursive); static PyObject * import_submodule(PyObject *mod, char *name, char *fullname); /* The Magnum Opus of dotted-name import :-) */ @@ -1906,7 +1908,7 @@ import_module_ex(char *name, PyObject *globals, PyObject *locals, PyObject *fromlist) { char buf[MAXPATHLEN+1]; - int buflen = 0; + Py_ssize_t buflen = 0; PyObject *parent, *head, *next, *tail; parent = get_parent(globals, buf, &buflen); @@ -1976,7 +1978,7 @@ PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals, corresponding entry is not found in sys.modules, Py_None is returned. */ static PyObject * -get_parent(PyObject *globals, char *buf, int *p_buflen) +get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen) { static PyObject *namestr = NULL; static PyObject *pathstr = NULL; @@ -2044,7 +2046,7 @@ get_parent(PyObject *globals, char *buf, int *p_buflen) /* altmod is either None or same as mod */ static PyObject * load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf, - int *p_buflen) + Py_ssize_t *p_buflen) { char *name = *p_name; char *dot = strchr(name, '.'); @@ -2114,7 +2116,7 @@ mark_miss(char *name) } static int -ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, int buflen, +ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen, int recursive) { int i; diff --git a/Python/mactoolboxglue.c b/Python/mactoolboxglue.c index 406b002..7f0627e 100644 --- a/Python/mactoolboxglue.c +++ b/Python/mactoolboxglue.c @@ -363,10 +363,10 @@ int (*PyMacGluePtr_##routinename)(PyObject *, object *); \ \ int routinename(PyObject *pyobj, object *cobj) { \ if (!PyMacGluePtr_##routinename) { \ - if (!PyImport_ImportModule(module)) return NULL; \ + if (!PyImport_ImportModule(module)) return 0; \ if (!PyMacGluePtr_##routinename) { \ PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \ - return NULL; \ + return 0; \ } \ } \ return (*PyMacGluePtr_##routinename)(pyobj, cobj); \ diff --git a/Python/marshal.c b/Python/marshal.c index 5617226..e0f138d 100644 --- a/Python/marshal.c +++ b/Python/marshal.c @@ -59,7 +59,7 @@ typedef struct { static void w_more(int c, WFILE *p) { - int size, newsize; + Py_ssize_t size, newsize; if (p->str == NULL) return; /* An error already occurred */ size = PyString_Size(p->str); @@ -117,7 +117,7 @@ w_long64(long x, WFILE *p) static void w_object(PyObject *v, WFILE *p) { - int i, n; + Py_ssize_t i, n; p->depth++; @@ -181,7 +181,7 @@ w_object(PyObject *v, WFILE *p) else { char buf[256]; /* Plenty to format any double */ PyFloat_AsReprString(buf, (PyFloatObject *)v); - n = strlen(buf); + n = (int)strlen(buf); w_byte(TYPE_FLOAT, p); w_byte(n, p); w_string(buf, n, p); @@ -213,14 +213,14 @@ w_object(PyObject *v, WFILE *p) PyComplex_RealAsDouble(v)); PyFloat_AsReprString(buf, temp); Py_DECREF(temp); - n = strlen(buf); + n = (int)strlen(buf); w_byte(n, p); w_string(buf, n, p); temp = (PyFloatObject*)PyFloat_FromDouble( PyComplex_ImagAsDouble(v)); PyFloat_AsReprString(buf, temp); Py_DECREF(temp); - n = strlen(buf); + n = (int)strlen(buf); w_byte(n, p); w_string(buf, n, p); } @@ -236,7 +236,7 @@ w_object(PyObject *v, WFILE *p) goto exit; } else { - o = PyInt_FromLong(PyDict_Size(p->strings)); + o = PyInt_FromSsize_t(PyDict_Size(p->strings)); PyDict_SetItem(p->strings, v, o); Py_DECREF(o); w_byte(TYPE_INTERNED, p); @@ -282,7 +282,7 @@ w_object(PyObject *v, WFILE *p) } } else if (PyDict_Check(v)) { - int pos; + Py_ssize_t pos; PyObject *key, *value; w_byte(TYPE_DICT, p); /* This one is NULL object terminated! */ @@ -395,9 +395,10 @@ static int r_string(char *s, int n, RFILE *p) { if (p->fp != NULL) - return fread(s, 1, n, p->fp); + /* The result fits into int because it must be <=n. */ + return (int)fread(s, 1, n, p->fp); if (p->end - p->ptr < n) - n = p->end - p->ptr; + n = (int)(p->end - p->ptr); memcpy(s, p->ptr, n); p->ptr += n; return n; @@ -939,7 +940,10 @@ PyMarshal_ReadLastObjectFromFile(FILE *fp) pBuf = (char *)PyMem_MALLOC(filesize); if (pBuf != NULL) { PyObject* v; - size_t n = fread(pBuf, 1, filesize, fp); + size_t n; + /* filesize must fit into an int, because it + is smaller than REASONABLE_FILE_LIMIT */ + n = fread(pBuf, 1, (int)filesize, fp); v = PyMarshal_ReadObjectFromString(pBuf, n); if (pBuf != buf) PyMem_FREE(pBuf); @@ -970,7 +974,7 @@ PyMarshal_ReadObjectFromFile(FILE *fp) } PyObject * -PyMarshal_ReadObjectFromString(char *str, int len) +PyMarshal_ReadObjectFromString(char *str, Py_ssize_t len) { RFILE rf; PyObject *result; diff --git a/Python/modsupport.c b/Python/modsupport.c index 7241936..f92fc34 100644 --- a/Python/modsupport.c +++ b/Python/modsupport.c @@ -313,6 +313,11 @@ do_mkvalue(const char **p_format, va_list *p_va) return PyInt_FromLong(n); } + case 'n': +#if SIZEOF_SIZE_T!=SIZEOF_LONG + return PyLong_FromSsize_t(va_arg(*p_va, Py_Ssize_t)); +#endif + /* Fall through from 'n' to 'l' if Py_ssize_t is long */ case 'l': return PyInt_FromLong(va_arg(*p_va, long)); @@ -371,7 +376,7 @@ do_mkvalue(const char **p_format, va_list *p_va) case 'c': { char p[1]; - p[0] = va_arg(*p_va, int); + p[0] = (char)va_arg(*p_va, int); return PyString_FromStringAndSize(p, 1); } diff --git a/Python/pystrtod.c b/Python/pystrtod.c index 3eccae8..83e792d 100644 --- a/Python/pystrtod.c +++ b/Python/pystrtod.c @@ -159,7 +159,7 @@ PyOS_ascii_strtod(const char *nptr, char **endptr) **/ char * PyOS_ascii_formatd(char *buffer, - int buf_len, + size_t buf_len, const char *format, double d) { diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 30cb518..0b7de42 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -939,7 +939,7 @@ print_error_text(PyObject *f, int offset, const char *text) nl = strchr(text, '\n'); if (nl == NULL || nl-text >= offset) break; - offset -= (nl+1-text); + offset -= (int)(nl+1-text); text = nl+1; } while (*text == ' ' || *text == '\t') { diff --git a/Python/symtable.c b/Python/symtable.c index 7e876d4..7f3f5db 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -426,7 +426,8 @@ static int analyze_cells(PyObject *scope, PyObject *free) { PyObject *name, *v, *w; - int pos = 0, success = 0; + int success = 0; + Py_ssize_t pos = 0; w = PyInt_FromLong(CELL); if (!w) @@ -507,7 +508,7 @@ update_symbols(PyObject *symbols, PyObject *scope, PyObject *bound, PyObject *free, int class) { PyObject *name, *v, *u, *w, *free_value = NULL; - int pos = 0; + Py_ssize_t pos = 0; while (PyDict_Next(symbols, &pos, &name, &v)) { long i, flags; @@ -583,7 +584,8 @@ analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, { PyObject *name, *v, *local = NULL, *scope = NULL, *newbound = NULL; PyObject *newglobal = NULL, *newfree = NULL; - int i, pos = 0, success = 0; + int i, success = 0; + Py_ssize_t pos = 0; local = PyDict_New(); if (!local) diff --git a/Python/sysmodule.c b/Python/sysmodule.c index f793b99..b240cc7 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -1279,7 +1279,7 @@ PySys_SetArgv(int argc, char **argv) if (path != NULL) { char *argv0 = argv[0]; char *p = NULL; - int n = 0; + Py_ssize_t n = 0; PyObject *a; #ifdef HAVE_READLINK char link[MAXPATHLEN+1]; diff --git a/Python/thread_nt.h b/Python/thread_nt.h index 47c776f..e52d288 100644 --- a/Python/thread_nt.h +++ b/Python/thread_nt.h @@ -170,7 +170,7 @@ bootstrap(void *call) long PyThread_start_new_thread(void (*func)(void *), void *arg) { - unsigned long rv; + uintptr_t rv; callobj obj; dprintf(("%ld: PyThread_start_new_thread called\n", @@ -186,7 +186,7 @@ PyThread_start_new_thread(void (*func)(void *), void *arg) return -1; rv = _beginthread(bootstrap, 0, &obj); /* use default stack size */ - if (rv == (unsigned long)-1) { + if (rv == (uintptr_t)-1) { /* I've seen errno == EAGAIN here, which means "there are * too many threads". */ diff --git a/RISCOS/Modules/drawfmodule.c b/RISCOS/Modules/drawfmodule.c index db74d36..5f8dc3e 100644 --- a/RISCOS/Modules/drawfmodule.c +++ b/RISCOS/Modules/drawfmodule.c @@ -66,7 +66,7 @@ static void countobjs(PyDrawFObject *pd) if ((char*)d==end) pd->nobjs=k; } -static drawfile_object *findobj(PyDrawFObject *pd,int n) +static drawfile_object *findobj(PyDrawFObject *pd,Py_ssize_t n) { drawfile_diagram *dd=pd->drawf; drawfile_object *d=dd->objects; for(;n>0;n--) d=NEXT(d); @@ -520,14 +520,14 @@ static PyObject *drawf_concat(PyDrawFObject *b,PyDrawFObject *c) return (PyObject*)p; } -static PyObject *drawf_repeat(PyDrawFObject *b,int i) +static PyObject *drawf_repeat(PyDrawFObject *b,Py_ssize_t i) { PyErr_SetString(PyExc_IndexError,"drawf repetition not implemented"); return NULL; } -static PyObject *drawf_item(PyDrawFObject *b,int i) +static PyObject *drawf_item(PyDrawFObject *b,Py_ssize_t i) { PyDrawFObject *c; - int size; + Py_ssize_t size; drawfile_diagram *dd; drawfile_object *d; if(i<0||i>=b->nobjs) @@ -546,9 +546,9 @@ static PyObject *drawf_item(PyDrawFObject *b,int i) return (PyObject*)c; } -static PyObject *drawf_slice(PyDrawFObject *b,int i,int j) +static PyObject *drawf_slice(PyDrawFObject *b,Py_ssize_t i,Py_ssize_t j) { PyDrawFObject *c; - int size,n; + Py_ssize_t size,n; drawfile_diagram *dd; drawfile_object *d; if(i<0||j>b->nobjs) @@ -570,7 +570,7 @@ static PyObject *drawf_slice(PyDrawFObject *b,int i,int j) return (PyObject*)c; } -static int drawf_ass_item(PyDrawFObject *b,int i,PyObject *v) +static int drawf_ass_item(PyDrawFObject *b,Py_ssize_t i,PyObject *v) { PyErr_SetString(PyExc_IndexError,"drawf ass not implemented"); return NULL; } @@ -587,7 +587,7 @@ static int drawf_ass_item(PyDrawFObject *b,int i,PyObject *v) } */ -static int drawf_ass_slice(PyDrawFObject *b,int i,int j,PyObject *v) +static int drawf_ass_slice(PyDrawFObject *b,Py_ssize_t i,Py_ssize_t j,PyObject *v) { PyErr_SetString(PyExc_IndexError,"drawf ass_slice not implemented"); return NULL; } @@ -595,11 +595,11 @@ static int drawf_ass_slice(PyDrawFObject *b,int i,int j,PyObject *v) static PySequenceMethods drawf_as_sequence= { (inquiry)drawf_len, (binaryfunc)drawf_concat, - (intargfunc)drawf_repeat, - (intargfunc)drawf_item, - (intintargfunc)drawf_slice, - (intobjargproc)drawf_ass_item, - (intintobjargproc)drawf_ass_slice, + (ssizeargfunc)drawf_repeat, + (ssizeargfunc)drawf_item, + (ssizessizeargfunc)drawf_slice, + (ssizeobjargproc)drawf_ass_item, + (ssizessizeobjargproc)drawf_ass_slice, }; static PyObject *PyDrawF_GetAttr(PyDrawFObject *s,char *name) diff --git a/RISCOS/Modules/swimodule.c b/RISCOS/Modules/swimodule.c index 583fc57..b460b2f 100644 --- a/RISCOS/Modules/swimodule.c +++ b/RISCOS/Modules/swimodule.c @@ -215,12 +215,12 @@ static PyObject *block_concat(PyBlockObject *b,PyBlockObject *c) return NULL; } -static PyObject *block_repeat(PyBlockObject *b,int i) +static PyObject *block_repeat(PyBlockObject *b,Py_ssize_t i) { PyErr_SetString(PyExc_IndexError,"block repetition not implemented"); return NULL; } -static PyObject *block_item(PyBlockObject *b,int i) +static PyObject *block_item(PyBlockObject *b,Py_ssize_t i) { if(i<0||4*i>=b->length) { PyErr_SetString(PyExc_IndexError,"block index out of range"); return NULL; @@ -228,8 +228,8 @@ static PyObject *block_item(PyBlockObject *b,int i) return PyInt_FromLong(((long*)(b->block))[i]); } -static PyObject *block_slice(PyBlockObject *b,int i,int j) -{ int n,k; +static PyObject *block_slice(PyBlockObject *b,Py_ssize_t i,Py_ssize_t j) +{ Py_ssize_t n,k; long *p=b->block; PyObject *result; if(j>b->length/4) j=b->length/4; @@ -239,11 +239,11 @@ static PyObject *block_slice(PyBlockObject *b,int i,int j) } n=j-i; result=PyList_New(n); - for(k=0;k=b->length/4) { PyErr_SetString(PyExc_IndexError,"block index out of range"); return -1; @@ -256,8 +256,8 @@ static int block_ass_item(PyBlockObject *b,int i,PyObject *v) return 0; } -static int block_ass_slice(PyBlockObject *b,int i,int j,PyObject *v) -{ int n,k; +static int block_ass_slice(PyBlockObject *b,Py_ssize_t i,Py_ssize_t j,PyObject *v) +{ Py_ssize_t n,k; long *p=b->block; if(j>b->length/4) j=b->length/4; if(i<0||i>j) @@ -281,11 +281,11 @@ static int block_ass_slice(PyBlockObject *b,int i,int j,PyObject *v) static PySequenceMethods block_as_sequence= { (inquiry)block_len, /*sq_length*/ (binaryfunc)block_concat, /*sq_concat*/ - (intargfunc)block_repeat, /*sq_repeat*/ - (intargfunc)block_item, /*sq_item*/ - (intintargfunc)block_slice, /*sq_slice*/ - (intobjargproc)block_ass_item, /*sq_ass_item*/ - (intintobjargproc)block_ass_slice, /*sq_ass_slice*/ + (ssizeargfunc)block_repeat, /*sq_repeat*/ + (ssizeargfunc)block_item, /*sq_item*/ + (ssizessizeargfunc)block_slice, /*sq_slice*/ + (ssizeobjargproc)block_ass_item, /*sq_ass_item*/ + (ssizessizeobjargproc)block_ass_slice, /*sq_ass_slice*/ }; static PyObject *PyBlock_GetAttr(PyBlockObject *s,char *name) diff --git a/configure b/configure index 8159268..327a450 100755 --- a/configure +++ b/configure @@ -1,5 +1,5 @@ #! /bin/sh -# From configure.in Revision: 42199 . +# From configure.in Revision: 42307 . # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.59 for python 2.5. # @@ -6197,6 +6197,70 @@ _ACEOF fi +echo "$as_me:$LINENO: checking for ssize_t" >&5 +echo $ECHO_N "checking for ssize_t... $ECHO_C" >&6 +if test "${ac_cv_type_ssize_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((ssize_t *) 0) + return 0; +if (sizeof (ssize_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_ssize_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_ssize_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_ssize_t" >&5 +echo "${ECHO_T}$ac_cv_type_ssize_t" >&6 +if test $ac_cv_type_ssize_t = yes; then + +cat >>confdefs.h <<\_ACEOF +#define HAVE_SSIZE_T 1 +_ACEOF + +fi + # Sizes of various common basic types # ANSI C requires sizeof(char) == 1, so no need to check it @@ -9098,6 +9162,420 @@ cat >>confdefs.h <<_ACEOF _ACEOF +echo "$as_me:$LINENO: checking for size_t" >&5 +echo $ECHO_N "checking for size_t... $ECHO_C" >&6 +if test "${ac_cv_type_size_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +if ((size_t *) 0) + return 0; +if (sizeof (size_t)) + return 0; + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_type_size_t=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_cv_type_size_t=no +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5 +echo "${ECHO_T}$ac_cv_type_size_t" >&6 + +echo "$as_me:$LINENO: checking size of size_t" >&5 +echo $ECHO_N "checking size of size_t... $ECHO_C" >&6 +if test "${ac_cv_sizeof_size_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test "$ac_cv_type_size_t" = yes; then + # The cast to unsigned long works around a bug in the HP C Compiler + # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects + # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. + # This bug is HP SR number 8606223364. + if test "$cross_compiling" = yes; then + # Depending upon the size, compute the lo and hi bounds. +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (size_t))) >= 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=0 ac_mid=0 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (size_t))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr $ac_mid + 1` + if test $ac_lo -le $ac_mid; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (size_t))) < 0)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=-1 ac_mid=-1 + while :; do + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (size_t))) >= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_lo=$ac_mid; break +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_hi=`expr '(' $ac_mid ')' - 1` + if test $ac_mid -le $ac_hi; then + ac_lo= ac_hi= + break + fi + ac_mid=`expr 2 '*' $ac_mid` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext + done +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo= ac_hi= +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +# Binary search between lo and hi bounds. +while test "x$ac_lo" != "x$ac_hi"; do + ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +int +main () +{ +static int test_array [1 - 2 * !(((long) (sizeof (size_t))) <= $ac_mid)]; +test_array [0] = 0 + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext +if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 + (eval $ac_compile) 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; } && + { ac_try='test -s conftest.$ac_objext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_hi=$ac_mid +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +ac_lo=`expr '(' $ac_mid ')' + 1` +fi +rm -f conftest.err conftest.$ac_objext conftest.$ac_ext +done +case $ac_lo in +?*) ac_cv_sizeof_size_t=$ac_lo;; +'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (size_t), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (size_t), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } ;; +esac +else + if test "$cross_compiling" = yes; then + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +else + cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +long longval () { return (long) (sizeof (size_t)); } +unsigned long ulongval () { return (long) (sizeof (size_t)); } +#include +#include +int +main () +{ + + FILE *f = fopen ("conftest.val", "w"); + if (! f) + exit (1); + if (((long) (sizeof (size_t))) < 0) + { + long i = longval (); + if (i != ((long) (sizeof (size_t)))) + exit (1); + fprintf (f, "%ld\n", i); + } + else + { + unsigned long i = ulongval (); + if (i != ((long) (sizeof (size_t)))) + exit (1); + fprintf (f, "%lu\n", i); + } + exit (ferror (f) || fclose (f) != 0); + + ; + return 0; +} +_ACEOF +rm -f conftest$ac_exeext +if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 + (eval $ac_link) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { ac_try='./conftest$ac_exeext' + { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 + (eval $ac_try) 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; }; then + ac_cv_sizeof_size_t=`cat conftest.val` +else + echo "$as_me: program exited with status $ac_status" >&5 +echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +( exit $ac_status ) +{ { echo "$as_me:$LINENO: error: cannot compute sizeof (size_t), 77 +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot compute sizeof (size_t), 77 +See \`config.log' for more details." >&2;} + { (exit 1); exit 1; }; } +fi +rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +fi +fi +rm -f conftest.val +else + ac_cv_sizeof_size_t=0 +fi +fi +echo "$as_me:$LINENO: result: $ac_cv_sizeof_size_t" >&5 +echo "${ECHO_T}$ac_cv_sizeof_size_t" >&6 +cat >>confdefs.h <<_ACEOF +#define SIZEOF_SIZE_T $ac_cv_sizeof_size_t +_ACEOF + + echo "$as_me:$LINENO: checking for long long support" >&5 echo $ECHO_N "checking for long long support... $ECHO_C" >&6 diff --git a/configure.in b/configure.in index 3892528..29eb168 100644 --- a/configure.in +++ b/configure.in @@ -1098,6 +1098,8 @@ AC_TYPE_PID_T AC_TYPE_SIGNAL AC_TYPE_SIZE_T AC_TYPE_UID_T +AC_CHECK_TYPE(ssize_t, + AC_DEFINE(HAVE_SSIZE_T, 1, Define if your compiler provides ssize_t),,) # Sizes of various common basic types # ANSI C requires sizeof(char) == 1, so no need to check it @@ -1108,6 +1110,7 @@ AC_CHECK_SIZEOF(short, 2) AC_CHECK_SIZEOF(float, 4) AC_CHECK_SIZEOF(double, 8) AC_CHECK_SIZEOF(fpos_t, 4) +AC_CHECK_SIZEOF(size_t, 4) AC_MSG_CHECKING(for long long support) have_long_long=no diff --git a/pyconfig.h.in b/pyconfig.h.in index cab9bf5..9c3ca53 100644 --- a/pyconfig.h.in +++ b/pyconfig.h.in @@ -461,6 +461,9 @@ /* Define if you have the 'socketpair' function. */ #undef HAVE_SOCKETPAIR +/* Define if your compiler provides ssize_t */ +#undef HAVE_SSIZE_T + /* Define to 1 if you have the `statvfs' function. */ #undef HAVE_STATVFS @@ -769,6 +772,9 @@ /* The size of a `short', as computed by sizeof. */ #undef SIZEOF_SHORT +/* The size of a `size_t', as computed by sizeof. */ +#undef SIZEOF_SIZE_T + /* The number of bytes in a time_t. */ #undef SIZEOF_TIME_T -- cgit v0.12