Merge ssize_t branch.
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 @@
return v;
}
-int
+Py_ssize_t
PyObject_Size(PyObject *o)
{
PySequenceMethods *m;
@@ -74,17 +74,17 @@
}
#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 @@
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 @@
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 @@
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_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 @@
}
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 @@
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 @@
/* 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 @@
{
PyNumberMethods *m;
const char *buffer;
- int buffer_len;
+ Py_ssize_t buffer_len;
if (o == NULL)
return null_error();
@@ -1006,7 +1006,7 @@
/* 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 @@
{
PyNumberMethods *m;
const char *buffer;
- int buffer_len;
+ Py_ssize_t buffer_len;
if (o == NULL)
return null_error();
@@ -1103,7 +1103,7 @@
s->ob_type->tp_as_sequence->sq_item != NULL;
}
-int
+Py_ssize_t
PySequence_Size(PyObject *s)
{
PySequenceMethods *m;
@@ -1122,7 +1122,7 @@
}
#undef PySequence_Length
-int
+Py_ssize_t
PySequence_Length(PyObject *s)
{
return PySequence_Size(s);
@@ -1154,7 +1154,7 @@
}
PyObject *
-PySequence_Repeat(PyObject *o, int count)
+PySequence_Repeat(PyObject *o, Py_ssize_t count)
{
PySequenceMethods *m;
@@ -1207,7 +1207,7 @@
}
PyObject *
-PySequence_InPlaceRepeat(PyObject *o, int count)
+PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
{
PySequenceMethods *m;
@@ -1236,7 +1236,7 @@
}
PyObject *
-PySequence_GetItem(PyObject *s, int i)
+PySequence_GetItem(PyObject *s, Py_ssize_t i)
{
PySequenceMethods *m;
@@ -1247,7 +1247,7 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
int
-PySequence_DelItem(PyObject *s, int i)
+PySequence_DelItem(PyObject *s, Py_ssize_t i)
{
PySequenceMethods *m;
@@ -1353,7 +1353,7 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
o->ob_type->tp_as_sequence->sq_slice);
}
-int
+Py_ssize_t
PyMapping_Size(PyObject *o)
{
PyMappingMethods *m;
@@ -1727,7 +1727,7 @@
}
#undef PyMapping_Length
-int
+Py_ssize_t
PyMapping_Length(PyObject *o)
{
return PyMapping_Size(o);
@@ -2053,7 +2053,7 @@
abstract_issubclass(PyObject *derived, PyObject *cls)
{
PyObject *bases;
- int i, n;
+ Py_ssize_t i, n;
int r = 0;
@@ -2137,7 +2137,7 @@
}
}
else if (PyTuple_Check(cls)) {
- int i, n;
+ Py_ssize_t i, n;
if (!recursion_depth) {
PyErr_SetString(PyExc_RuntimeError,
@@ -2191,8 +2191,8 @@
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 @@
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 @@
*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 @@
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 @@
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 @@
}
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 @@
/* 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 @@
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 @@
}
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 @@
}
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 @@
"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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
PyObject *lnotab)
{
PyCodeObject *co;
- int i;
+ Py_ssize_t i;
/* Check argument types */
if (argcount < 0 || nlocals < 0 ||
code == NULL ||
@@ -135,7 +135,7 @@
{
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 @@
#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 @@
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 @@
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 @@
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 @@
PyObject *dict;
} proxyobject;
-static int
+static Py_ssize_t
proxy_len(proxyobject *pp)
{
return PyObject_Size(pp->dict);
@@ -682,7 +682,7 @@
}
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 @@
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 @@
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 @@
* 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 @@
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 @@
return result;
}
-static int
+static Py_ssize_t
dict_length(dictobject *mp)
{
return mp->ma_used;
@@ -898,7 +899,7 @@
}
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 @@
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 @@
for (i = 0; ; ++i) {
PyObject *key, *value;
- int n;
+ Py_ssize_t n;
fast = NULL;
item = PyIter_Next(it);
@@ -1147,7 +1148,7 @@
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 @@
return NULL;
}
-int
+Py_ssize_t
PyDict_Size(PyObject *mp)
{
if (mp == NULL || !PyDict_Check(mp)) {
@@ -1708,7 +1709,8 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
int
PyFile_SoftSpace(PyObject *f, int newflag)
{
- int oldflag = 0;
+ long oldflag = 0;
if (f == NULL) {
/* Do nothing */
}
@@ -2077,6 +2081,7 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
/* 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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
#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 @@
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 @@
}
PyObject *
-PyList_New(int size)
+PyList_New(Py_ssize_t size)
{
PyListObject *op;
size_t nbytes;
@@ -118,7 +118,7 @@
return (PyObject *) op;
}
-int
+Py_ssize_t
PyList_Size(PyObject *op)
{
if (!PyList_Check(op)) {
@@ -132,7 +132,7 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
static PyObject *
list_repr(PyListObject *v)
{
- int i;
+ Py_ssize_t i;
PyObject *s, *temp;
PyObject *pieces = NULL, *result = NULL;
@@ -363,7 +364,7 @@
return result;
}
-static int
+static Py_ssize_t
list_length(PyListObject *a)
{
return a->ob_size;
@@ -372,7 +373,8 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
* 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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
/* 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 @@
/* 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 @@
*/
++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 @@
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 @@
/* 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 @@
/* 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 @@
*/
++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 @@
*/
struct s_slice {
PyObject **base;
- int len;
+ Py_ssize_t len;
};
typedef struct s_MergeState {
@@ -1305,13 +1307,13 @@
* 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 @@
* 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, 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 @@
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 @@
* 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 @@
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 @@
/* 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 @@
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 @@
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 @@
*
* 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 @@
{
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 @@
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 @@
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 @@
{
PyObject *w;
PyObject **p;
- int n;
+ Py_ssize_t n;
if (v == NULL || !PyList_Check(v)) {
PyErr_BadInternalCall();
return NULL;
@@ -2200,7 +2203,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
if (value == NULL) {
/* delete slice */
PyObject **garbage;
- int cur, i;
+ Py_ssize_t cur, i;
if (slicelength <= 0)
return 0;
@@ -2554,7 +2551,7 @@
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 @@
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 @@
}
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 @@
}
static PyMappingMethods list_as_mapping = {
- (inquiry)list_length,
+ (lenfunc)list_length,
(binaryfunc)list_subscript,
(objobjargproc)list_ass_subscript
};
@@ -2767,11 +2765,11 @@
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 @@
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 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 @@
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 @@
_PyLong_Copy(PyLongObject *src)
{
PyLongObject *result;
- int i;
+ Py_ssize_t i;
assert(src != NULL);
i = src->ob_size;
@@ -198,7 +203,8 @@
/* 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 @@
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 @@
{
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 @@
{
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
* 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 @@
* 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 @@
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 @@
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 @@
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 @@
{
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 @@
/* 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 @@
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 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
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_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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
{
PyObject *dict;
PyObject *list;
- int i;
+ Py_ssize_t i;
dict = PyThreadState_GetDict();
if (dict == NULL)
@@ -2020,7 +2021,7 @@
{
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 @@
/* 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 @@
{
void *bp;
poolp pool;
- uint size;
+ size_t size;
if (p == NULL)
return PyObject_Malloc(nbytes);
@@ -1005,6 +1005,8 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
* 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 @@
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 @@
return result;
}
-static int
+static Py_ssize_t
set_len(PyObject *so)
{
return ((PySetObject *)so)->used;
@@ -673,7 +674,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
{
PySetObject *otherset;
PyObject *key;
- int pos = 0;
+ Py_ssize_t pos = 0;
setentry *entry;
if ((PyObject *)so == other)
@@ -1442,7 +1443,7 @@
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 @@
}
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 @@
}
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 @@
}
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 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 @@
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 @@
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 @@
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 @@
PyObject *PyString_Decode(const char *s,
- int size,
+ Py_ssize_t size,
const char *encoding,
const char *errors)
{
@@ -410,7 +411,7 @@
}
PyObject *PyString_Encode(const char *s,
- int size,
+ Py_ssize_t size,
const char *encoding,
const char *errors)
{
@@ -519,16 +520,16 @@
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 *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 @@
}
}
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 @@
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 @@
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 @@
*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 @@
static int
string_print(PyStringObject *op, FILE *fp, int flags)
{
- int i;
+ Py_ssize_t i;
char c;
int quote;
@@ -809,7 +810,7 @@
return NULL;
}
else {
- register int i;
+ register Py_ssize_t i;
register char c;
register char *p;
int quote;
@@ -876,7 +877,7 @@
}
}
-static int
+static Py_ssize_t
string_length(PyStringObject *a)
{
return a->ob_size;
@@ -885,7 +886,7 @@
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 @@
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 @@
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 @@
}
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 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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
/* 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 @@
}
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 @@
*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 @@
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 @@
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 @@
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 @@
"substring not found");
return NULL;
}
- return PyInt_FromLong(result);
+ return PyInt_FromSsize_t(result);
}
@@ -1823,10 +1823,10 @@
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 @@
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 @@
"substring not found");
return NULL;
}
- return PyInt_FromLong(result);
+ return PyInt_FromSsize_t(result);
}
@@ -1854,10 +1854,10 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
#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 @@
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 @@
break;
i = t - s;
}
- return PyInt_FromLong((long) r);
+ return PyInt_FromSsize_t(r);
}
PyDoc_STRVAR(swapcase__doc__,
@@ -2204,7 +2204,7 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
}
#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 @@
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 @@
}
#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 @@
{
const char *e, *p;
char *q;
- int i, j;
+ Py_ssize_t i, j;
PyObject *u;
int tabsize = 8;
@@ -2807,7 +2807,7 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
*/
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 @@
(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 @@
{
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 @@
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 @@
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 @@
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 @@
fmt++;
if (*fmt == '(') {
char *keystart;
- int keylen;
+ Py_ssize_t keylen;
PyObject *key;
int pcount = 1;
@@ -4393,7 +4394,7 @@
{
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
#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 @@
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 @@
return (PyObject *) op;
}
-int
+Py_ssize_t
PyTuple_Size(register PyObject *op)
{
if (!PyTuple_Check(op)) {
@@ -94,7 +94,7 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
static PyObject *
tuplerepr(PyTupleObject *v)
{
- int i, n;
+ Py_ssize_t i, n;
PyObject *s, *temp;
PyObject *pieces, *result = NULL;
@@ -268,7 +268,7 @@
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 @@
return x;
}
-static int
+static Py_ssize_t
tuplelength(PyTupleObject *a)
{
return a->ob_size;
@@ -295,7 +295,8 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
"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 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 @@
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 PyMappingMethods tuple_as_mapping = {
- (inquiry)tuplelength,
+ (lenfunc)tuplelength,
(binaryfunc)tuplesubscript,
0
};
@@ -707,12 +703,12 @@
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 @@
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 @@
{
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
if (tuple == NULL)
return -1;
if (checkit) {
- int i, len;
+ Py_ssize_t i, len;
PyObject *cls;
PyTypeObject *solid;
@@ -1350,7 +1352,7 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
"(" 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 @@
/* 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 @@
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 @@
}
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 @@
{
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 @@
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 @@
"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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
static
int unicode_resize(register PyUnicodeObject *unicode,
- int length)
+ Py_ssize_t length)
{
void *oldstr;
@@ -154,7 +154,8 @@
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 @@
*/
static
-PyUnicodeObject *_PyUnicode_New(int length)
+PyUnicodeObject *_PyUnicode_New(Py_ssize_t length)
{
register PyUnicodeObject *unicode;
@@ -225,7 +226,8 @@
*/
unicode->str[0] = 0;
unicode->str[length] = 0;
- unicode->length = length;
+ assert(length<INT_MAX);
+ unicode->length = (int)length;
unicode->hash = -1;
unicode->defenc = NULL;
return unicode;
@@ -263,7 +265,7 @@
}
}
-int PyUnicode_Resize(PyObject **unicode, int length)
+int PyUnicode_Resize(PyObject **unicode, Py_ssize_t length)
{
register PyUnicodeObject *v;
@@ -303,7 +305,7 @@
PyUnicode_Resize(((PyObject **)(unicodevar)), length)
PyObject *PyUnicode_FromUnicode(const Py_UNICODE *u,
- int size)
+ Py_ssize_t size)
{
PyUnicodeObject *unicode;
@@ -347,7 +349,7 @@
#ifdef HAVE_WCHAR_H
PyObject *PyUnicode_FromWideChar(register const wchar_t *w,
- int size)
+ Py_ssize_t size)
{
PyUnicodeObject *unicode;
@@ -376,9 +378,9 @@
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 @@
const char *errors)
{
const char *s = NULL;
- int len;
+ Py_ssize_t len;
PyObject *v;
if (obj == NULL) {
@@ -520,7 +522,7 @@
}
PyObject *PyUnicode_Decode(const char *s,
- int size,
+ Py_ssize_t size,
const char *encoding,
const char *errors)
{
@@ -588,7 +590,7 @@
}
PyObject *PyUnicode_Encode(const Py_UNICODE *s,
- int size,
+ Py_ssize_t size,
const char *encoding,
const char *errors)
{
@@ -696,7 +698,7 @@
return NULL;
}
-int PyUnicode_GetSize(PyObject *unicode)
+Py_ssize_t PyUnicode_GetSize(PyObject *unicode)
{
if (!PyUnicode_Check(unicode)) {
PyErr_BadArgument();
@@ -742,18 +744,18 @@
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 @@
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 @@
}
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 @@
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 @@
};
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 @@
*/
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_DecodeUTF16(const char *s,
- int size,
+ Py_ssize_t size,
const char *errors,
int *byteorder)
{
@@ -1464,15 +1467,15 @@
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 @@
PyObject *
PyUnicode_EncodeUTF16(const Py_UNICODE *s,
- int size,
+ Py_ssize_t size,
const char *errors,
int byteorder)
{
@@ -1716,13 +1719,13 @@
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 @@
/* 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 @@
*/
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 *PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s,
- int size)
+ Py_ssize_t size)
{
return unicodeescape_string(s, size, 0);
}
@@ -2111,13 +2114,13 @@
/* --- 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_EncodeRawUnicodeEscape(const Py_UNICODE *s,
- int size)
+ Py_ssize_t size)
{
PyObject *repr;
char *p;
@@ -2284,13 +2287,13 @@
/* --- 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 @@
/* --- Latin-1 Codec ------------------------------------------------------ */
PyObject *PyUnicode_DecodeLatin1(const char *s,
- int size,
+ Py_ssize_t size,
const char *errors)
{
PyUnicodeObject *v;
@@ -2391,8 +2394,8 @@
/* 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 @@
/* 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 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 @@
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_ucs1(const Py_UNICODE *p,
- int size,
+ Py_ssize_t size,
const char *errors,
int limit)
{
@@ -2494,8 +2498,8 @@
/* 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 @@
++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 @@
}
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 @@
/* --- 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_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 @@
/* --- 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 @@
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_EncodeMBCS(const Py_UNICODE *p,
- int size,
+ Py_ssize_t size,
const char *errors)
{
PyObject *repr;
@@ -2794,7 +2800,8 @@
return PyString_FromString("");
/* First get the size of the result */
- mbcssize = WideCharToMultiByte(CP_ACP, 0, p, size, NULL, 0, NULL, NULL);
+ assert(size<INT_MAX);
+ mbcssize = WideCharToMultiByte(CP_ACP, 0, p, (int)size, NULL, 0, NULL, NULL);
if (mbcssize==0)
return PyErr_SetFromWindowsErrWithFilename(0, NULL);
@@ -2806,7 +2813,8 @@
/* Do the conversion */
s = PyString_AS_STRING(repr);
- if (0 == WideCharToMultiByte(CP_ACP, 0, p, size, s, mbcssize, NULL, NULL)) {
+ assert(size < INT_MAX);
+ if (0 == WideCharToMultiByte(CP_ACP, 0, p, (int)size, s, mbcssize, NULL, NULL)) {
Py_DECREF(repr);
return PyErr_SetFromWindowsErrWithFilename(0, NULL);
}
@@ -2829,22 +2837,22 @@
/* --- Character Mapping Codec -------------------------------------------- */
PyObject *PyUnicode_DecodeCharmap(const char *s,
- int size,
+ Py_ssize_t size,
PyObject *mapping,
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 *v;
Py_UNICODE *p;
- int extrachars = 0;
+ Py_ssize_t extrachars = 0;
PyObject *errorHandler = NULL;
PyObject *exc = NULL;
Py_UNICODE *mapstring = NULL;
- int maplen = 0;
+ Py_ssize_t maplen = 0;
/* Default to Latin-1 */
if (mapping == NULL)
@@ -2934,7 +2942,7 @@
continue;
}
else if (PyUnicode_Check(x)) {
- int targetsize = PyUnicode_GET_SIZE(x);
+ Py_ssize_t targetsize = PyUnicode_GET_SIZE(x);
if (targetsize == 1)
/* 1-1 mapping */
@@ -2944,8 +2952,8 @@
/* 1-n mapping */
if (targetsize > 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 @@
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 @@
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 (outsize<requiredsize) {
/* exponentially overallocate to minimize reallocations */
if (requiredsize < 2*outsize)
@@ -3068,8 +3076,8 @@
}
else {
const char *repchars = PyString_AS_STRING(rep);
- int repsize = PyString_GET_SIZE(rep);
- int requiredsize = *outpos+repsize;
+ Py_ssize_t repsize = PyString_GET_SIZE(rep);
+ Py_ssize_t requiredsize = *outpos+repsize;
if (outsize<requiredsize) {
/* exponentially overallocate to minimize reallocations */
if (requiredsize < 2*outsize)
@@ -3091,19 +3099,19 @@
Return 0 on success, -1 on error */
static
int charmap_encoding_error(
- const Py_UNICODE *p, int size, int *inpos, PyObject *mapping,
+ const Py_UNICODE *p, Py_ssize_t size, Py_ssize_t *inpos, PyObject *mapping,
PyObject **exceptionObject,
int *known_errorHandler, PyObject **errorHandler, const char *errors,
- PyObject **res, int *respos)
+ PyObject **res, Py_ssize_t *respos)
{
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 unencodable chars */
- int collstartpos = *inpos;
- int collendpos = *inpos+1;
- int collpos;
+ Py_ssize_t collstartpos = *inpos;
+ Py_ssize_t collendpos = *inpos+1;
+ Py_ssize_t collpos;
char *encoding = "charmap";
char *reason = "character maps to <undefined>";
@@ -3204,16 +3212,16 @@
}
PyObject *PyUnicode_EncodeCharmap(const Py_UNICODE *p,
- int size,
+ Py_ssize_t size,
PyObject *mapping,
const char *errors)
{
/* output object */
PyObject *res = NULL;
/* current input position */
- int inpos = 0;
+ Py_ssize_t inpos = 0;
/* current output position */
- int respos = 0;
+ Py_ssize_t respos = 0;
PyObject *errorHandler = NULL;
PyObject *exc = NULL;
/* the following variable is used for caching string comparisons
@@ -3284,8 +3292,8 @@
/* create or adjust a UnicodeTranslateError */
static void make_translate_exception(PyObject **exceptionObject,
- 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) {
@@ -3308,8 +3316,8 @@
/* raises a UnicodeTranslateError */
static void raise_translate_exception(PyObject **exceptionObject,
- 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_translate_exception(exceptionObject,
@@ -3325,12 +3333,13 @@
static PyObject *unicode_translate_call_errorhandler(const char *errors,
PyObject **errorHandler,
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;translating error handler must return (unicode, int) tuple";
+ int i_newpos;
PyObject *restuple;
PyObject *resunicode;
@@ -3355,14 +3364,17 @@
return NULL;
}
if (!PyArg_ParseTuple(restuple, argparse, &PyUnicode_Type,
- &resunicode, newpos)) {
+ &resunicode, &i_newpos)) {
Py_DECREF(restuple);
return NULL;
}
- if (*newpos<0)
- *newpos = size+*newpos;
+ if (i_newpos<0)
+ *newpos = size+i_newpos;
+ else
+ *newpos = i_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;
}
@@ -3426,12 +3438,12 @@
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 @@
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 @@
*(*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 @@
}
PyObject *PyUnicode_TranslateCharmap(const Py_UNICODE *p,
- int size,
+ Py_ssize_t size,
PyObject *mapping,
const char *errors)
{
@@ -3499,7 +3511,7 @@
/* pointer into the output */
Py_UNICODE *str;
/* current output position */
- int respos = 0;
+ Py_ssize_t respos = 0;
char *reason = "character maps to <undefined>";
PyObject *errorHandler = NULL;
PyObject *exc = NULL;
@@ -3534,8 +3546,8 @@
++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 @@
/* --- Decimal Encoder ---------------------------------------------------- */
int PyUnicode_EncodeDecimal(Py_UNICODE *s,
- int length,
+ Py_ssize_t length,
char *output,
const char *errors)
{
@@ -3676,8 +3688,8 @@
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 @@
/* --- 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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 *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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
static
PyObject *split(PyUnicodeObject *self,
PyUnicodeObject *substring,
- int maxcount)
+ Py_ssize_t maxcount)
{
PyObject *list;
@@ -4619,7 +4631,7 @@
static
PyObject *rsplit(PyUnicodeObject *self,
PyUnicodeObject *substring,
- int maxcount)
+ Py_ssize_t maxcount)
{
PyObject *list;
@@ -4649,7 +4661,7 @@
PyObject *replace(PyUnicodeObject *self,
PyUnicodeObject *str1,
PyUnicodeObject *str2,
- int maxcount)
+ Py_ssize_t maxcount)
{
PyUnicodeObject *u;
@@ -4686,7 +4698,7 @@
}
} else {
- int n, i;
+ Py_ssize_t n, i;
Py_UNICODE *p;
/* replace strings */
@@ -4778,7 +4790,7 @@
{
PyObject *list;
PyObject *item;
- int i;
+ Py_ssize_t i;
/* Split into words */
list = split(self, NULL, -1);
@@ -4840,8 +4852,8 @@
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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
return PyUnicode_Join(self, data);
}
-static int
+static Py_ssize_t
unicode_length(PyUnicodeObject *self)
{
return self->length;
@@ -5707,10 +5720,10 @@
_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 @@
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 @@
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 @@
PyObject *PyUnicode_Replace(PyObject *obj,
PyObject *subobj,
PyObject *replobj,
- int maxcount)
+ Py_ssize_t maxcount)
{
PyObject *self;
PyObject *str1;
@@ -5942,10 +5955,10 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
PyObject *PyUnicode_Split(PyObject *s,
PyObject *sep,
- int maxsplit)
+ Py_ssize_t maxsplit)
{
PyObject *result;
@@ -6114,9 +6127,9 @@
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 @@
PyObject *PyUnicode_RSplit(PyObject *s,
PyObject *sep,
- int maxsplit)
+ Py_ssize_t maxsplit)
{
PyObject *result;
@@ -6164,9 +6177,9 @@
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 @@
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 @@
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 @@
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 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 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 @@
}
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 @@
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 @@
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 @@
static int
unicode_buffer_getcharbuf(PyUnicodeObject *self,
- int index,
+ Py_ssize_t index,
const void **ptr)
{
PyObject *str;
@@ -6558,9 +6566,9 @@
/* 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 @@
#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 @@
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 @@
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 @@
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 *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 @@
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 *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 @@
}
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 @@
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 @@
/* 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 @@
}
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 @@
/* mapping slots */
-static int
+static Py_ssize_t
proxy_length(PyWeakReference *proxy)
{
if (!proxy_checkref(proxy))
@@ -625,18 +625,18 @@
};
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 @@
}
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 @@
}
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;