Merge p3yk branch with the trunk up to revision 45595. This breaks a fair
number of tests, all because of the codecs/_multibytecodecs issue described
here (it's not a Py3K issue, just something Py3K discovers):
http://mail.python.org/pipermail/python-dev/2006-April/064051.html
Hye-Shik Chang promised to look for a fix, so no need to fix it here. The
tests that are expected to break are:
test_codecencodings_cn
test_codecencodings_hk
test_codecencodings_jp
test_codecencodings_kr
test_codecencodings_tw
test_codecs
test_multibytecodec
This merge fixes an actual test failure (test_weakref) in this branch,
though, so I believe merging is the right thing to do anyway.
diff --git a/Objects/abstract.c b/Objects/abstract.c
index c755654..13a9473 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -10,6 +10,7 @@
#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
/* Shorthands to return certain errors */
static PyObject *
@@ -940,8 +941,9 @@
value = nb->nb_index(item);
}
else {
- PyErr_SetString(PyExc_IndexError,
- "object cannot be interpreted as an index");
+ PyErr_Format(PyExc_TypeError,
+ "'%.200s' object cannot be interpreted "
+ "as an index", item->ob_type->tp_name);
}
return value;
}
@@ -1245,24 +1247,6 @@
return type_error("unindexable object");
}
-static PyObject *
-sliceobj_from_intint(Py_ssize_t i, Py_ssize_t j)
-{
- PyObject *start, *end, *slice;
- start = PyInt_FromLong((long)i);
- if (!start)
- return NULL;
- end = PyInt_FromLong((long)j);
- if (!end) {
- Py_DECREF(start);
- return NULL;
- }
- slice = PySlice_New(start, end, NULL);
- Py_DECREF(start);
- Py_DECREF(end);
- return slice;
-}
-
PyObject *
PySequence_GetSlice(PyObject *s, Py_ssize_t i1, Py_ssize_t i2)
{
@@ -1287,7 +1271,7 @@
return m->sq_slice(s, i1, i2);
} else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_subscript) {
PyObject *res;
- PyObject *slice = sliceobj_from_intint(i1, i2);
+ PyObject *slice = _PySlice_FromIndices(i1, i2);
if (!slice)
return NULL;
res = mp->mp_subscript(s, slice);
@@ -1379,7 +1363,7 @@
return m->sq_ass_slice(s, i1, i2, o);
} else if ((mp = s->ob_type->tp_as_mapping) && mp->mp_ass_subscript) {
int res;
- PyObject *slice = sliceobj_from_intint(i1, i2);
+ PyObject *slice = _PySlice_FromIndices(i1, i2);
if (!slice)
return -1;
res = mp->mp_ass_subscript(s, slice, o);
@@ -1815,11 +1799,37 @@
return NULL;
}
+static PyObject*
+call_function_tail(PyObject *callable, PyObject *args)
+{
+ PyObject *retval;
+
+ if (args == NULL)
+ return NULL;
+
+ if (!PyTuple_Check(args)) {
+ PyObject *a;
+
+ a = PyTuple_New(1);
+ if (a == NULL) {
+ Py_DECREF(args);
+ return NULL;
+ }
+ PyTuple_SET_ITEM(a, 0, args);
+ args = a;
+ }
+ retval = PyObject_Call(callable, args, NULL);
+
+ Py_DECREF(args);
+
+ return retval;
+}
+
PyObject *
PyObject_CallFunction(PyObject *callable, char *format, ...)
{
va_list va;
- PyObject *args, *retval;
+ PyObject *args;
if (callable == NULL)
return null_error();
@@ -1832,31 +1842,34 @@
else
args = PyTuple_New(0);
- if (args == NULL)
- return NULL;
+ return call_function_tail(callable, args);
+}
- if (!PyTuple_Check(args)) {
- PyObject *a;
+PyObject *
+_PyObject_CallFunction_SizeT(PyObject *callable, char *format, ...)
+{
+ va_list va;
+ PyObject *args;
- a = PyTuple_New(1);
- if (a == NULL)
- return NULL;
- if (PyTuple_SetItem(a, 0, args) < 0)
- return NULL;
- args = a;
+ if (callable == NULL)
+ return null_error();
+
+ if (format && *format) {
+ va_start(va, format);
+ args = _Py_VaBuildValue_SizeT(format, va);
+ va_end(va);
}
- retval = PyObject_Call(callable, args, NULL);
+ else
+ args = PyTuple_New(0);
- Py_DECREF(args);
-
- return retval;
+ return call_function_tail(callable, args);
}
PyObject *
PyObject_CallMethod(PyObject *o, char *name, char *format, ...)
{
va_list va;
- PyObject *args = NULL;
+ PyObject *args;
PyObject *func = NULL;
PyObject *retval = NULL;
@@ -1882,24 +1895,49 @@
else
args = PyTuple_New(0);
- if (!args)
- goto exit;
-
- if (!PyTuple_Check(args)) {
- PyObject *a;
-
- a = PyTuple_New(1);
- if (a == NULL)
- goto exit;
- if (PyTuple_SetItem(a, 0, args) < 0)
- goto exit;
- args = a;
- }
-
- retval = PyObject_Call(func, args, NULL);
+ retval = call_function_tail(func, args);
exit:
- Py_XDECREF(args);
+ /* args gets consumed in call_function_tail */
+ Py_XDECREF(func);
+
+ return retval;
+}
+
+PyObject *
+_PyObject_CallMethod_SizeT(PyObject *o, char *name, char *format, ...)
+{
+ va_list va;
+ PyObject *args;
+ PyObject *func = NULL;
+ PyObject *retval = NULL;
+
+ if (o == NULL || name == NULL)
+ return null_error();
+
+ func = PyObject_GetAttrString(o, name);
+ if (func == NULL) {
+ PyErr_SetString(PyExc_AttributeError, name);
+ return 0;
+ }
+
+ if (!PyCallable_Check(func)) {
+ type_error("call of non-callable attribute");
+ goto exit;
+ }
+
+ if (format && *format) {
+ va_start(va, format);
+ args = _Py_VaBuildValue_SizeT(format, va);
+ va_end(va);
+ }
+ else
+ args = PyTuple_New(0);
+
+ retval = call_function_tail(func, args);
+
+ exit:
+ /* args gets consumed in call_function_tail */
Py_XDECREF(func);
return retval;
diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index 05784e5..79be184 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -103,42 +103,42 @@
/* Arithmetic methods -- only so we can override &, |, ^. */
static PyNumberMethods bool_as_number = {
- 0, /* nb_add */
- 0, /* nb_subtract */
- 0, /* nb_multiply */
- 0, /* nb_remainder */
- 0, /* nb_divmod */
- 0, /* nb_power */
- 0, /* nb_negative */
- 0, /* nb_positive */
- 0, /* nb_absolute */
- 0, /* nb_nonzero */
- 0, /* nb_invert */
- 0, /* nb_lshift */
- 0, /* nb_rshift */
- (binaryfunc)bool_and, /* nb_and */
- (binaryfunc)bool_xor, /* nb_xor */
- (binaryfunc)bool_or, /* nb_or */
- 0, /* nb_coerce */
- 0, /* nb_int */
- 0, /* nb_long */
- 0, /* nb_float */
- 0, /* nb_oct */
- 0, /* nb_hex */
- 0, /* nb_inplace_add */
- 0, /* nb_inplace_subtract */
- 0, /* nb_inplace_multiply */
- 0, /* nb_inplace_remainder */
- 0, /* nb_inplace_power */
- 0, /* nb_inplace_lshift */
- 0, /* nb_inplace_rshift */
- 0, /* nb_inplace_and */
- 0, /* nb_inplace_xor */
- 0, /* nb_inplace_or */
- 0, /* nb_floor_divide */
- 0, /* nb_true_divide */
- 0, /* nb_inplace_floor_divide */
- 0, /* nb_inplace_true_divide */
+ 0, /* nb_add */
+ 0, /* nb_subtract */
+ 0, /* nb_multiply */
+ 0, /* nb_remainder */
+ 0, /* nb_divmod */
+ 0, /* nb_power */
+ 0, /* nb_negative */
+ 0, /* nb_positive */
+ 0, /* nb_absolute */
+ 0, /* nb_nonzero */
+ 0, /* nb_invert */
+ 0, /* nb_lshift */
+ 0, /* nb_rshift */
+ bool_and, /* nb_and */
+ bool_xor, /* nb_xor */
+ bool_or, /* nb_or */
+ 0, /* nb_coerce */
+ 0, /* nb_int */
+ 0, /* nb_long */
+ 0, /* nb_float */
+ 0, /* nb_oct */
+ 0, /* nb_hex */
+ 0, /* nb_inplace_add */
+ 0, /* nb_inplace_subtract */
+ 0, /* nb_inplace_multiply */
+ 0, /* nb_inplace_remainder */
+ 0, /* nb_inplace_power */
+ 0, /* nb_inplace_lshift */
+ 0, /* nb_inplace_rshift */
+ 0, /* nb_inplace_and */
+ 0, /* nb_inplace_xor */
+ 0, /* nb_inplace_or */
+ 0, /* nb_floor_divide */
+ 0, /* nb_true_divide */
+ 0, /* nb_inplace_floor_divide */
+ 0, /* nb_inplace_true_divide */
};
/* The type object for bool. Note that this cannot be subclassed! */
diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index eff06aa..d2597b9 100644
--- a/Objects/bufferobject.c
+++ b/Objects/bufferobject.c
@@ -169,7 +169,7 @@
}
/* XXX: check for overflow in multiply */
/* Inline PyObject_New */
- o = PyObject_MALLOC(sizeof(*b) + size);
+ o = (PyObject *)PyObject_MALLOC(sizeof(*b) + size);
if ( o == NULL )
return PyErr_NoMemory();
b = (PyBufferObject *) PyObject_INIT(o, &PyBuffer_Type);
@@ -305,7 +305,7 @@
Py_ssize_t size;
if (!get_buf(self, &ptr, &size))
return NULL;
- return PyString_FromStringAndSize(ptr, size);
+ return PyString_FromStringAndSize((const char *)ptr, size);
}
/* Sequence methods */
diff --git a/Objects/cellobject.c b/Objects/cellobject.c
index 3b87093..da48dea 100644
--- a/Objects/cellobject.c
+++ b/Objects/cellobject.c
@@ -73,19 +73,29 @@
static int
cell_traverse(PyCellObject *op, visitproc visit, void *arg)
{
- if (op->ob_ref)
- return visit(op->ob_ref, arg);
+ Py_VISIT(op->ob_ref);
return 0;
}
static int
cell_clear(PyCellObject *op)
{
- Py_XDECREF(op->ob_ref);
- op->ob_ref = NULL;
+ Py_CLEAR(op->ob_ref);
return 0;
}
+static PyObject *
+cell_get_contents(PyCellObject *op, void *closure)
+{
+ Py_XINCREF(op->ob_ref);
+ return op->ob_ref;
+}
+
+static PyGetSetDef cell_getsetlist[] = {
+ {"cell_contents", (getter)cell_get_contents, NULL},
+ {NULL} /* sentinel */
+};
+
PyTypeObject PyCell_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
@@ -111,4 +121,11 @@
0, /* tp_doc */
(traverseproc)cell_traverse, /* tp_traverse */
(inquiry)cell_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ cell_getsetlist, /* tp_getset */
};
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 93acb50..594de11 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -208,7 +208,7 @@
{
register PyObject *v;
register char *sname = PyString_AsString(name);
- PyClassObject *class;
+ PyClassObject *klass;
descrgetfunc f;
if (sname[0] == '_' && sname[1] == '_') {
@@ -234,7 +234,7 @@
return v;
}
}
- v = class_lookup(op, name, &class);
+ v = class_lookup(op, name, &klass);
if (v == NULL) {
PyErr_Format(PyExc_AttributeError,
"class %.50s has no attribute '%.400s'",
@@ -388,15 +388,15 @@
Py_INCREF(name);
return name;
}
- m = PyString_Size(mod);
- n = PyString_Size(name);
+ m = PyString_GET_SIZE(mod);
+ n = PyString_GET_SIZE(name);
res = PyString_FromStringAndSize((char *)NULL, m+1+n);
if (res != NULL) {
- char *s = PyString_AsString(res);
- memcpy(s, PyString_AsString(mod), m);
+ char *s = PyString_AS_STRING(res);
+ memcpy(s, PyString_AS_STRING(mod), m);
s += m;
*s++ = '.';
- memcpy(s, PyString_AsString(name), n);
+ memcpy(s, PyString_AS_STRING(name), n);
}
return res;
}
@@ -404,37 +404,12 @@
static int
class_traverse(PyClassObject *o, visitproc visit, void *arg)
{
- int err;
- if (o->cl_bases) {
- err = visit(o->cl_bases, arg);
- if (err)
- return err;
- }
- if (o->cl_dict) {
- err = visit(o->cl_dict, arg);
- if (err)
- return err;
- }
- if (o->cl_name) {
- err = visit(o->cl_name, arg);
- if (err)
- return err;
- }
- if (o->cl_getattr) {
- err = visit(o->cl_getattr, arg);
- if (err)
- return err;
- }
- if (o->cl_setattr) {
- err = visit(o->cl_setattr, arg);
- if (err)
- return err;
- }
- if (o->cl_delattr) {
- err = visit(o->cl_delattr, arg);
- if (err)
- return err;
- }
+ Py_VISIT(o->cl_bases);
+ Py_VISIT(o->cl_dict);
+ Py_VISIT(o->cl_name);
+ Py_VISIT(o->cl_getattr);
+ Py_VISIT(o->cl_setattr);
+ Py_VISIT(o->cl_delattr);
return 0;
}
@@ -481,23 +456,23 @@
};
int
-PyClass_IsSubclass(PyObject *class, PyObject *base)
+PyClass_IsSubclass(PyObject *klass, PyObject *base)
{
Py_ssize_t i, n;
PyClassObject *cp;
- if (class == base)
+ if (klass == base)
return 1;
if (PyTuple_Check(base)) {
n = PyTuple_GET_SIZE(base);
for (i = 0; i < n; i++) {
- if (PyClass_IsSubclass(class, PyTuple_GET_ITEM(base, i)))
+ if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))
return 1;
}
return 0;
}
- if (class == NULL || !PyClass_Check(class))
+ if (klass == NULL || !PyClass_Check(klass))
return 0;
- cp = (PyClassObject *)class;
+ cp = (PyClassObject *)klass;
n = PyTuple_Size(cp->cl_bases);
for (i = 0; i < n; i++) {
if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
@@ -719,7 +694,7 @@
instance_getattr2(register PyInstanceObject *inst, PyObject *name)
{
register PyObject *v;
- PyClassObject *class;
+ PyClassObject *klass;
descrgetfunc f;
v = PyDict_GetItem(inst->in_dict, name);
@@ -727,7 +702,7 @@
Py_INCREF(v);
return v;
}
- v = class_lookup(inst->in_class, name, &class);
+ v = class_lookup(inst->in_class, name, &klass);
if (v != NULL) {
Py_INCREF(v);
f = TP_DESCR_GET(v->ob_type);
@@ -767,7 +742,7 @@
_PyInstance_Lookup(PyObject *pinst, PyObject *name)
{
PyObject *v;
- PyClassObject *class;
+ PyClassObject *klass;
PyInstanceObject *inst; /* pinst cast to the right type */
assert(PyInstance_Check(pinst));
@@ -777,7 +752,7 @@
v = PyDict_GetItem(inst->in_dict, name);
if (v == NULL)
- v = class_lookup(inst->in_class, name, &class);
+ v = class_lookup(inst->in_class, name, &klass);
return v;
}
@@ -979,17 +954,8 @@
static int
instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
{
- int err;
- if (o->in_class) {
- err = visit((PyObject *)(o->in_class), arg);
- if (err)
- return err;
- }
- if (o->in_dict) {
- err = visit(o->in_dict, arg);
- if (err)
- return err;
- }
+ Py_VISIT(o->in_class);
+ Py_VISIT(o->in_dict);
return 0;
}
@@ -1128,27 +1094,6 @@
}
static PyObject *
-sliceobj_from_intint(Py_ssize_t i, Py_ssize_t j)
-{
- PyObject *start, *end, *res;
-
- start = PyInt_FromLong((long)i);
- if (!start)
- return NULL;
-
- end = PyInt_FromLong((long)j);
- if (!end) {
- Py_DECREF(start);
- return NULL;
- }
- res = PySlice_New(start, end, NULL);
- Py_DECREF(start);
- Py_DECREF(end);
- return res;
-}
-
-
-static PyObject *
instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j)
{
PyObject *func, *arg, *res;
@@ -1168,7 +1113,7 @@
func = instance_getattr(inst, getitemstr);
if (func == NULL)
return NULL;
- arg = Py_BuildValue("(N)", sliceobj_from_intint(i, j));
+ arg = Py_BuildValue("(N)", _PySlice_FromIndices(i, j));
} else
arg = Py_BuildValue("(nn)", i, j);
@@ -1239,7 +1184,7 @@
return -1;
arg = Py_BuildValue("(N)",
- sliceobj_from_intint(i, j));
+ _PySlice_FromIndices(i, j));
} else
arg = Py_BuildValue("(nn)", i, j);
}
@@ -1260,7 +1205,7 @@
return -1;
arg = Py_BuildValue("(NO)",
- sliceobj_from_intint(i, j), value);
+ _PySlice_FromIndices(i, j), value);
} else
arg = Py_BuildValue("(nnO)", i, j, value);
}
@@ -2049,43 +1994,43 @@
static PyNumberMethods instance_as_number = {
- (binaryfunc)instance_add, /* nb_add */
- (binaryfunc)instance_sub, /* nb_subtract */
- (binaryfunc)instance_mul, /* nb_multiply */
- (binaryfunc)instance_mod, /* nb_remainder */
- (binaryfunc)instance_divmod, /* nb_divmod */
- (ternaryfunc)instance_pow, /* nb_power */
- (unaryfunc)instance_neg, /* nb_negative */
- (unaryfunc)instance_pos, /* nb_positive */
- (unaryfunc)instance_abs, /* nb_absolute */
- (inquiry)instance_nonzero, /* nb_nonzero */
- (unaryfunc)instance_invert, /* nb_invert */
- (binaryfunc)instance_lshift, /* nb_lshift */
- (binaryfunc)instance_rshift, /* nb_rshift */
- (binaryfunc)instance_and, /* nb_and */
- (binaryfunc)instance_xor, /* nb_xor */
- (binaryfunc)instance_or, /* nb_or */
- (coercion)instance_coerce, /* nb_coerce */
- (unaryfunc)instance_int, /* nb_int */
- (unaryfunc)instance_long, /* nb_long */
- (unaryfunc)instance_float, /* nb_float */
- (unaryfunc)instance_oct, /* nb_oct */
- (unaryfunc)instance_hex, /* nb_hex */
- (binaryfunc)instance_iadd, /* nb_inplace_add */
- (binaryfunc)instance_isub, /* nb_inplace_subtract */
- (binaryfunc)instance_imul, /* nb_inplace_multiply */
- (binaryfunc)instance_imod, /* nb_inplace_remainder */
- (ternaryfunc)instance_ipow, /* nb_inplace_power */
- (binaryfunc)instance_ilshift, /* nb_inplace_lshift */
- (binaryfunc)instance_irshift, /* nb_inplace_rshift */
- (binaryfunc)instance_iand, /* nb_inplace_and */
- (binaryfunc)instance_ixor, /* nb_inplace_xor */
- (binaryfunc)instance_ior, /* nb_inplace_or */
- (binaryfunc)instance_floordiv, /* nb_floor_divide */
- (binaryfunc)instance_truediv, /* nb_true_divide */
- (binaryfunc)instance_ifloordiv, /* nb_inplace_floor_divide */
- (binaryfunc)instance_itruediv, /* nb_inplace_true_divide */
- (lenfunc)instance_index, /* nb_index */
+ instance_add, /* nb_add */
+ instance_sub, /* nb_subtract */
+ instance_mul, /* nb_multiply */
+ instance_mod, /* nb_remainder */
+ instance_divmod, /* nb_divmod */
+ instance_pow, /* nb_power */
+ (unaryfunc)instance_neg, /* nb_negative */
+ (unaryfunc)instance_pos, /* nb_positive */
+ (unaryfunc)instance_abs, /* nb_absolute */
+ (inquiry)instance_nonzero, /* nb_nonzero */
+ (unaryfunc)instance_invert, /* nb_invert */
+ instance_lshift, /* nb_lshift */
+ instance_rshift, /* nb_rshift */
+ instance_and, /* nb_and */
+ instance_xor, /* nb_xor */
+ instance_or, /* nb_or */
+ instance_coerce, /* nb_coerce */
+ (unaryfunc)instance_int, /* nb_int */
+ (unaryfunc)instance_long, /* nb_long */
+ (unaryfunc)instance_float, /* nb_float */
+ (unaryfunc)instance_oct, /* nb_oct */
+ (unaryfunc)instance_hex, /* nb_hex */
+ instance_iadd, /* nb_inplace_add */
+ instance_isub, /* nb_inplace_subtract */
+ instance_imul, /* nb_inplace_multiply */
+ instance_imod, /* nb_inplace_remainder */
+ instance_ipow, /* nb_inplace_power */
+ instance_ilshift, /* nb_inplace_lshift */
+ instance_irshift, /* nb_inplace_rshift */
+ instance_iand, /* nb_inplace_and */
+ instance_ixor, /* nb_inplace_xor */
+ instance_ior, /* nb_inplace_or */
+ instance_floordiv, /* nb_floor_divide */
+ instance_truediv, /* nb_true_divide */
+ instance_ifloordiv, /* nb_inplace_floor_divide */
+ instance_itruediv, /* nb_inplace_true_divide */
+ (lenfunc)instance_index, /* nb_index */
};
PyTypeObject PyInstance_Type = {
@@ -2140,7 +2085,7 @@
static PyMethodObject *free_list;
PyObject *
-PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
+PyMethod_New(PyObject *func, PyObject *self, PyObject *klass)
{
register PyMethodObject *im;
if (!PyCallable_Check(func)) {
@@ -2162,8 +2107,8 @@
im->im_func = func;
Py_XINCREF(self);
im->im_self = self;
- Py_XINCREF(class);
- im->im_class = class;
+ Py_XINCREF(klass);
+ im->im_class = klass;
_PyObject_GC_TRACK(im);
return (PyObject *)im;
}
@@ -2365,35 +2310,22 @@
static int
instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
{
- int err;
- if (im->im_func) {
- err = visit(im->im_func, arg);
- if (err)
- return err;
- }
- if (im->im_self) {
- err = visit(im->im_self, arg);
- if (err)
- return err;
- }
- if (im->im_class) {
- err = visit(im->im_class, arg);
- if (err)
- return err;
- }
+ Py_VISIT(im->im_func);
+ Py_VISIT(im->im_self);
+ Py_VISIT(im->im_class);
return 0;
}
static void
-getclassname(PyObject *class, char *buf, int bufsize)
+getclassname(PyObject *klass, char *buf, int bufsize)
{
PyObject *name;
assert(bufsize > 1);
strcpy(buf, "?"); /* Default outcome */
- if (class == NULL)
+ if (klass == NULL)
return;
- name = PyObject_GetAttrString(class, "__name__");
+ name = PyObject_GetAttrString(klass, "__name__");
if (name == NULL) {
/* This function cannot return an exception */
PyErr_Clear();
@@ -2409,7 +2341,7 @@
static void
getinstclassname(PyObject *inst, char *buf, int bufsize)
{
- PyObject *class;
+ PyObject *klass;
if (inst == NULL) {
assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
@@ -2417,22 +2349,22 @@
return;
}
- class = PyObject_GetAttrString(inst, "__class__");
- if (class == NULL) {
+ klass = PyObject_GetAttrString(inst, "__class__");
+ if (klass == NULL) {
/* This function cannot return an exception */
PyErr_Clear();
- class = (PyObject *)(inst->ob_type);
- Py_INCREF(class);
+ klass = (PyObject *)(inst->ob_type);
+ Py_INCREF(klass);
}
- getclassname(class, buf, bufsize);
- Py_XDECREF(class);
+ getclassname(klass, buf, bufsize);
+ Py_XDECREF(klass);
}
static PyObject *
instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)
{
PyObject *self = PyMethod_GET_SELF(func);
- PyObject *class = PyMethod_GET_CLASS(func);
+ PyObject *klass = PyMethod_GET_CLASS(func);
PyObject *result;
func = PyMethod_GET_FUNCTION(func);
@@ -2445,14 +2377,14 @@
if (self == NULL)
ok = 0;
else {
- ok = PyObject_IsInstance(self, class);
+ ok = PyObject_IsInstance(self, klass);
if (ok < 0)
return NULL;
}
if (!ok) {
char clsbuf[256];
char instbuf[256];
- getclassname(class, clsbuf, sizeof(clsbuf));
+ getclassname(klass, clsbuf, sizeof(clsbuf));
getinstclassname(self, instbuf, sizeof(instbuf));
PyErr_Format(PyExc_TypeError,
"unbound method %s%s must be called with "
@@ -2531,7 +2463,7 @@
(hashfunc)instancemethod_hash, /* tp_hash */
instancemethod_call, /* tp_call */
0, /* tp_str */
- (getattrofunc)instancemethod_getattro, /* tp_getattro */
+ instancemethod_getattro, /* tp_getattro */
PyObject_GenericSetAttr, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
diff --git a/Objects/cobject.c b/Objects/cobject.c
index f764a1d..b2cae9a 100644
--- a/Objects/cobject.c
+++ b/Objects/cobject.c
@@ -136,25 +136,26 @@
PyTypeObject PyCObject_Type = {
PyObject_HEAD_INIT(&PyType_Type)
- 0, /*ob_size*/
- "PyCObject", /*tp_name*/
- sizeof(PyCObject), /*tp_basicsize*/
- 0, /*tp_itemsize*/
+ 0, /*ob_size*/
+ "PyCObject", /*tp_name*/
+ sizeof(PyCObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
/* methods */
- (destructor)PyCObject_dealloc, /*tp_dealloc*/
- (printfunc)0, /*tp_print*/
- (getattrfunc)0, /*tp_getattr*/
- (setattrfunc)0, /*tp_setattr*/
- (cmpfunc)0, /*tp_compare*/
- (reprfunc)0, /*tp_repr*/
- 0, /*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- (hashfunc)0, /*tp_hash*/
- (ternaryfunc)0, /*tp_call*/
- (reprfunc)0, /*tp_str*/
-
- /* Space for future expansion */
- 0L,0L,0L,0L,
- PyCObject_Type__doc__ /* Documentation string */
+ (destructor)PyCObject_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ 0, /*tp_flags*/
+ PyCObject_Type__doc__ /*tp_doc*/
};
diff --git a/Objects/codeobject.c b/Objects/codeobject.c
index f832911..8ae2399 100644
--- a/Objects/codeobject.c
+++ b/Objects/codeobject.c
@@ -451,3 +451,136 @@
}
return line;
}
+
+/*
+ Check whether the current instruction is at the start of a line.
+
+ */
+
+ /* The theory of SET_LINENO-less tracing.
+
+ In a nutshell, we use the co_lnotab field of the code object
+ to tell when execution has moved onto a different line.
+
+ As mentioned above, the basic idea is so set things up so
+ that
+
+ *instr_lb <= frame->f_lasti < *instr_ub
+
+ is true so long as execution does not change lines.
+
+ This is all fairly simple. Digging the information out of
+ co_lnotab takes some work, but is conceptually clear.
+
+ Somewhat harder to explain is why we don't *always* call the
+ line trace function when the above test fails.
+
+ Consider this code:
+
+ 1: def f(a):
+ 2: if a:
+ 3: print 1
+ 4: else:
+ 5: print 2
+
+ which compiles to this:
+
+ 2 0 LOAD_FAST 0 (a)
+ 3 JUMP_IF_FALSE 9 (to 15)
+ 6 POP_TOP
+
+ 3 7 LOAD_CONST 1 (1)
+ 10 PRINT_ITEM
+ 11 PRINT_NEWLINE
+ 12 JUMP_FORWARD 6 (to 21)
+ >> 15 POP_TOP
+
+ 5 16 LOAD_CONST 2 (2)
+ 19 PRINT_ITEM
+ 20 PRINT_NEWLINE
+ >> 21 LOAD_CONST 0 (None)
+ 24 RETURN_VALUE
+
+ If 'a' is false, execution will jump to instruction at offset
+ 15 and the co_lnotab will claim that execution has moved to
+ line 3. This is at best misleading. In this case we could
+ associate the POP_TOP with line 4, but that doesn't make
+ sense in all cases (I think).
+
+ What we do is only call the line trace function if the co_lnotab
+ indicates we have jumped to the *start* of a line, i.e. if the
+ current instruction offset matches the offset given for the
+ start of a line by the co_lnotab.
+
+ This also takes care of the situation where 'a' is true.
+ Execution will jump from instruction offset 12 to offset 21.
+ Then the co_lnotab would imply that execution has moved to line
+ 5, which is again misleading.
+
+ Why do we set f_lineno when tracing? Well, consider the code
+ above when 'a' is true. If stepping through this with 'n' in
+ pdb, you would stop at line 1 with a "call" type event, then
+ line events on lines 2 and 3, then a "return" type event -- but
+ you would be shown line 5 during this event. This is a change
+ from the behaviour in 2.2 and before, and I've found it
+ confusing in practice. By setting and using f_lineno when
+ tracing, one can report a line number different from that
+ suggested by f_lasti on this one occasion where it's desirable.
+ */
+
+
+int
+PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds)
+{
+ int size, addr, line;
+ unsigned char* p;
+
+ p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
+ size = PyString_GET_SIZE(co->co_lnotab) / 2;
+
+ addr = 0;
+ line = co->co_firstlineno;
+ assert(line > 0);
+
+ /* possible optimization: if f->f_lasti == instr_ub
+ (likely to be a common case) then we already know
+ instr_lb -- if we stored the matching value of p
+ somwhere we could skip the first while loop. */
+
+ /* see comments in compile.c for the description of
+ co_lnotab. A point to remember: increments to p
+ should come in pairs -- although we don't care about
+ the line increments here, treating them as byte
+ increments gets confusing, to say the least. */
+
+ while (size > 0) {
+ if (addr + *p > lasti)
+ break;
+ addr += *p++;
+ if (*p)
+ bounds->ap_lower = addr;
+ line += *p++;
+ --size;
+ }
+
+ /* If lasti and addr don't match exactly, we don't want to
+ change the lineno slot on the frame or execute a trace
+ function. Return -1 instead.
+ */
+ if (addr != lasti)
+ line = -1;
+
+ if (size > 0) {
+ while (--size >= 0) {
+ addr += *p++;
+ if (*p++)
+ break;
+ }
+ bounds->ap_upper = addr;
+ }
+ else {
+ bounds->ap_upper = INT_MAX;
+ }
+
+ return line;
+}
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index f0915dd..c6021e9 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -667,7 +667,7 @@
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
- if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) {
+ if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(s_buffer)) {
PyErr_SetString(PyExc_ValueError,
"complex() literal too large to convert");
return NULL;
@@ -940,10 +940,10 @@
0, /* nb_and */
0, /* nb_xor */
0, /* nb_or */
- (coercion)complex_coerce, /* nb_coerce */
- (unaryfunc)complex_int, /* nb_int */
- (unaryfunc)complex_long, /* nb_long */
- (unaryfunc)complex_float, /* nb_float */
+ complex_coerce, /* nb_coerce */
+ complex_int, /* nb_int */
+ complex_long, /* nb_long */
+ complex_float, /* nb_float */
0, /* nb_oct */
0, /* nb_hex */
0, /* nb_inplace_add */
@@ -968,7 +968,7 @@
"complex",
sizeof(PyComplexObject),
0,
- (destructor)complex_dealloc, /* tp_dealloc */
+ complex_dealloc, /* tp_dealloc */
(printfunc)complex_print, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index 9494062..561ba4a5 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -377,13 +377,7 @@
descr_traverse(PyObject *self, visitproc visit, void *arg)
{
PyDescrObject *descr = (PyDescrObject *)self;
- int err;
-
- if (descr->d_type) {
- err = visit((PyObject *)(descr->d_type), arg);
- if (err)
- return err;
- }
+ Py_VISIT(descr->d_type);
return 0;
}
@@ -480,7 +474,7 @@
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
+ 0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
@@ -518,7 +512,7 @@
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
+ 0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
@@ -814,13 +808,7 @@
proxy_traverse(PyObject *self, visitproc visit, void *arg)
{
proxyobject *pp = (proxyobject *)self;
- int err;
-
- if (pp->dict) {
- err = visit(pp->dict, arg);
- if (err)
- return err;
- }
+ Py_VISIT(pp->dict);
return 0;
}
@@ -999,18 +987,8 @@
wrapper_traverse(PyObject *self, visitproc visit, void *arg)
{
wrapperobject *wp = (wrapperobject *)self;
- int err;
-
- if (wp->descr) {
- err = visit((PyObject *)(wp->descr), arg);
- if (err)
- return err;
- }
- if (wp->self) {
- err = visit(wp->self, arg);
- if (err)
- return err;
- }
+ Py_VISIT(wp->descr);
+ Py_VISIT(wp->self);
return 0;
}
@@ -1237,20 +1215,10 @@
property_traverse(PyObject *self, visitproc visit, void *arg)
{
propertyobject *pp = (propertyobject *)self;
- int err;
-
-#define VISIT(SLOT) \
- if (pp->SLOT) { \
- err = visit((PyObject *)(pp->SLOT), arg); \
- if (err) \
- return err; \
- }
-
- VISIT(prop_get);
- VISIT(prop_set);
- VISIT(prop_del);
- VISIT(prop_doc);
-
+ Py_VISIT(pp->prop_get);
+ Py_VISIT(pp->prop_set);
+ Py_VISIT(pp->prop_del);
+ Py_VISIT(pp->prop_doc);
return 0;
}
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 0eccdbb..f5799ee 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -115,6 +115,14 @@
/* Object used as dummy key to fill deleted entries */
static PyObject *dummy = NULL; /* Initialized by first call to newdictobject() */
+#ifdef Py_REF_DEBUG
+PyObject *
+_PyDict_Dummy(void)
+{
+ return dummy;
+}
+#endif
+
/* forward declarations */
static dictentry *
lookdict_string(dictobject *mp, PyObject *key, long hash);
@@ -1724,17 +1732,12 @@
dict_traverse(PyObject *op, visitproc visit, void *arg)
{
Py_ssize_t i = 0;
- int err;
PyObject *pk;
PyObject *pv;
while (PyDict_Next(op, &i, &pk, &pv)) {
- err = visit(pk, arg);
- if (err)
- return err;
- err = visit(pv, arg);
- if (err)
- return err;
+ Py_VISIT(pk);
+ Py_VISIT(pv);
}
return 0;
}
@@ -1880,16 +1883,16 @@
/* Hack to implement "key in dict" */
static PySequenceMethods dict_as_sequence = {
- 0, /* sq_length */
- 0, /* sq_concat */
- 0, /* sq_repeat */
- 0, /* sq_item */
- 0, /* sq_slice */
- 0, /* sq_ass_item */
- 0, /* sq_ass_slice */
- (objobjproc)PyDict_Contains, /* sq_contains */
- 0, /* sq_inplace_concat */
- 0, /* sq_inplace_repeat */
+ 0, /* sq_length */
+ 0, /* sq_concat */
+ 0, /* sq_repeat */
+ 0, /* sq_item */
+ 0, /* sq_slice */
+ 0, /* sq_ass_item */
+ 0, /* sq_ass_slice */
+ PyDict_Contains, /* sq_contains */
+ 0, /* sq_inplace_concat */
+ 0, /* sq_inplace_repeat */
};
static PyObject *
@@ -1966,8 +1969,8 @@
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
Py_TPFLAGS_BASETYPE, /* tp_flags */
dictionary_doc, /* tp_doc */
- (traverseproc)dict_traverse, /* tp_traverse */
- (inquiry)dict_tp_clear, /* tp_clear */
+ dict_traverse, /* tp_traverse */
+ dict_tp_clear, /* tp_clear */
dict_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc)dict_iter, /* tp_iter */
@@ -1980,7 +1983,7 @@
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
- (initproc)dict_init, /* tp_init */
+ dict_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
dict_new, /* tp_new */
PyObject_GC_Del, /* tp_free */
diff --git a/Objects/enumobject.c b/Objects/enumobject.c
index 4811239..a8f43e0 100644
--- a/Objects/enumobject.c
+++ b/Objects/enumobject.c
@@ -9,8 +9,6 @@
PyObject* en_result; /* result tuple */
} enumobject;
-PyTypeObject PyEnum_Type;
-
static PyObject *
enum_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
@@ -51,18 +49,8 @@
static int
enum_traverse(enumobject *en, visitproc visit, void *arg)
{
- int err;
-
- if (en->en_sit) {
- err = visit(en->en_sit, arg);
- if (err)
- return err;
- }
- if (en->en_result) {
- err = visit(en->en_result, arg);
- if (err)
- return err;
- }
+ Py_VISIT(en->en_sit);
+ Py_VISIT(en->en_result);
return 0;
}
@@ -207,8 +195,7 @@
static int
reversed_traverse(reversedobject *ro, visitproc visit, void *arg)
{
- if (ro->seq)
- return visit((PyObject *)(ro->seq), arg);
+ Py_VISIT(ro->seq);
return 0;
}
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index f96ee7b..632ab04 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -48,6 +48,10 @@
#define NEWLINE_LF 2 /* \n newline seen */
#define NEWLINE_CRLF 4 /* \r\n newline seen */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
FILE *
PyFile_AsFile(PyObject *f)
{
@@ -313,7 +317,8 @@
PyMem_Free(file->f_setbuf);
file->f_setbuf = NULL;
} else {
- file->f_setbuf = PyMem_Realloc(file->f_setbuf, bufsize);
+ file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf,
+ bufsize);
}
#ifdef HAVE_SETVBUF
setvbuf(file->f_fp, file->f_setbuf, type, bufsize);
@@ -818,7 +823,7 @@
buffersize = new_buffersize(f, (size_t)0);
else
buffersize = bytesrequested;
- if (buffersize > INT_MAX) {
+ if (buffersize > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"requested number of bytes is more than a Python string can hold");
return NULL;
@@ -1093,7 +1098,7 @@
assert(*(pvend-1) == '\0');
increment = total_v_size >> 2; /* mild exponential growth */
total_v_size += increment;
- if (total_v_size > INT_MAX) {
+ if (total_v_size > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"line is longer than a Python string can hold");
Py_DECREF(v);
@@ -1204,7 +1209,7 @@
used_v_size = total_v_size;
increment = total_v_size >> 2; /* mild exponential growth */
total_v_size += increment;
- if (total_v_size > INT_MAX) {
+ if (total_v_size > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"line is longer than a Python string can hold");
Py_DECREF(v);
@@ -1391,12 +1396,12 @@
goto cleanup;
}
totalread += nread;
- p = memchr(buffer+nfilled, '\n', nread);
+ p = (char *)memchr(buffer+nfilled, '\n', nread);
if (p == NULL) {
/* Need a larger buffer to fit this line */
nfilled += nread;
buffersize *= 2;
- if (buffersize > INT_MAX) {
+ if (buffersize > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"line is longer than a Python string can hold");
goto error;
@@ -1431,7 +1436,7 @@
if (err != 0)
goto error;
q = p;
- p = memchr(q, '\n', end-q);
+ p = (char *)memchr(q, '\n', end-q);
} while (p != NULL);
/* Move the remaining incomplete line to the start */
nfilled = end-q;
@@ -1790,7 +1795,7 @@
/* Make sure that file has a readahead buffer with at least one byte
(unless at EOF) and no more than bufsize. Returns negative value on
- error */
+ error, will set MemoryError if bufsize bytes cannot be allocated. */
static int
readahead(PyFileObject *f, int bufsize)
{
@@ -1802,7 +1807,8 @@
else
drop_readahead(f);
}
- if ((f->f_buf = PyMem_Malloc(bufsize)) == NULL) {
+ if ((f->f_buf = (char *)PyMem_Malloc(bufsize)) == NULL) {
+ PyErr_NoMemory();
return -1;
}
Py_BEGIN_ALLOW_THREADS
@@ -1844,7 +1850,7 @@
if (len == 0)
return (PyStringObject *)
PyString_FromStringAndSize(NULL, skip);
- bufptr = memchr(f->f_bufptr, '\n', len);
+ bufptr = (char *)memchr(f->f_bufptr, '\n', len);
if (bufptr != NULL) {
bufptr++; /* Count the '\n' */
len = bufptr - f->f_bufptr;
@@ -2056,7 +2062,7 @@
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
- (initproc)file_init, /* tp_init */
+ file_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
file_new, /* tp_new */
PyObject_Del, /* tp_free */
@@ -2432,3 +2438,8 @@
f->f_skipnextlf = skipnextlf;
return dst - buf;
}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 20ed86e..8708690 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -97,7 +97,7 @@
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
- if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) {
+ if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(s_buffer)) {
PyErr_SetString(PyExc_ValueError,
"Unicode float() literal too long to convert");
return NULL;
@@ -940,21 +940,21 @@
static PyObject *
float_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *tmp, *new;
+ PyObject *tmp, *newobj;
assert(PyType_IsSubtype(type, &PyFloat_Type));
tmp = float_new(&PyFloat_Type, args, kwds);
if (tmp == NULL)
return NULL;
assert(PyFloat_CheckExact(tmp));
- new = type->tp_alloc(type, 0);
- if (new == NULL) {
+ newobj = type->tp_alloc(type, 0);
+ if (newobj == NULL) {
Py_DECREF(tmp);
return NULL;
}
- ((PyFloatObject *)new)->ob_fval = ((PyFloatObject *)tmp)->ob_fval;
+ ((PyFloatObject *)newobj)->ob_fval = ((PyFloatObject *)tmp)->ob_fval;
Py_DECREF(tmp);
- return new;
+ return newobj;
}
static PyObject *
@@ -1106,12 +1106,12 @@
static PyNumberMethods float_as_number = {
- (binaryfunc)float_add, /*nb_add*/
- (binaryfunc)float_sub, /*nb_subtract*/
- (binaryfunc)float_mul, /*nb_multiply*/
- (binaryfunc)float_rem, /*nb_remainder*/
- (binaryfunc)float_divmod, /*nb_divmod*/
- (ternaryfunc)float_pow, /*nb_power*/
+ float_add, /*nb_add*/
+ float_sub, /*nb_subtract*/
+ float_mul, /*nb_multiply*/
+ float_rem, /*nb_remainder*/
+ float_divmod, /*nb_divmod*/
+ float_pow, /*nb_power*/
(unaryfunc)float_neg, /*nb_negative*/
(unaryfunc)float_pos, /*nb_positive*/
(unaryfunc)float_abs, /*nb_absolute*/
@@ -1122,10 +1122,10 @@
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
- (coercion)float_coerce, /*nb_coerce*/
- (unaryfunc)float_int, /*nb_int*/
- (unaryfunc)float_long, /*nb_long*/
- (unaryfunc)float_float, /*nb_float*/
+ float_coerce, /*nb_coerce*/
+ float_int, /*nb_int*/
+ float_long, /*nb_long*/
+ float_float, /*nb_float*/
0, /* nb_oct */
0, /* nb_hex */
0, /* nb_inplace_add */
@@ -1170,7 +1170,7 @@
float_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
- (richcmpfunc)float_richcompare, /* tp_richcompare */
+ float_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
index 6e3f297..9aabc7a 100644
--- a/Objects/frameobject.c
+++ b/Objects/frameobject.c
@@ -1,4 +1,3 @@
-
/* Frame object implementation */
#include "Python.h"
@@ -333,7 +332,7 @@
Py_XINCREF(v);
f->f_trace = v;
-
+
if (v != NULL)
f->f_lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
@@ -399,7 +398,7 @@
for (p = f->f_valuestack; p < f->f_stacktop; p++)
Py_XDECREF(*p);
}
-
+
Py_XDECREF(f->f_back);
Py_DECREF(f->f_code);
Py_DECREF(f->f_builtins);
@@ -423,30 +422,28 @@
frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
{
PyObject **fastlocals, **p;
- int i, err, slots;
-#define VISIT(o) if (o) {if ((err = visit((PyObject *)(o), arg))) return err;}
+ int i, slots;
- VISIT(f->f_back);
- VISIT(f->f_code);
- VISIT(f->f_builtins);
- VISIT(f->f_globals);
- VISIT(f->f_locals);
- VISIT(f->f_trace);
- VISIT(f->f_exc_type);
- VISIT(f->f_exc_value);
- VISIT(f->f_exc_traceback);
+ Py_VISIT(f->f_back);
+ Py_VISIT(f->f_code);
+ Py_VISIT(f->f_builtins);
+ Py_VISIT(f->f_globals);
+ Py_VISIT(f->f_locals);
+ Py_VISIT(f->f_trace);
+ Py_VISIT(f->f_exc_type);
+ Py_VISIT(f->f_exc_value);
+ Py_VISIT(f->f_exc_traceback);
/* locals */
slots = f->f_nlocals + f->f_ncells + f->f_nfreevars;
fastlocals = f->f_localsplus;
- for (i = slots; --i >= 0; ++fastlocals) {
- VISIT(*fastlocals);
- }
+ for (i = slots; --i >= 0; ++fastlocals)
+ Py_VISIT(*fastlocals);
/* stack */
if (f->f_stacktop != NULL) {
for (p = f->f_valuestack; p < f->f_stacktop; p++)
- VISIT(*p);
+ Py_VISIT(*p);
}
return 0;
}
@@ -454,37 +451,32 @@
static void
frame_clear(PyFrameObject *f)
{
- PyObject **fastlocals, **p;
+ PyObject **fastlocals, **p, **oldtop;
int i, slots;
- Py_XDECREF(f->f_exc_type);
- f->f_exc_type = NULL;
+ /* Before anything else, make sure that this frame is clearly marked
+ * as being defunct! Else, e.g., a generator reachable from this
+ * frame may also point to this frame, believe itself to still be
+ * active, and try cleaning up this frame again.
+ */
+ oldtop = f->f_stacktop;
+ f->f_stacktop = NULL;
- Py_XDECREF(f->f_exc_value);
- f->f_exc_value = NULL;
-
- Py_XDECREF(f->f_exc_traceback);
- f->f_exc_traceback = NULL;
-
- Py_XDECREF(f->f_trace);
- f->f_trace = NULL;
+ Py_CLEAR(f->f_exc_type);
+ Py_CLEAR(f->f_exc_value);
+ Py_CLEAR(f->f_exc_traceback);
+ Py_CLEAR(f->f_trace);
/* locals */
slots = f->f_nlocals + f->f_ncells + f->f_nfreevars;
fastlocals = f->f_localsplus;
- for (i = slots; --i >= 0; ++fastlocals) {
- if (*fastlocals != NULL) {
- Py_XDECREF(*fastlocals);
- *fastlocals = NULL;
- }
- }
+ for (i = slots; --i >= 0; ++fastlocals)
+ Py_CLEAR(*fastlocals);
/* stack */
- if (f->f_stacktop != NULL) {
- for (p = f->f_valuestack; p < f->f_stacktop; p++) {
- Py_XDECREF(*p);
- *p = NULL;
- }
+ if (oldtop != NULL) {
+ for (p = f->f_valuestack; p < oldtop; p++)
+ Py_CLEAR(*p);
}
}
@@ -534,7 +526,7 @@
}
PyFrameObject *
-PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
+PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
PyObject *locals)
{
PyFrameObject *back = tstate->frame;
@@ -563,10 +555,10 @@
builtins = NULL;
}
if (builtins == NULL) {
- /* No builtins! Make up a minimal one
+ /* No builtins! Make up a minimal one
Give them 'None', at least. */
builtins = PyDict_New();
- if (builtins == NULL ||
+ if (builtins == NULL ||
PyDict_SetItemString(
builtins, "None", Py_None) < 0)
return NULL;
@@ -611,7 +603,7 @@
Py_INCREF(globals);
f->f_globals = globals;
/* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
- if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
+ if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
(CO_NEWLOCALS | CO_OPTIMIZED))
locals = NULL; /* PyFrame_FastToLocals() will set. */
else if (code->co_flags & CO_NEWLOCALS) {
@@ -749,7 +741,7 @@
return;
PyErr_Fetch(&error_type, &error_value, &error_traceback);
fast = f->f_localsplus;
- j = PyTuple_Size(map);
+ j = PyTuple_GET_SIZE(map);
if (j > f->f_nlocals)
j = f->f_nlocals;
if (f->f_nlocals)
@@ -759,10 +751,10 @@
&& PyTuple_Check(f->f_code->co_freevars))) {
return;
}
- map_to_dict(f->f_code->co_cellvars,
+ map_to_dict(f->f_code->co_cellvars,
PyTuple_GET_SIZE(f->f_code->co_cellvars),
locals, fast + f->f_nlocals, 1);
- map_to_dict(f->f_code->co_freevars,
+ map_to_dict(f->f_code->co_freevars,
PyTuple_GET_SIZE(f->f_code->co_freevars),
locals, fast + f->f_nlocals + f->f_ncells, 1);
}
@@ -787,7 +779,7 @@
return;
PyErr_Fetch(&error_type, &error_value, &error_traceback);
fast = f->f_localsplus;
- j = PyTuple_Size(map);
+ j = PyTuple_GET_SIZE(map);
if (j > f->f_nlocals)
j = f->f_nlocals;
if (f->f_nlocals)
@@ -796,12 +788,12 @@
if (!(PyTuple_Check(f->f_code->co_cellvars)
&& PyTuple_Check(f->f_code->co_freevars)))
return;
- dict_to_map(f->f_code->co_cellvars,
+ dict_to_map(f->f_code->co_cellvars,
PyTuple_GET_SIZE(f->f_code->co_cellvars),
locals, fast + f->f_nlocals, 1, clear);
- dict_to_map(f->f_code->co_freevars,
+ dict_to_map(f->f_code->co_freevars,
PyTuple_GET_SIZE(f->f_code->co_freevars),
- locals, fast + f->f_nlocals + f->f_ncells, 1,
+ locals, fast + f->f_nlocals + f->f_ncells, 1,
clear);
}
PyErr_Restore(error_type, error_value, error_traceback);
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
index 00ae2eb..59cb519 100644
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -466,47 +466,14 @@
static int
func_traverse(PyFunctionObject *f, visitproc visit, void *arg)
{
- int err;
- if (f->func_code) {
- err = visit(f->func_code, arg);
- if (err)
- return err;
- }
- if (f->func_globals) {
- err = visit(f->func_globals, arg);
- if (err)
- return err;
- }
- if (f->func_module) {
- err = visit(f->func_module, arg);
- if (err)
- return err;
- }
- if (f->func_defaults) {
- err = visit(f->func_defaults, arg);
- if (err)
- return err;
- }
- if (f->func_doc) {
- err = visit(f->func_doc, arg);
- if (err)
- return err;
- }
- if (f->func_name) {
- err = visit(f->func_name, arg);
- if (err)
- return err;
- }
- if (f->func_dict) {
- err = visit(f->func_dict, arg);
- if (err)
- return err;
- }
- if (f->func_closure) {
- err = visit(f->func_closure, arg);
- if (err)
- return err;
- }
+ Py_VISIT(f->func_code);
+ Py_VISIT(f->func_globals);
+ Py_VISIT(f->func_module);
+ Py_VISIT(f->func_defaults);
+ Py_VISIT(f->func_doc);
+ Py_VISIT(f->func_name);
+ Py_VISIT(f->func_dict);
+ Py_VISIT(f->func_closure);
return 0;
}
@@ -647,17 +614,14 @@
static int
cm_traverse(classmethod *cm, visitproc visit, void *arg)
{
- if (!cm->cm_callable)
- return 0;
- return visit(cm->cm_callable, arg);
+ Py_VISIT(cm->cm_callable);
+ return 0;
}
static int
cm_clear(classmethod *cm)
{
- Py_XDECREF(cm->cm_callable);
- cm->cm_callable = NULL;
-
+ Py_CLEAR(cm->cm_callable);
return 0;
}
@@ -808,9 +772,8 @@
static int
sm_traverse(staticmethod *sm, visitproc visit, void *arg)
{
- if (!sm->sm_callable)
- return 0;
- return visit(sm->sm_callable, arg);
+ Py_VISIT(sm->sm_callable);
+ return 0;
}
static int
diff --git a/Objects/genobject.c b/Objects/genobject.c
index 3f6ef85..15e53dd 100644
--- a/Objects/genobject.c
+++ b/Objects/genobject.c
@@ -5,11 +5,13 @@
#include "genobject.h"
#include "ceval.h"
#include "structmember.h"
+#include "opcode.h"
static int
gen_traverse(PyGenObject *gen, visitproc visit, void *arg)
{
- return visit((PyObject *)gen->gi_frame, arg);
+ Py_VISIT((PyObject *)gen->gi_frame);
+ return 0;
}
static void
@@ -20,12 +22,11 @@
_PyObject_GC_UNTRACK(gen);
if (gen->gi_weakreflist != NULL)
- PyObject_ClearWeakRefs((PyObject *) gen);
-
+ PyObject_ClearWeakRefs(self);
_PyObject_GC_TRACK(self);
- if (gen->gi_frame->f_stacktop!=NULL) {
+ if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {
/* Generator is paused, so we need to close */
gen->ob_type->tp_del(self);
if (self->ob_refcnt > 0)
@@ -33,7 +34,7 @@
}
_PyObject_GC_UNTRACK(self);
- Py_XDECREF(gen->gi_frame);
+ Py_CLEAR(gen->gi_frame);
PyObject_GC_Del(gen);
}
@@ -50,16 +51,18 @@
"generator already executing");
return NULL;
}
- if ((PyObject *)f == Py_None || f->f_stacktop == NULL) {
+ if (f==NULL || f->f_stacktop == NULL) {
/* Only set exception if called from send() */
- if (arg && !exc) PyErr_SetNone(PyExc_StopIteration);
+ if (arg && !exc)
+ PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
if (f->f_lasti == -1) {
if (arg && arg != Py_None) {
PyErr_SetString(PyExc_TypeError,
- "can't send non-None value to a just-started generator");
+ "can't send non-None value to a "
+ "just-started generator");
return NULL;
}
} else {
@@ -91,21 +94,22 @@
Py_DECREF(result);
result = NULL;
/* Set exception if not called by gen_iternext() */
- if (arg) PyErr_SetNone(PyExc_StopIteration);
+ if (arg)
+ PyErr_SetNone(PyExc_StopIteration);
}
if (!result || f->f_stacktop == NULL) {
/* generator can't be rerun, so release the frame */
Py_DECREF(f);
- gen->gi_frame = (PyFrameObject *)Py_None;
- Py_INCREF(Py_None);
+ gen->gi_frame = NULL;
}
return result;
}
PyDoc_STRVAR(send_doc,
-"send(arg) -> send 'arg' into generator, return next yielded value or raise StopIteration.");
+"send(arg) -> send 'arg' into generator,\n\
+return next yielded value or raise StopIteration.");
static PyObject *
gen_send(PyGenObject *gen, PyObject *arg)
@@ -125,11 +129,11 @@
if (retval) {
Py_DECREF(retval);
PyErr_SetString(PyExc_RuntimeError,
- "generator ignored GeneratorExit");
+ "generator ignored GeneratorExit");
return NULL;
}
- if ( PyErr_ExceptionMatches(PyExc_StopIteration)
- || PyErr_ExceptionMatches(PyExc_GeneratorExit) )
+ if (PyErr_ExceptionMatches(PyExc_StopIteration)
+ || PyErr_ExceptionMatches(PyExc_GeneratorExit))
{
PyErr_Clear(); /* ignore these errors */
Py_INCREF(Py_None);
@@ -145,7 +149,7 @@
PyObject *error_type, *error_value, *error_traceback;
PyGenObject *gen = (PyGenObject *)self;
- if ((PyObject *)gen->gi_frame == Py_None || gen->gi_frame->f_stacktop==NULL)
+ if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL)
/* Generator isn't paused, so no need to close */
return;
@@ -156,10 +160,10 @@
/* Save the current exception, if any. */
PyErr_Fetch(&error_type, &error_value, &error_traceback);
- res = gen_close((PyGenObject *)self, NULL);
+ res = gen_close(gen, NULL);
if (res == NULL)
- PyErr_WriteUnraisable((PyObject *)self);
+ PyErr_WriteUnraisable(self);
else
Py_DECREF(res);
@@ -181,7 +185,7 @@
_Py_NewReference(self);
self->ob_refcnt = refcnt;
}
- assert(!PyType_IS_GC(self->ob_type) ||
+ assert(PyType_IS_GC(self->ob_type) &&
_Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
/* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
@@ -202,10 +206,11 @@
PyDoc_STRVAR(throw_doc,
-"throw(typ[,val[,tb]]) -> raise exception in generator, return next yielded value or raise StopIteration.");
+"throw(typ[,val[,tb]]) -> raise exception in generator,\n\
+return next yielded value or raise StopIteration.");
static PyObject *
-gen_throw(PyGenObject *gen, PyObject *args)
+gen_throw(PyGenObject *gen, PyObject *args)
{
PyObject *typ;
PyObject *tb = NULL;
@@ -216,10 +221,8 @@
/* First, check the traceback argument, replacing None with
NULL. */
- if (tb == Py_None) {
- Py_DECREF(tb);
+ if (tb == Py_None)
tb = NULL;
- }
else if (tb != NULL && !PyTraceBack_Check(tb)) {
PyErr_SetString(PyExc_TypeError,
"throw() third argument must be a traceback object");
@@ -249,7 +252,10 @@
Py_INCREF(typ);
}
}
- else {
+
+ /* Allow raising builtin string exceptions */
+
+ else if (!PyString_CheckExact(typ)) {
/* Not something you can raise. throw() fails. */
PyErr_Format(PyExc_TypeError,
"exceptions must be classes, or instances, not %s",
@@ -257,7 +263,7 @@
goto failed_throw;
}
- PyErr_Restore(typ,val,tb);
+ PyErr_Restore(typ, val, tb);
return gen_send_ex(gen, Py_None, 1);
failed_throw:
@@ -324,7 +330,7 @@
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
-
+
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
@@ -355,3 +361,23 @@
_PyObject_GC_TRACK(gen);
return (PyObject *)gen;
}
+
+int
+PyGen_NeedsFinalizing(PyGenObject *gen)
+{
+ int i;
+ PyFrameObject *f = gen->gi_frame;
+
+ if (f == NULL || f->f_stacktop == NULL || f->f_iblock <= 0)
+ return 0; /* no frame or empty blockstack == no finalization */
+
+ /* Any block type besides a loop requires cleanup. */
+ i = f->f_iblock;
+ while (--i >= 0) {
+ if (f->f_blockstack[i].b_type != SETUP_LOOP)
+ return 1;
+ }
+
+ /* No blocks except loops, it's safe to skip finalization. */
+ return 0;
+}
diff --git a/Objects/intobject.c b/Objects/intobject.c
index c734840..fb3221f 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -255,18 +255,18 @@
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
nb->nb_int == NULL) {
PyErr_SetString(PyExc_TypeError, "an integer is required");
- return -1;
+ return (unsigned long)-1;
}
io = (PyIntObject*) (*nb->nb_int) (op);
if (io == NULL)
- return -1;
+ return (unsigned long)-1;
if (!PyInt_Check(io)) {
if (PyLong_Check(io)) {
val = PyLong_AsUnsignedLongMask((PyObject *)io);
Py_DECREF(io);
if (PyErr_Occurred())
- return -1;
+ return (unsigned long)-1;
return val;
}
else
@@ -274,7 +274,7 @@
Py_DECREF(io);
PyErr_SetString(PyExc_TypeError,
"nb_int should return int object");
- return -1;
+ return (unsigned long)-1;
}
}
@@ -300,18 +300,18 @@
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
nb->nb_int == NULL) {
PyErr_SetString(PyExc_TypeError, "an integer is required");
- return -1;
+ return (unsigned PY_LONG_LONG)-1;
}
io = (PyIntObject*) (*nb->nb_int) (op);
if (io == NULL)
- return -1;
+ return (unsigned PY_LONG_LONG)-1;
if (!PyInt_Check(io)) {
if (PyLong_Check(io)) {
val = PyLong_AsUnsignedLongLongMask((PyObject *)io);
Py_DECREF(io);
if (PyErr_Occurred())
- return -1;
+ return (unsigned PY_LONG_LONG)-1;
return val;
}
else
@@ -319,7 +319,7 @@
Py_DECREF(io);
PyErr_SetString(PyExc_TypeError,
"nb_int should return int object");
- return -1;
+ return (unsigned PY_LONG_LONG)-1;
}
}
@@ -335,7 +335,8 @@
{
char *end;
long x;
- char buffer[256]; /* For errors */
+ Py_ssize_t slen;
+ PyObject *sobj, *srepr;
if ((base != 0 && base < 2) || base > 36) {
PyErr_SetString(PyExc_ValueError,
@@ -359,9 +360,18 @@
end++;
if (*end != '\0') {
bad:
- PyOS_snprintf(buffer, sizeof(buffer),
- "invalid literal for int(): %.200s", s);
- PyErr_SetString(PyExc_ValueError, buffer);
+ slen = strlen(s) < 200 ? strlen(s) : 200;
+ sobj = PyString_FromStringAndSize(s, slen);
+ if (sobj == NULL)
+ return NULL;
+ srepr = PyObject_Repr(sobj);
+ Py_DECREF(sobj);
+ if (srepr == NULL)
+ return NULL;
+ PyErr_Format(PyExc_ValueError,
+ "invalid literal for int() with base %d: %s",
+ base, PyString_AS_STRING(srepr));
+ Py_DECREF(srepr);
return NULL;
}
else if (errno != 0)
@@ -376,7 +386,7 @@
PyInt_FromUnicode(Py_UNICODE *s, Py_ssize_t length, int base)
{
PyObject *result;
- char *buffer = PyMem_MALLOC(length+1);
+ char *buffer = (char *)PyMem_MALLOC(length+1);
if (buffer == NULL)
return NULL;
@@ -961,7 +971,7 @@
static PyObject *
int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *tmp, *new;
+ PyObject *tmp, *newobj;
long ival;
assert(PyType_IsSubtype(type, &PyInt_Type));
@@ -978,14 +988,14 @@
ival = ((PyIntObject *)tmp)->ob_ival;
}
- new = type->tp_alloc(type, 0);
- if (new == NULL) {
+ newobj = type->tp_alloc(type, 0);
+ if (newobj == NULL) {
Py_DECREF(tmp);
return NULL;
}
- ((PyIntObject *)new)->ob_ival = ival;
+ ((PyIntObject *)newobj)->ob_ival = ival;
Py_DECREF(tmp);
- return new;
+ return newobj;
}
static PyObject *
@@ -1046,7 +1056,7 @@
int_true_divide, /* nb_true_divide */
0, /* nb_inplace_floor_divide */
0, /* nb_inplace_true_divide */
- (lenfunc)PyInt_AsSsize_t, /* nb_index */
+ PyInt_AsSsize_t, /* nb_index */
};
PyTypeObject PyInt_Type = {
@@ -1119,6 +1129,7 @@
PyIntObject *p;
PyIntBlock *list, *next;
int i;
+ unsigned int ctr;
int bc, bf; /* block count, number of freed blocks */
int irem, isum; /* remaining unfreed ints per block, total */
@@ -1141,9 +1152,9 @@
while (list != NULL) {
bc++;
irem = 0;
- for (i = 0, p = &list->objects[0];
- i < N_INTOBJECTS;
- i++, p++) {
+ for (ctr = 0, p = &list->objects[0];
+ ctr < N_INTOBJECTS;
+ ctr++, p++) {
if (PyInt_CheckExact(p) && p->ob_refcnt != 0)
irem++;
}
@@ -1151,9 +1162,9 @@
if (irem) {
list->next = block_list;
block_list = list;
- for (i = 0, p = &list->objects[0];
- i < N_INTOBJECTS;
- i++, p++) {
+ for (ctr = 0, p = &list->objects[0];
+ ctr < N_INTOBJECTS;
+ ctr++, p++) {
if (!PyInt_CheckExact(p) ||
p->ob_refcnt == 0) {
p->ob_type = (struct _typeobject *)
@@ -1194,9 +1205,9 @@
if (Py_VerboseFlag > 1) {
list = block_list;
while (list != NULL) {
- for (i = 0, p = &list->objects[0];
- i < N_INTOBJECTS;
- i++, p++) {
+ for (ctr = 0, p = &list->objects[0];
+ ctr < N_INTOBJECTS;
+ ctr++, p++) {
if (PyInt_CheckExact(p) && p->ob_refcnt != 0)
/* XXX(twouters) cast refcount to
long until %zd is universally
diff --git a/Objects/iterobject.c b/Objects/iterobject.c
index 51f551b..cf839f4 100644
--- a/Objects/iterobject.c
+++ b/Objects/iterobject.c
@@ -38,9 +38,8 @@
static int
iter_traverse(seqiterobject *it, visitproc visit, void *arg)
{
- if (it->it_seq == NULL)
- return 0;
- return visit(it->it_seq, arg);
+ Py_VISIT(it->it_seq);
+ return 0;
}
static PyObject *
@@ -123,7 +122,7 @@
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
PyObject_SelfIter, /* tp_iter */
- (iternextfunc)iter_iternext, /* tp_iternext */
+ iter_iternext, /* tp_iternext */
seqiter_methods, /* tp_methods */
0, /* tp_members */
};
@@ -162,11 +161,8 @@
static int
calliter_traverse(calliterobject *it, visitproc visit, void *arg)
{
- int err;
- if (it->it_callable != NULL && (err = visit(it->it_callable, arg)))
- return err;
- if (it->it_sentinel != NULL && (err = visit(it->it_sentinel, arg)))
- return err;
+ Py_VISIT(it->it_callable);
+ Py_VISIT(it->it_sentinel);
return 0;
}
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 966d659..105df4c 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -181,7 +181,7 @@
PyErr_BadInternalCall();
return -1;
}
- if (n == INT_MAX) {
+ if (n == PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"cannot add more objects to list");
return -1;
@@ -221,7 +221,7 @@
Py_ssize_t n = PyList_GET_SIZE(self);
assert (v != NULL);
- if (n == INT_MAX) {
+ if (n == PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"cannot add more objects to list");
return -1;
@@ -1805,28 +1805,11 @@
PyObject *value;
} sortwrapperobject;
-static PyTypeObject sortwrapper_type;
-
-static PyObject *
-sortwrapper_richcompare(sortwrapperobject *a, sortwrapperobject *b, int op)
-{
- if (!PyObject_TypeCheck(b, &sortwrapper_type)) {
- PyErr_SetString(PyExc_TypeError,
- "expected a sortwrapperobject");
- return NULL;
- }
- return PyObject_RichCompare(a->key, b->key, op);
-}
-
-static void
-sortwrapper_dealloc(sortwrapperobject *so)
-{
- Py_XDECREF(so->key);
- Py_XDECREF(so->value);
- PyObject_Del(so);
-}
-
PyDoc_STRVAR(sortwrapper_doc, "Object wrapper with a custom sort key.");
+static PyObject *
+sortwrapper_richcompare(sortwrapperobject *, sortwrapperobject *, int);
+static void
+sortwrapper_dealloc(sortwrapperobject *);
static PyTypeObject sortwrapper_type = {
PyObject_HEAD_INIT(&PyType_Type)
@@ -1858,6 +1841,26 @@
(richcmpfunc)sortwrapper_richcompare, /* tp_richcompare */
};
+
+static PyObject *
+sortwrapper_richcompare(sortwrapperobject *a, sortwrapperobject *b, int op)
+{
+ if (!PyObject_TypeCheck(b, &sortwrapper_type)) {
+ PyErr_SetString(PyExc_TypeError,
+ "expected a sortwrapperobject");
+ return NULL;
+ }
+ return PyObject_RichCompare(a->key, b->key, op);
+}
+
+static void
+sortwrapper_dealloc(sortwrapperobject *so)
+{
+ Py_XDECREF(so->key);
+ Py_XDECREF(so->value);
+ PyObject_Del(so);
+}
+
/* Returns a new reference to a sortwrapper.
Consumes the references to the two underlying objects. */
@@ -2271,16 +2274,9 @@
list_traverse(PyListObject *o, visitproc visit, void *arg)
{
Py_ssize_t i;
- PyObject *x;
- for (i = o->ob_size; --i >= 0; ) {
- x = o->ob_item[i];
- if (x != NULL) {
- int err = visit(x, arg);
- if (err)
- return err;
- }
- }
+ for (i = o->ob_size; --i >= 0; )
+ Py_VISIT(o->ob_item[i]);
return 0;
}
@@ -2698,78 +2694,11 @@
PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
} listiterobject;
-PyTypeObject PyListIter_Type;
-
-static PyObject *
-list_iter(PyObject *seq)
-{
- listiterobject *it;
-
- if (!PyList_Check(seq)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- it = PyObject_GC_New(listiterobject, &PyListIter_Type);
- if (it == NULL)
- return NULL;
- it->it_index = 0;
- Py_INCREF(seq);
- it->it_seq = (PyListObject *)seq;
- _PyObject_GC_TRACK(it);
- return (PyObject *)it;
-}
-
-static void
-listiter_dealloc(listiterobject *it)
-{
- _PyObject_GC_UNTRACK(it);
- Py_XDECREF(it->it_seq);
- PyObject_GC_Del(it);
-}
-
-static int
-listiter_traverse(listiterobject *it, visitproc visit, void *arg)
-{
- if (it->it_seq == NULL)
- return 0;
- return visit((PyObject *)it->it_seq, arg);
-}
-
-static PyObject *
-listiter_next(listiterobject *it)
-{
- PyListObject *seq;
- PyObject *item;
-
- assert(it != NULL);
- seq = it->it_seq;
- if (seq == NULL)
- return NULL;
- assert(PyList_Check(seq));
-
- if (it->it_index < PyList_GET_SIZE(seq)) {
- item = PyList_GET_ITEM(seq, it->it_index);
- ++it->it_index;
- Py_INCREF(item);
- return item;
- }
-
- Py_DECREF(seq);
- it->it_seq = NULL;
- return NULL;
-}
-
-static PyObject *
-listiter_len(listiterobject *it)
-{
- Py_ssize_t len;
- if (it->it_seq) {
- len = PyList_GET_SIZE(it->it_seq) - it->it_index;
- if (len >= 0)
- return PyInt_FromSsize_t(len);
- }
- return PyInt_FromLong(0);
-}
+static PyObject *list_iter(PyObject *);
+static void listiter_dealloc(listiterobject *);
+static int listiter_traverse(listiterobject *, visitproc, void *);
+static PyObject *listiter_next(listiterobject *);
+static PyObject *listiter_len(listiterobject *);
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
@@ -2812,6 +2741,76 @@
0, /* tp_members */
};
+
+static PyObject *
+list_iter(PyObject *seq)
+{
+ listiterobject *it;
+
+ if (!PyList_Check(seq)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ it = PyObject_GC_New(listiterobject, &PyListIter_Type);
+ if (it == NULL)
+ return NULL;
+ it->it_index = 0;
+ Py_INCREF(seq);
+ it->it_seq = (PyListObject *)seq;
+ _PyObject_GC_TRACK(it);
+ return (PyObject *)it;
+}
+
+static void
+listiter_dealloc(listiterobject *it)
+{
+ _PyObject_GC_UNTRACK(it);
+ Py_XDECREF(it->it_seq);
+ PyObject_GC_Del(it);
+}
+
+static int
+listiter_traverse(listiterobject *it, visitproc visit, void *arg)
+{
+ Py_VISIT(it->it_seq);
+ return 0;
+}
+
+static PyObject *
+listiter_next(listiterobject *it)
+{
+ PyListObject *seq;
+ PyObject *item;
+
+ assert(it != NULL);
+ seq = it->it_seq;
+ if (seq == NULL)
+ return NULL;
+ assert(PyList_Check(seq));
+
+ if (it->it_index < PyList_GET_SIZE(seq)) {
+ item = PyList_GET_ITEM(seq, it->it_index);
+ ++it->it_index;
+ Py_INCREF(item);
+ return item;
+ }
+
+ Py_DECREF(seq);
+ it->it_seq = NULL;
+ return NULL;
+}
+
+static PyObject *
+listiter_len(listiterobject *it)
+{
+ Py_ssize_t len;
+ if (it->it_seq) {
+ len = PyList_GET_SIZE(it->it_seq) - it->it_index;
+ if (len >= 0)
+ return PyInt_FromSsize_t(len);
+ }
+ return PyInt_FromLong(0);
+}
/*********************** List Reverse Iterator **************************/
typedef struct {
@@ -2820,69 +2819,11 @@
PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
} listreviterobject;
-PyTypeObject PyListRevIter_Type;
-
-static PyObject *
-list_reversed(PyListObject *seq, PyObject *unused)
-{
- listreviterobject *it;
-
- it = PyObject_GC_New(listreviterobject, &PyListRevIter_Type);
- if (it == NULL)
- return NULL;
- assert(PyList_Check(seq));
- it->it_index = PyList_GET_SIZE(seq) - 1;
- Py_INCREF(seq);
- it->it_seq = seq;
- PyObject_GC_Track(it);
- return (PyObject *)it;
-}
-
-static void
-listreviter_dealloc(listreviterobject *it)
-{
- PyObject_GC_UnTrack(it);
- Py_XDECREF(it->it_seq);
- PyObject_GC_Del(it);
-}
-
-static int
-listreviter_traverse(listreviterobject *it, visitproc visit, void *arg)
-{
- if (it->it_seq == NULL)
- return 0;
- return visit((PyObject *)it->it_seq, arg);
-}
-
-static PyObject *
-listreviter_next(listreviterobject *it)
-{
- PyObject *item;
- Py_ssize_t index = it->it_index;
- PyListObject *seq = it->it_seq;
-
- if (index>=0 && index < PyList_GET_SIZE(seq)) {
- item = PyList_GET_ITEM(seq, index);
- it->it_index--;
- Py_INCREF(item);
- return item;
- }
- it->it_index = -1;
- if (seq != NULL) {
- it->it_seq = NULL;
- Py_DECREF(seq);
- }
- return NULL;
-}
-
-static Py_ssize_t
-listreviter_len(listreviterobject *it)
-{
- 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 PyObject *list_reversed(PyListObject *, PyObject *);
+static void listreviter_dealloc(listreviterobject *);
+static int listreviter_traverse(listreviterobject *, visitproc, void *);
+static PyObject *listreviter_next(listreviterobject *);
+static Py_ssize_t listreviter_len(listreviterobject *);
static PySequenceMethods listreviter_as_sequence = {
(lenfunc)listreviter_len, /* sq_length */
@@ -2921,3 +2862,65 @@
(iternextfunc)listreviter_next, /* tp_iternext */
0,
};
+
+static PyObject *
+list_reversed(PyListObject *seq, PyObject *unused)
+{
+ listreviterobject *it;
+
+ it = PyObject_GC_New(listreviterobject, &PyListRevIter_Type);
+ if (it == NULL)
+ return NULL;
+ assert(PyList_Check(seq));
+ it->it_index = PyList_GET_SIZE(seq) - 1;
+ Py_INCREF(seq);
+ it->it_seq = seq;
+ PyObject_GC_Track(it);
+ return (PyObject *)it;
+}
+
+static void
+listreviter_dealloc(listreviterobject *it)
+{
+ PyObject_GC_UnTrack(it);
+ Py_XDECREF(it->it_seq);
+ PyObject_GC_Del(it);
+}
+
+static int
+listreviter_traverse(listreviterobject *it, visitproc visit, void *arg)
+{
+ Py_VISIT(it->it_seq);
+ return 0;
+}
+
+static PyObject *
+listreviter_next(listreviterobject *it)
+{
+ PyObject *item;
+ Py_ssize_t index = it->it_index;
+ PyListObject *seq = it->it_seq;
+
+ if (index>=0 && index < PyList_GET_SIZE(seq)) {
+ item = PyList_GET_ITEM(seq, index);
+ it->it_index--;
+ Py_INCREF(item);
+ return item;
+ }
+ it->it_index = -1;
+ if (seq != NULL) {
+ it->it_seq = NULL;
+ Py_DECREF(seq);
+ }
+ return NULL;
+}
+
+static Py_ssize_t
+listreviter_len(listreviterobject *it)
+{
+ Py_ssize_t len = it->it_index + 1;
+ if (it->it_seq == NULL || PyList_GET_SIZE(it->it_seq) < len)
+ return 0;
+ return len;
+}
+
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 7c5ebc4..3073923 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -281,7 +281,7 @@
if (sign > 0)
return PY_SSIZE_T_MAX;
else
- return -PY_SSIZE_T_MAX-1;
+ return PY_SSIZE_T_MIN;
}
/* Get a Py_ssize_t from a long int object.
@@ -301,7 +301,7 @@
/* Get a Py_ssize_t from a long int object.
Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
- Return 0 on error, 1 on success.
+ On error, return -1 with an exception set.
*/
static Py_ssize_t
@@ -419,7 +419,7 @@
digit msd = v->ob_digit[ndigits - 1];
result = (ndigits - 1) * SHIFT;
- if (result / SHIFT != ndigits - 1)
+ if (result / SHIFT != (size_t)(ndigits - 1))
goto Overflow;
do {
++result;
@@ -771,6 +771,8 @@
PyLong_FromVoidPtr(void *p)
{
#if SIZEOF_VOID_P <= SIZEOF_LONG
+ if ((long)p < 0)
+ return PyLong_FromUnsignedLong((unsigned long)p);
return PyInt_FromLong((long)p);
#else
@@ -783,7 +785,7 @@
/* optimize null pointers */
if (p == NULL)
return PyInt_FromLong(0);
- return PyLong_FromLongLong((PY_LONG_LONG)p);
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)p);
#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */
}
@@ -802,8 +804,10 @@
if (PyInt_Check(vv))
x = PyInt_AS_LONG(vv);
- else
+ else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0)
x = PyLong_AsLong(vv);
+ else
+ x = PyLong_AsUnsignedLong(vv);
#else
#ifndef HAVE_LONG_LONG
@@ -816,8 +820,10 @@
if (PyInt_Check(vv))
x = PyInt_AS_LONG(vv);
- else
+ else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0)
x = PyLong_AsLongLong(vv);
+ else
+ x = PyLong_AsUnsignedLongLong(vv);
#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */
@@ -947,7 +953,7 @@
if (vv == NULL || !PyLong_Check(vv)) {
PyErr_BadInternalCall();
- return -1;
+ return (unsigned PY_LONG_LONG)-1;
}
res = _PyLong_AsByteArray(
@@ -1394,6 +1400,8 @@
int sign = 1;
char *start, *orig_str = str;
PyLongObject *z;
+ PyObject *strobj, *strrepr;
+ Py_ssize_t slen;
if ((base != 0 && base < 2) || base > 36) {
PyErr_SetString(PyExc_ValueError,
@@ -1459,9 +1467,19 @@
return (PyObject *) z;
onError:
- PyErr_Format(PyExc_ValueError,
- "invalid literal for long(): %.200s", orig_str);
Py_XDECREF(z);
+ slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200;
+ strobj = PyString_FromStringAndSize(orig_str, slen);
+ if (strobj == NULL)
+ return NULL;
+ strrepr = PyObject_Repr(strobj);
+ Py_DECREF(strobj);
+ if (strrepr == NULL)
+ return NULL;
+ PyErr_Format(PyExc_ValueError,
+ "invalid literal for long() with base %d: %s",
+ base, PyString_AS_STRING(strrepr));
+ Py_DECREF(strrepr);
return NULL;
}
@@ -1470,7 +1488,7 @@
PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base)
{
PyObject *result;
- char *buffer = PyMem_MALLOC(length+1);
+ char *buffer = (char *)PyMem_MALLOC(length+1);
if (buffer == NULL)
return NULL;
@@ -3066,7 +3084,7 @@
static PyObject *
long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyLongObject *tmp, *new;
+ PyLongObject *tmp, *newobj;
Py_ssize_t i, n;
assert(PyType_IsSubtype(type, &PyLong_Type));
@@ -3077,17 +3095,17 @@
n = tmp->ob_size;
if (n < 0)
n = -n;
- new = (PyLongObject *)type->tp_alloc(type, n);
- if (new == NULL) {
+ newobj = (PyLongObject *)type->tp_alloc(type, n);
+ if (newobj == NULL) {
Py_DECREF(tmp);
return NULL;
}
- assert(PyLong_Check(new));
- new->ob_size = tmp->ob_size;
+ assert(PyLong_Check(newobj));
+ newobj->ob_size = tmp->ob_size;
for (i = 0; i < n; i++)
- new->ob_digit[i] = tmp->ob_digit[i];
+ newobj->ob_digit[i] = tmp->ob_digit[i];
Py_DECREF(tmp);
- return (PyObject *)new;
+ return (PyObject *)newobj;
}
static PyObject *
@@ -3114,25 +3132,25 @@
(binaryfunc) long_add, /*nb_add*/
(binaryfunc) long_sub, /*nb_subtract*/
(binaryfunc) long_mul, /*nb_multiply*/
- (binaryfunc) long_mod, /*nb_remainder*/
- (binaryfunc) long_divmod, /*nb_divmod*/
- (ternaryfunc) long_pow, /*nb_power*/
+ long_mod, /*nb_remainder*/
+ long_divmod, /*nb_divmod*/
+ long_pow, /*nb_power*/
(unaryfunc) long_neg, /*nb_negative*/
(unaryfunc) long_pos, /*tp_positive*/
(unaryfunc) long_abs, /*tp_absolute*/
(inquiry) long_nonzero, /*tp_nonzero*/
(unaryfunc) long_invert, /*nb_invert*/
- (binaryfunc) long_lshift, /*nb_lshift*/
+ long_lshift, /*nb_lshift*/
(binaryfunc) long_rshift, /*nb_rshift*/
- (binaryfunc) long_and, /*nb_and*/
- (binaryfunc) long_xor, /*nb_xor*/
- (binaryfunc) long_or, /*nb_or*/
- (coercion) long_coerce, /*nb_coerce*/
- (unaryfunc) long_int, /*nb_int*/
- (unaryfunc) long_long, /*nb_long*/
- (unaryfunc) long_float, /*nb_float*/
- (unaryfunc) long_oct, /*nb_oct*/
- (unaryfunc) long_hex, /*nb_hex*/
+ long_and, /*nb_and*/
+ long_xor, /*nb_xor*/
+ long_or, /*nb_or*/
+ long_coerce, /*nb_coerce*/
+ long_int, /*nb_int*/
+ long_long, /*nb_long*/
+ long_float, /*nb_float*/
+ long_oct, /*nb_oct*/
+ long_hex, /*nb_hex*/
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
0, /* nb_inplace_multiply */
@@ -3143,11 +3161,11 @@
0, /* nb_inplace_and */
0, /* nb_inplace_xor */
0, /* nb_inplace_or */
- (binaryfunc)long_div, /* nb_floor_divide */
+ long_div, /* nb_floor_divide */
long_true_divide, /* nb_true_divide */
0, /* nb_inplace_floor_divide */
0, /* nb_inplace_true_divide */
- (lenfunc)long_index, /* nb_index */
+ long_index, /* nb_index */
};
PyTypeObject PyLong_Type = {
@@ -3156,18 +3174,18 @@
"long", /* tp_name */
sizeof(PyLongObject) - sizeof(digit), /* tp_basicsize */
sizeof(digit), /* tp_itemsize */
- (destructor)long_dealloc, /* tp_dealloc */
+ long_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
(cmpfunc)long_compare, /* tp_compare */
- (reprfunc)long_repr, /* tp_repr */
+ long_repr, /* tp_repr */
&long_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)long_hash, /* tp_hash */
0, /* tp_call */
- (reprfunc)long_str, /* tp_str */
+ long_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 8e3bf86..ecc9a0a 100644
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -149,17 +149,8 @@
static int
meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
{
- int err;
- if (m->m_self != NULL) {
- err = visit(m->m_self, arg);
- if (err)
- return err;
- }
- if (m->m_module != NULL) {
- err = visit(m->m_module, arg);
- if (err)
- return err;
- }
+ Py_VISIT(m->m_self);
+ Py_VISIT(m->m_module);
return 0;
}
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index 8124968..e454fcf 100644
--- a/Objects/moduleobject.c
+++ b/Objects/moduleobject.c
@@ -204,8 +204,7 @@
static int
module_traverse(PyModuleObject *m, visitproc visit, void *arg)
{
- if (m->md_dict != NULL)
- return visit(m->md_dict, arg);
+ Py_VISIT(m->md_dict);
return 0;
}
diff --git a/Objects/object.c b/Objects/object.c
index 9b6a30a..a75c14e 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -3,9 +3,30 @@
#include "Python.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#ifdef Py_REF_DEBUG
Py_ssize_t _Py_RefTotal;
-#endif
+
+Py_ssize_t
+_Py_GetRefTotal(void)
+{
+ PyObject *o;
+ Py_ssize_t total = _Py_RefTotal;
+ /* ignore the references to the dummy object of the dicts and sets
+ because they are not reliable and not useful (now that the
+ hash table code is well-tested) */
+ o = _PyDict_Dummy();
+ if (o != NULL)
+ total -= o->ob_refcnt;
+ o = _PySet_Dummy();
+ if (o != NULL)
+ total -= o->ob_refcnt;
+ return total;
+}
+#endif /* Py_REF_DEBUG */
int Py_DivisionWarningFlag;
@@ -53,23 +74,30 @@
#ifdef COUNT_ALLOCS
static PyTypeObject *type_list;
+/* All types are added to type_list, at least when
+ they get one object created. That makes them
+ immortal, which unfortunately contributes to
+ garbage itself. If unlist_types_without_objects
+ is set, they will be removed from the type_list
+ once the last object is deallocated. */
+int unlist_types_without_objects;
extern int tuple_zero_allocs, fast_tuple_allocs;
extern int quick_int_allocs, quick_neg_int_allocs;
extern int null_strings, one_strings;
void
-dump_counts(void)
+dump_counts(FILE* f)
{
PyTypeObject *tp;
for (tp = type_list; tp; tp = tp->tp_next)
- fprintf(stderr, "%s alloc'd: %d, freed: %d, max in use: %d\n",
+ fprintf(f, "%s alloc'd: %d, freed: %d, max in use: %d\n",
tp->tp_name, tp->tp_allocs, tp->tp_frees,
tp->tp_maxalloc);
- fprintf(stderr, "fast tuple allocs: %d, empty: %d\n",
+ fprintf(f, "fast tuple allocs: %d, empty: %d\n",
fast_tuple_allocs, tuple_zero_allocs);
- fprintf(stderr, "fast int allocs: pos: %d, neg: %d\n",
+ fprintf(f, "fast int allocs: pos: %d, neg: %d\n",
quick_int_allocs, quick_neg_int_allocs);
- fprintf(stderr, "null strings: %d, 1-strings: %d\n",
+ fprintf(f, "null strings: %d, 1-strings: %d\n",
null_strings, one_strings);
}
@@ -103,10 +131,12 @@
void
inc_count(PyTypeObject *tp)
{
- if (tp->tp_allocs == 0) {
+ if (tp->tp_next == NULL && tp->tp_prev == NULL) {
/* first time; insert in linked list */
if (tp->tp_next != NULL) /* sanity check */
Py_FatalError("XXX inc_count sanity check");
+ if (type_list)
+ type_list->tp_prev = tp;
tp->tp_next = type_list;
/* Note that as of Python 2.2, heap-allocated type objects
* can go away, but this code requires that they stay alive
@@ -129,6 +159,24 @@
if (tp->tp_allocs - tp->tp_frees > tp->tp_maxalloc)
tp->tp_maxalloc = tp->tp_allocs - tp->tp_frees;
}
+
+void dec_count(PyTypeObject *tp)
+{
+ tp->tp_frees++;
+ if (unlist_types_without_objects &&
+ tp->tp_allocs == tp->tp_frees) {
+ /* unlink the type from type_list */
+ if (tp->tp_prev)
+ tp->tp_prev->tp_next = tp->tp_next;
+ else
+ type_list = tp->tp_next;
+ if (tp->tp_next)
+ tp->tp_next->tp_prev = tp->tp_prev;
+ tp->tp_next = tp->tp_prev = NULL;
+ Py_DECREF(tp);
+ }
+}
+
#endif
#ifdef Py_REF_DEBUG
@@ -138,11 +186,10 @@
{
char buf[300];
- /* XXX(twouters) cast refcount to long until %zd is universally
- available */
PyOS_snprintf(buf, sizeof(buf),
- "%s:%i object at %p has negative ref count %ld",
- fname, lineno, op, (long)op->ob_refcnt);
+ "%s:%i object at %p has negative ref count "
+ "%" PY_FORMAT_SIZE_T "d",
+ fname, lineno, op, op->ob_refcnt);
Py_FatalError(buf);
}
@@ -317,7 +364,7 @@
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(res)) {
PyObject* str;
- str = PyUnicode_AsUnicodeEscapeString(res);
+ str = PyUnicode_AsEncodedString(res, NULL, NULL);
Py_DECREF(res);
if (str)
res = str;
@@ -1775,12 +1822,12 @@
"NoneType",
0,
0,
- (destructor)none_dealloc, /*tp_dealloc*/ /*never called*/
+ none_dealloc, /*tp_dealloc*/ /*never called*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
- (reprfunc)none_repr, /*tp_repr*/
+ none_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
@@ -1806,12 +1853,12 @@
"NotImplementedType",
0,
0,
- (destructor)none_dealloc, /*tp_dealloc*/ /*never called*/
+ none_dealloc, /*tp_dealloc*/ /*never called*/
0, /*tp_print*/
0, /*tp_getattr*/
0, /*tp_setattr*/
0, /*tp_compare*/
- (reprfunc)NotImplemented_repr, /*tp_repr*/
+ NotImplemented_repr, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
@@ -1901,9 +1948,7 @@
PyObject *op;
fprintf(fp, "Remaining objects:\n");
for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
- /* XXX(twouters) cast refcount to long until %zd is
- universally available */
- fprintf(fp, "%p [%ld] ", op, (long)op->ob_refcnt);
+ fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] ", op, op->ob_refcnt);
if (PyObject_Print(op, fp, 0) != 0)
PyErr_Clear();
putc('\n', fp);
@@ -1919,10 +1964,8 @@
PyObject *op;
fprintf(fp, "Remaining object addresses:\n");
for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
- /* XXX(twouters) cast refcount to long until %zd is
- universally available */
- fprintf(fp, "%p [%ld] %s\n", op, (long)op->ob_refcnt,
- op->ob_type->tp_name);
+ fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op,
+ op->ob_refcnt, op->ob_type->tp_name);
}
PyObject *
@@ -2100,3 +2143,8 @@
--_PyTrash_delete_nesting;
}
}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c
index 870f93c..a393cbc 100644
--- a/Objects/obmalloc.c
+++ b/Objects/obmalloc.c
@@ -529,7 +529,7 @@
nbytes = numarenas * sizeof(*arenas);
if (nbytes / sizeof(*arenas) != numarenas)
return NULL; /* overflow */
- arenaobj = realloc(arenas, nbytes);
+ arenaobj = (struct arena_object *)realloc(arenas, nbytes);
if (arenaobj == NULL)
return NULL;
arenas = arenaobj;
diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
index a9c0b55..c48bee0 100644
--- a/Objects/rangeobject.c
+++ b/Objects/rangeobject.c
@@ -104,13 +104,6 @@
static Py_ssize_t
range_length(rangeobject *r)
{
-#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 (Py_ssize_t)(r->len);
}
@@ -157,44 +150,44 @@
PyTypeObject PyRange_Type = {
PyObject_HEAD_INIT(&PyType_Type)
- 0, /* Number of items for varobject */
- "xrange", /* Name of this type */
- sizeof(rangeobject), /* Basic object size */
- 0, /* Item size for varobject */
- (destructor)PyObject_Del, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_compare */
- (reprfunc)range_repr, /* tp_repr */
- 0, /* tp_as_number */
- &range_as_sequence, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- 0, /* tp_call */
- 0, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT, /* tp_flags */
- range_doc, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- (getiterfunc)range_iter, /* tp_iter */
- 0, /* tp_iternext */
- range_methods, /* tp_methods */
- 0, /* tp_members */
- 0, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- 0, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- 0, /* tp_init */
- 0, /* tp_alloc */
- range_new, /* tp_new */
+ 0, /* Number of items for varobject */
+ "xrange", /* Name of this type */
+ sizeof(rangeobject), /* Basic object size */
+ 0, /* Item size for varobject */
+ (destructor)PyObject_Del, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)range_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ &range_as_sequence, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ range_doc, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ range_iter, /* tp_iter */
+ 0, /* tp_iternext */
+ range_methods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ range_new, /* tp_new */
};
/*********************** Xrange Iterator **************************/
@@ -207,53 +200,6 @@
long len;
} rangeiterobject;
-static PyTypeObject Pyrangeiter_Type;
-
-static PyObject *
-range_iter(PyObject *seq)
-{
- rangeiterobject *it;
-
- if (!PyRange_Check(seq)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
- if (it == NULL)
- return NULL;
- it->index = 0;
- it->start = ((rangeobject *)seq)->start;
- it->step = ((rangeobject *)seq)->step;
- it->len = ((rangeobject *)seq)->len;
- return (PyObject *)it;
-}
-
-static PyObject *
-range_reverse(PyObject *seq)
-{
- rangeiterobject *it;
- long start, step, len;
-
- if (!PyRange_Check(seq)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
- if (it == NULL)
- return NULL;
-
- start = ((rangeobject *)seq)->start;
- step = ((rangeobject *)seq)->step;
- len = ((rangeobject *)seq)->len;
-
- it->index = 0;
- it->start = start + (len-1) * step;
- it->step = -step;
- it->len = len;
-
- return (PyObject *)it;
-}
-
static PyObject *
rangeiter_next(rangeiterobject *r)
{
@@ -308,3 +254,48 @@
rangeiter_methods, /* tp_methods */
0,
};
+
+static PyObject *
+range_iter(PyObject *seq)
+{
+ rangeiterobject *it;
+
+ if (!PyRange_Check(seq)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
+ if (it == NULL)
+ return NULL;
+ it->index = 0;
+ it->start = ((rangeobject *)seq)->start;
+ it->step = ((rangeobject *)seq)->step;
+ it->len = ((rangeobject *)seq)->len;
+ return (PyObject *)it;
+}
+
+static PyObject *
+range_reverse(PyObject *seq)
+{
+ rangeiterobject *it;
+ long start, step, len;
+
+ if (!PyRange_Check(seq)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ it = PyObject_New(rangeiterobject, &Pyrangeiter_Type);
+ if (it == NULL)
+ return NULL;
+
+ start = ((rangeobject *)seq)->start;
+ step = ((rangeobject *)seq)->step;
+ len = ((rangeobject *)seq)->len;
+
+ it->index = 0;
+ it->start = start + (len-1) * step;
+ it->step = -step;
+ it->len = len;
+
+ return (PyObject *)it;
+}
diff --git a/Objects/setobject.c b/Objects/setobject.c
index 89d574f..26a232b 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -3,7 +3,7 @@
Written and maintained by Raymond D. Hettinger <python@rcn.com>
Derived from Lib/sets.py and Objects/dictobject.c.
- Copyright (c) 2003-5 Python Software Foundation.
+ Copyright (c) 2003-6 Python Software Foundation.
All rights reserved.
*/
@@ -16,6 +16,14 @@
/* Object used as dummy key to fill deleted entries */
static PyObject *dummy = NULL; /* Initialized by first call to make_new_set() */
+#ifdef Py_REF_DEBUG
+PyObject *
+_PySet_Dummy(void)
+{
+ return dummy;
+}
+#endif
+
#define INIT_NONZERO_SET_SLOTS(so) do { \
(so)->table = (so)->smalltable; \
(so)->mask = PySet_MINSIZE - 1; \
@@ -445,7 +453,7 @@
}
#ifdef Py_DEBUG
else
- assert(entry->key == NULL || entry->key == dummy);
+ assert(entry->key == NULL);
#endif
}
@@ -719,8 +727,6 @@
/***** Set iterator type ***********************************************/
-static PyTypeObject PySetIter_Type; /* Forward */
-
typedef struct {
PyObject_HEAD
PySetObject *si_set; /* Set to NULL when iterator is exhausted */
@@ -729,20 +735,6 @@
long len;
} setiterobject;
-static PyObject *
-set_iter(PySetObject *so)
-{
- setiterobject *si = PyObject_New(setiterobject, &PySetIter_Type);
- if (si == NULL)
- return NULL;
- Py_INCREF(so);
- si->si_set = so;
- si->si_used = so->used;
- si->si_pos = 0;
- si->len = so->used;
- return (PyObject *)si;
-}
-
static void
setiter_dealloc(setiterobject *si)
{
@@ -838,6 +830,20 @@
0,
};
+static PyObject *
+set_iter(PySetObject *so)
+{
+ setiterobject *si = PyObject_New(setiterobject, &PySetIter_Type);
+ if (si == NULL)
+ return NULL;
+ Py_INCREF(so);
+ si->si_set = so;
+ si->si_used = so->used;
+ si->si_pos = 0;
+ si->len = so->used;
+ return (PyObject *)si;
+}
+
static int
set_update_internal(PySetObject *so, PyObject *other)
{
@@ -972,8 +978,8 @@
so = free_sets[num_free_sets];
PyObject_GC_Del(so);
}
- Py_XDECREF(dummy);
- Py_XDECREF(emptyfrozenset);
+ Py_CLEAR(dummy);
+ Py_CLEAR(emptyfrozenset);
}
static PyObject *
@@ -1531,7 +1537,7 @@
}
static int
-set_nocmp(PyObject *self)
+set_nocmp(PyObject *self, PyObject *other)
{
PyErr_SetString(PyExc_TypeError, "cannot compare sets using cmp()");
return -1;
@@ -1688,7 +1694,7 @@
}
static PySequenceMethods set_as_sequence = {
- (lenfunc)set_len, /* sq_length */
+ set_len, /* sq_length */
0, /* sq_concat */
0, /* sq_repeat */
0, /* sq_item */
@@ -1802,7 +1808,7 @@
(printfunc)set_tp_print, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
- (cmpfunc)set_nocmp, /* tp_compare */
+ set_nocmp, /* tp_compare */
(reprfunc)set_repr, /* tp_repr */
&set_as_number, /* tp_as_number */
&set_as_sequence, /* tp_as_sequence */
@@ -1896,7 +1902,7 @@
(printfunc)set_tp_print, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
- (cmpfunc)set_nocmp, /* tp_compare */
+ set_nocmp, /* tp_compare */
(reprfunc)set_repr, /* tp_repr */
&frozenset_as_number, /* tp_as_number */
&set_as_sequence, /* tp_as_sequence */
@@ -1966,6 +1972,16 @@
}
int
+PySet_Clear(PyObject *set)
+{
+ if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ return set_clear_internal((PySetObject *)set);
+}
+
+int
PySet_Contains(PyObject *anyset, PyObject *key)
{
if (!PyAnySet_Check(anyset)) {
@@ -1995,6 +2011,21 @@
return set_add_key((PySetObject *)set, key);
}
+int
+_PySet_Next(PyObject *set, Py_ssize_t *pos, PyObject **entry)
+{
+ setentry *entry_ptr;
+
+ if (!PyAnySet_Check(set)) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ if (set_next((PySetObject *)set, pos, &entry_ptr) == 0)
+ return 0;
+ *entry = entry_ptr->key;
+ return 1;
+}
+
PyObject *
PySet_Pop(PyObject *set)
{
@@ -2005,6 +2036,15 @@
return set_pop((PySetObject *)set);
}
+int
+_PySet_Update(PyObject *set, PyObject *iterable)
+{
+ if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ return set_update_internal((PySetObject *)set, iterable);
+}
#ifdef Py_DEBUG
@@ -2021,7 +2061,11 @@
static PyObject *
test_c_api(PySetObject *so)
{
- PyObject *elem, *dup, *t, *f, *ob = (PyObject *)so;
+ int count;
+ char *s;
+ Py_ssize_t i;
+ PyObject *elem, *dup, *t, *f, *dup2;
+ PyObject *ob = (PyObject *)so;
/* Verify preconditions and exercise type/size checks */
assert(PyAnySet_Check(ob));
@@ -2052,6 +2096,35 @@
assert(PySet_Discard(ob, elem) == 0);
assert(PySet_GET_SIZE(ob) == 2);
+ /* Exercise clear */
+ dup2 = PySet_New(dup);
+ assert(PySet_Clear(dup2) == 0);
+ assert(PySet_Size(dup2) == 0);
+ Py_DECREF(dup2);
+
+ /* Raise SystemError on clear or update of frozen set */
+ f = PyFrozenSet_New(dup);
+ assertRaises(PySet_Clear(f) == -1, PyExc_SystemError);
+ assertRaises(_PySet_Update(f, dup) == -1, PyExc_SystemError);
+ Py_DECREF(f);
+
+ /* Exercise direct iteration */
+ i = 0, count = 0;
+ while (_PySet_Next((PyObject *)dup, &i, &elem)) {
+ s = PyString_AsString(elem);
+ assert(s && (s[0] == 'a' || s[0] == 'b' || s[0] == 'c'));
+ count++;
+ }
+ assert(count == 3);
+
+ /* Exercise updates */
+ dup2 = PySet_New(NULL);
+ assert(_PySet_Update(dup2, dup) == 0);
+ assert(PySet_Size(dup2) == 3);
+ assert(_PySet_Update(dup2, dup) == 0);
+ assert(PySet_Size(dup2) == 3);
+ Py_DECREF(dup2);
+
/* Raise SystemError when self argument is not a set or frozenset. */
t = PyTuple_New(0);
assertRaises(PySet_Size(t) == -1, PyExc_SystemError);
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index 3b37dbb..271a9ad 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -24,26 +24,26 @@
static PyTypeObject PyEllipsis_Type = {
PyObject_HEAD_INIT(&PyType_Type)
- 0, /* ob_size */
- "ellipsis", /* tp_name */
- 0, /* tp_basicsize */
- 0, /* tp_itemsize */
- 0, /*never called*/ /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_compare */
- (reprfunc)ellipsis_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- 0, /* tp_call */
- 0, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT, /* tp_flags */
+ 0, /* ob_size */
+ "ellipsis", /* tp_name */
+ 0, /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /*never called*/ /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ ellipsis_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
};
PyObject _Py_EllipsisObject = {
@@ -79,6 +79,25 @@
return (PyObject *) obj;
}
+PyObject *
+_PySlice_FromIndices(Py_ssize_t istart, Py_ssize_t istop)
+{
+ PyObject *start, *end, *slice;
+ start = PyInt_FromSsize_t(istart);
+ if (!start)
+ return NULL;
+ end = PyInt_FromSsize_t(istop);
+ if (!end) {
+ Py_DECREF(start);
+ return NULL;
+ }
+
+ slice = PySlice_New(start, end, NULL);
+ Py_DECREF(start);
+ Py_DECREF(end);
+ return slice;
+}
+
int
PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
@@ -87,21 +106,21 @@
if (r->step == Py_None) {
*step = 1;
} else {
- if (!PyInt_Check(r->step)) return -1;
- *step = PyInt_AsLong(r->step);
+ if (!PyInt_Check(r->step) && !PyLong_Check(r->step)) return -1;
+ *step = PyInt_AsSsize_t(r->step);
}
if (r->start == Py_None) {
*start = *step < 0 ? length-1 : 0;
} else {
- if (!PyInt_Check(r->start)) return -1;
- *start = PyInt_AsLong(r->start);
+ if (!PyInt_Check(r->start) && !PyLong_Check(r->step)) return -1;
+ *start = PyInt_AsSsize_t(r->start);
if (*start < 0) *start += length;
}
if (r->stop == Py_None) {
*stop = *step < 0 ? -1 : length;
} else {
- if (!PyInt_Check(r->stop)) return -1;
- *stop = PyInt_AsLong(r->stop);
+ if (!PyInt_Check(r->stop) && !PyLong_Check(r->step)) return -1;
+ *stop = PyInt_AsSsize_t(r->stop);
if (*stop < 0) *stop += length;
}
if (*stop > length) return -1;
@@ -233,7 +252,7 @@
{
Py_ssize_t ilen, start, stop, step, slicelength;
- ilen = PyInt_AsLong(len);
+ ilen = PyInt_AsSsize_t(len);
if (ilen == -1 && PyErr_Occurred()) {
return NULL;
@@ -244,7 +263,7 @@
return NULL;
}
- return Py_BuildValue("(iii)", start, stop, step);
+ return Py_BuildValue("(nnn)", start, stop, step);
}
PyDoc_STRVAR(slice_indices_doc,
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index 32aacf5..32e825e 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -1,5 +1,6 @@
/* String object implementation */
+#define PY_SSIZE_T_CLEAN
#include "Python.h"
#include <ctype.h>
@@ -16,7 +17,7 @@
When the interned string reaches a refcnt of 0 the string deallocation
function will delete the reference from this dictionary.
- Another way to look at this is that to say that the actual reference
+ Another way to look at this is that to say that the actual reference
count of a string is: s->ob_refcnt + (s->ob_sstate?2:0)
*/
static PyObject *interned;
@@ -105,7 +106,7 @@
assert(str != NULL);
size = strlen(str);
- if (size > INT_MAX) {
+ if (size > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"string is too long for a Python string");
return NULL;
@@ -183,7 +184,7 @@
++f;
/* likewise for %zd */
if (*f == 'z' && *(f+1) == 'd')
- ++f;
+ ++f;
switch (*f) {
case 'c':
@@ -273,18 +274,9 @@
case 'd':
if (longflag)
sprintf(s, "%ld", va_arg(vargs, long));
- else if (size_tflag) {
- /* Instead of checking whether the C
- library supports %zd, handle the
- common cases. */
- #if SIZEOF_SIZE_T == SIZEOF_LONG
- sprintf(s, "%ld", va_arg(vargs, long));
- #elif defined(MS_WINDOWS)
- sprintf(s, "%Id", va_arg(vargs, size_t));
- #else
- #error Cannot print size_t values
- #endif
- }
+ else if (size_tflag)
+ sprintf(s, "%" PY_FORMAT_SIZE_T "u",
+ va_arg(vargs, size_t));
else
sprintf(s, "%d", va_arg(vargs, int));
s += strlen(s);
@@ -578,8 +570,9 @@
if (!w) goto failed;
/* Append bytes to output buffer. */
- r = PyString_AsString(w);
- rn = PyString_Size(w);
+ assert(PyString_Check(w));
+ r = PyString_AS_STRING(w);
+ rn = PyString_GET_SIZE(w);
memcpy(p, r, rn);
p += rn;
Py_DECREF(w);
@@ -622,7 +615,7 @@
*p++ = c;
break;
case 'x':
- if (isxdigit(Py_CHARMASK(s[0]))
+ if (isxdigit(Py_CHARMASK(s[0]))
&& isxdigit(Py_CHARMASK(s[1]))) {
unsigned int x = 0;
c = Py_CHARMASK(*s);
@@ -646,7 +639,7 @@
break;
}
if (!errors || strcmp(errors, "strict") == 0) {
- PyErr_SetString(PyExc_ValueError,
+ PyErr_SetString(PyExc_ValueError,
"invalid \\x escape");
goto failed;
}
@@ -753,7 +746,7 @@
*s = PyString_AS_STRING(obj);
if (len != NULL)
*len = PyString_GET_SIZE(obj);
- else if (strlen(*s) != PyString_GET_SIZE(obj)) {
+ else if (strlen(*s) != (size_t)PyString_GET_SIZE(obj)) {
PyErr_SetString(PyExc_TypeError,
"expected string without null bytes");
return -1;
@@ -822,7 +815,7 @@
register PyStringObject* op = (PyStringObject*) obj;
size_t newsize = 2 + 4 * op->ob_size;
PyObject *v;
- if (newsize > INT_MAX) {
+ if (newsize > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"string is too large to make repr");
}
@@ -838,7 +831,7 @@
/* figure out which quote to use; single is preferred */
quote = '\'';
- if (smartquotes &&
+ if (smartquotes &&
memchr(op->ob_sval, '\'', op->ob_size) &&
!memchr(op->ob_sval, '"', op->ob_size))
quote = '"';
@@ -1003,7 +996,7 @@
/* String slice a[i:j] consists of characters a[i] ... a[j-1] */
static PyObject *
-string_slice(register PyStringObject *a, register Py_ssize_t i,
+string_slice(register PyStringObject *a, register Py_ssize_t i,
register Py_ssize_t j)
/* j -- may be negative! */
{
@@ -1047,7 +1040,7 @@
if (len_sub == 0)
return 1;
- /* last points to one char beyond the start of the rightmost
+ /* last points to one char beyond the start of the rightmost
substring. When s<last, there is still room for a possible match
and s[0] through s[len_sub-1] will be in bounds.
shortsub is len_sub minus the last character which is checked
@@ -1059,7 +1052,7 @@
lastchar = sub[shortsub];
last = s + PyString_GET_SIZE(a) - len_sub + 1;
while (s < last) {
- s = memchr(s, firstchar, last-s);
+ s = (char *)memchr(s, firstchar, last-s);
if (s == NULL)
return 0;
assert(s < last);
@@ -1207,7 +1200,7 @@
char* result_buf;
PyObject* result;
- if (PySlice_GetIndicesEx((PySliceObject*)item,
+ if (PySlice_GetIndicesEx((PySliceObject*)item,
PyString_GET_SIZE(self),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
@@ -1218,23 +1211,23 @@
}
else {
source_buf = PyString_AsString((PyObject*)self);
- result_buf = PyMem_Malloc(slicelength);
+ result_buf = (char *)PyMem_Malloc(slicelength);
if (result_buf == NULL)
return PyErr_NoMemory();
- for (cur = start, i = 0; i < slicelength;
+ for (cur = start, i = 0; i < slicelength;
cur += step, i++) {
result_buf[i] = source_buf[cur];
}
-
- result = PyString_FromStringAndSize(result_buf,
+
+ result = PyString_FromStringAndSize(result_buf,
slicelength);
PyMem_Free(result_buf);
return result;
}
- }
+ }
else {
- PyErr_SetString(PyExc_TypeError,
+ PyErr_SetString(PyExc_TypeError,
"string indices must be integers");
return NULL;
}
@@ -1340,7 +1333,7 @@
Py_DECREF(str);
static PyObject *
-split_whitespace(const char *s, Py_ssize_t len, int maxsplit)
+split_whitespace(const char *s, Py_ssize_t len, Py_ssize_t maxsplit)
{
Py_ssize_t i, j;
PyObject *str;
@@ -1374,7 +1367,7 @@
}
static PyObject *
-split_char(const char *s, Py_ssize_t len, char ch, int maxcount)
+split_char(const char *s, Py_ssize_t len, char ch, Py_ssize_t maxcount)
{
register Py_ssize_t i, j;
PyObject *str;
@@ -1415,14 +1408,14 @@
{
Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
int err;
- int maxsplit = -1;
+ Py_ssize_t maxsplit = -1;
const char *s = PyString_AS_STRING(self), *sub;
PyObject *list, *item, *subobj = Py_None;
- if (!PyArg_ParseTuple(args, "|Oi:split", &subobj, &maxsplit))
+ if (!PyArg_ParseTuple(args, "|On:split", &subobj, &maxsplit))
return NULL;
if (maxsplit < 0)
- maxsplit = INT_MAX;
+ maxsplit = PY_SSIZE_T_MAX;
if (subobj == Py_None)
return split_whitespace(s, len, maxsplit);
if (PyString_Check(subobj)) {
@@ -1480,7 +1473,7 @@
}
static PyObject *
-rsplit_whitespace(const char *s, Py_ssize_t len, int maxsplit)
+rsplit_whitespace(const char *s, Py_ssize_t len, Py_ssize_t maxsplit)
{
Py_ssize_t i, j;
PyObject *str;
@@ -1514,7 +1507,7 @@
}
static PyObject *
-rsplit_char(const char *s, Py_ssize_t len, char ch, int maxcount)
+rsplit_char(const char *s, Py_ssize_t len, char ch, Py_ssize_t maxcount)
{
register Py_ssize_t i, j;
PyObject *str;
@@ -1556,14 +1549,14 @@
{
Py_ssize_t len = PyString_GET_SIZE(self), n, i, j;
int err;
- int maxsplit = -1;
+ Py_ssize_t maxsplit = -1;
const char *s = PyString_AS_STRING(self), *sub;
PyObject *list, *item, *subobj = Py_None;
- if (!PyArg_ParseTuple(args, "|Oi:rsplit", &subobj, &maxsplit))
+ if (!PyArg_ParseTuple(args, "|On:rsplit", &subobj, &maxsplit))
return NULL;
if (maxsplit < 0)
- maxsplit = INT_MAX;
+ maxsplit = PY_SSIZE_T_MAX;
if (subobj == Py_None)
return rsplit_whitespace(s, len, maxsplit);
if (PyString_Check(subobj)) {
@@ -1661,7 +1654,7 @@
}
/* There are at least two things to join, or else we have a subclass
- * of the builtin types in the sequence.
+ * of the builtin types in the sequence.
* Do a pre-pass to figure out the total amount of space we'll
* need (sz), see whether any argument is absurd, and defer to
* the Unicode join if appropriate.
@@ -1684,16 +1677,16 @@
}
#endif
PyErr_Format(PyExc_TypeError,
- "sequence item %i: expected string,"
+ "sequence item %zd: expected string,"
" %.80s found",
- /*XXX*/(int)i, item->ob_type->tp_name);
+ i, item->ob_type->tp_name);
Py_DECREF(seq);
return NULL;
}
sz += PyString_GET_SIZE(item);
if (i != 0)
sz += seplen;
- if (sz < old_sz || sz > INT_MAX) {
+ if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"join() is too long for a Python string");
Py_DECREF(seq);
@@ -1754,7 +1747,7 @@
{
const char *s = PyString_AS_STRING(self), *sub;
Py_ssize_t len = PyString_GET_SIZE(self);
- Py_ssize_t n, i = 0, last = INT_MAX;
+ Py_ssize_t n, i = 0, last = PY_SSIZE_T_MAX;
PyObject *subobj;
/* XXX ssize_t i */
@@ -1960,17 +1953,14 @@
return res;
}
#endif
- else {
- PyErr_Format(PyExc_TypeError,
+ PyErr_Format(PyExc_TypeError,
#ifdef Py_USING_UNICODE
- "%s arg must be None, str or unicode",
+ "%s arg must be None, str or unicode",
#else
- "%s arg must be None or str",
+ "%s arg must be None or str",
#endif
- STRIPNAME(striptype));
- return NULL;
- }
- return do_xstrip(self, striptype, sep);
+ STRIPNAME(striptype));
+ return NULL;
}
return do_strip(self, striptype);
@@ -2039,12 +2029,12 @@
{
char *s = PyString_AS_STRING(self), *s_new;
Py_ssize_t i, n = PyString_GET_SIZE(self);
- PyObject *new;
+ PyObject *newobj;
- new = PyString_FromStringAndSize(NULL, n);
- if (new == NULL)
+ newobj = PyString_FromStringAndSize(NULL, n);
+ if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(new);
+ s_new = PyString_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (isupper(c)) {
@@ -2053,7 +2043,7 @@
*s_new = c;
s_new++;
}
- return new;
+ return newobj;
}
@@ -2067,12 +2057,12 @@
{
char *s = PyString_AS_STRING(self), *s_new;
Py_ssize_t i, n = PyString_GET_SIZE(self);
- PyObject *new;
+ PyObject *newobj;
- new = PyString_FromStringAndSize(NULL, n);
- if (new == NULL)
+ newobj = PyString_FromStringAndSize(NULL, n);
+ if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(new);
+ s_new = PyString_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2081,7 +2071,7 @@
*s_new = c;
s_new++;
}
- return new;
+ return newobj;
}
@@ -2097,12 +2087,12 @@
char *s = PyString_AS_STRING(self), *s_new;
Py_ssize_t i, n = PyString_GET_SIZE(self);
int previous_is_cased = 0;
- PyObject *new;
+ PyObject *newobj;
- new = PyString_FromStringAndSize(NULL, n);
- if (new == NULL)
+ newobj = PyString_FromStringAndSize(NULL, n);
+ if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(new);
+ s_new = PyString_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2117,7 +2107,7 @@
previous_is_cased = 0;
*s_new++ = c;
}
- return new;
+ return newobj;
}
PyDoc_STRVAR(capitalize__doc__,
@@ -2131,12 +2121,12 @@
{
char *s = PyString_AS_STRING(self), *s_new;
Py_ssize_t i, n = PyString_GET_SIZE(self);
- PyObject *new;
+ PyObject *newobj;
- new = PyString_FromStringAndSize(NULL, n);
- if (new == NULL)
+ newobj = PyString_FromStringAndSize(NULL, n);
+ if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(new);
+ s_new = PyString_AsString(newobj);
if (0 < n) {
int c = Py_CHARMASK(*s++);
if (islower(c))
@@ -2153,7 +2143,7 @@
*s_new = c;
s_new++;
}
- return new;
+ return newobj;
}
@@ -2169,7 +2159,7 @@
{
const char *s = PyString_AS_STRING(self), *sub, *t;
Py_ssize_t len = PyString_GET_SIZE(self), n;
- Py_ssize_t i = 0, last = INT_MAX;
+ Py_ssize_t i = 0, last = PY_SSIZE_T_MAX;
Py_ssize_t m, r;
PyObject *subobj;
@@ -2210,7 +2200,7 @@
}
if (i >= m)
break;
- t = memchr(s+i, sub[0], m-i);
+ t = (const char *)memchr(s+i, sub[0], m-i);
if (t == NULL)
break;
i = t - s;
@@ -2229,12 +2219,12 @@
{
char *s = PyString_AS_STRING(self), *s_new;
Py_ssize_t i, n = PyString_GET_SIZE(self);
- PyObject *new;
+ PyObject *newobj;
- new = PyString_FromStringAndSize(NULL, n);
- if (new == NULL)
+ newobj = PyString_FromStringAndSize(NULL, n);
+ if (newobj == NULL)
return NULL;
- s_new = PyString_AsString(new);
+ s_new = PyString_AsString(newobj);
for (i = 0; i < n; i++) {
int c = Py_CHARMASK(*s++);
if (islower(c)) {
@@ -2247,7 +2237,7 @@
*s_new = c;
s_new++;
}
- return new;
+ return newobj;
}
@@ -2323,12 +2313,12 @@
}
table = table1;
- inlen = PyString_Size(input_obj);
+ inlen = PyString_GET_SIZE(input_obj);
result = PyString_FromStringAndSize((char *)NULL, inlen);
if (result == NULL)
return NULL;
output_start = output = PyString_AsString(result);
- input = PyString_AsString(input_obj);
+ input = PyString_AS_STRING(input_obj);
if (dellen == 0) {
/* If no deletions are required, use faster code */
@@ -2457,7 +2447,7 @@
/* find length of output string */
nfound = (pat_len > 0) ? mymemcnt(str, len, pat, pat_len) : len + 1;
if (count < 0)
- count = INT_MAX;
+ count = PY_SSIZE_T_MAX;
else if (nfound > count)
nfound = count;
if (nfound == 0)
@@ -2534,11 +2524,11 @@
char *new_s;
const Py_ssize_t len = PyString_GET_SIZE(self);
Py_ssize_t sub_len, repl_len, out_len;
- int count = -1;
- PyObject *new;
+ Py_ssize_t count = -1;
+ PyObject *newobj;
PyObject *subobj, *replobj;
- if (!PyArg_ParseTuple(args, "OO|i:replace",
+ if (!PyArg_ParseTuple(args, "OO|n:replace",
&subobj, &replobj, &count))
return NULL;
@@ -2574,20 +2564,20 @@
if (out_len == -1) {
if (PyString_CheckExact(self)) {
/* we're returning another reference to self */
- new = (PyObject*)self;
- Py_INCREF(new);
+ newobj = (PyObject*)self;
+ Py_INCREF(newobj);
}
else {
- new = PyString_FromStringAndSize(str, len);
- if (new == NULL)
+ newobj = PyString_FromStringAndSize(str, len);
+ if (newobj == NULL)
return NULL;
}
}
else {
- new = PyString_FromStringAndSize(new_s, out_len);
+ newobj = PyString_FromStringAndSize(new_s, out_len);
PyMem_FREE(new_s);
}
- return new;
+ return newobj;
}
@@ -2606,7 +2596,7 @@
const char* prefix;
Py_ssize_t plen;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *subobj;
if (!PyArg_ParseTuple(args, "O|O&O&:startswith", &subobj,
@@ -2657,7 +2647,7 @@
const char* suffix;
Py_ssize_t slen;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *subobj;
if (!PyArg_ParseTuple(args, "O|O&O&:endswith", &subobj,
@@ -2711,7 +2701,7 @@
char *encoding = NULL;
char *errors = NULL;
PyObject *v;
-
+
if (!PyArg_ParseTuple(args, "|ss:encode", &encoding, &errors))
return NULL;
v = PyString_AsEncodedObject((PyObject *)self, encoding, errors);
@@ -2748,7 +2738,7 @@
char *encoding = NULL;
char *errors = NULL;
PyObject *v;
-
+
if (!PyArg_ParseTuple(args, "|ss:decode", &encoding, &errors))
return NULL;
v = PyString_AsDecodedObject((PyObject *)self, encoding, errors);
@@ -2870,10 +2860,10 @@
static PyObject *
string_ljust(PyStringObject *self, PyObject *args)
{
- int width;
+ Py_ssize_t width;
char fillchar = ' ';
- if (!PyArg_ParseTuple(args, "i|c:ljust", &width, &fillchar))
+ if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
return NULL;
if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
@@ -2894,10 +2884,10 @@
static PyObject *
string_rjust(PyStringObject *self, PyObject *args)
{
- int width;
+ Py_ssize_t width;
char fillchar = ' ';
- if (!PyArg_ParseTuple(args, "i|c:rjust", &width, &fillchar))
+ if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
return NULL;
if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
@@ -2919,10 +2909,10 @@
string_center(PyStringObject *self, PyObject *args)
{
Py_ssize_t marg, left;
- long width;
+ Py_ssize_t width;
char fillchar = ' ';
- if (!PyArg_ParseTuple(args, "l|c:center", &width, &fillchar))
+ if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
return NULL;
if (PyString_GET_SIZE(self) >= width && PyString_CheckExact(self)) {
@@ -2948,9 +2938,9 @@
Py_ssize_t fill;
PyObject *s;
char *p;
+ Py_ssize_t width;
- long width;
- if (!PyArg_ParseTuple(args, "l:zfill", &width))
+ if (!PyArg_ParseTuple(args, "n:zfill", &width))
return NULL;
if (PyString_GET_SIZE(self) >= width) {
@@ -3467,22 +3457,22 @@
"str",
sizeof(PyStringObject),
sizeof(char),
- (destructor)string_dealloc, /* tp_dealloc */
+ string_dealloc, /* tp_dealloc */
(printfunc)string_print, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
- (reprfunc)string_repr, /* tp_repr */
+ string_repr, /* tp_repr */
&string_as_number, /* tp_as_number */
&string_as_sequence, /* tp_as_sequence */
&string_as_mapping, /* tp_as_mapping */
(hashfunc)string_hash, /* tp_hash */
0, /* tp_call */
- (reprfunc)string_str, /* tp_str */
+ string_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
&string_as_buffer, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
Py_TPFLAGS_BASETYPE, /* tp_flags */
string_doc, /* tp_doc */
0, /* tp_traverse */
@@ -3635,7 +3625,7 @@
len = 1 + 50 + 1 + prec = 52 + prec
If prec=0 the effective precision is 1 (the leading digit is
- always given), therefore increase the length by one.
+ always given), therefore increase the length by one.
*/
if ((type == 'g' && buflen <= (size_t)10 + (size_t)prec) ||
@@ -3711,7 +3701,7 @@
}
buf = PyString_AsString(result);
llen = PyString_Size(result);
- if (llen > INT_MAX) {
+ if (llen > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_ValueError, "string too large in _PyString_FormatLong");
return NULL;
}
@@ -4439,7 +4429,7 @@
detector, interned strings are not forcibly deallocated; rather, we
give them their stolen references back, and then clear and DECREF
the interned dict. */
-
+
fprintf(stderr, "releasing interned strings\n");
n = PyList_GET_SIZE(keys);
for (i = 0; i < n; i++) {
diff --git a/Objects/structseq.c b/Objects/structseq.c
index 218d0b4..e074810 100644
--- a/Objects/structseq.c
+++ b/Objects/structseq.c
@@ -315,7 +315,7 @@
0, /* tp_as_number */
&structseq_as_sequence, /* tp_as_sequence */
0, /* tp_as_mapping */
- (hashfunc)structseq_hash, /* tp_hash */
+ structseq_hash, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
@@ -349,6 +349,14 @@
PyMemberDef* members;
int n_members, n_unnamed_members, i, k;
+#ifdef Py_TRACE_REFS
+ /* if the type object was chained, unchain it first
+ before overwriting its storage */
+ if (type->_ob_next) {
+ _Py_ForgetReference((PyObject*)type);
+ }
+#endif
+
n_unnamed_members = 0;
for (i = 0; desc->fields[i].name != NULL; ++i)
if (desc->fields[i].name == PyStructSequence_UnnamedField)
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 384b355..2161ab9 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -438,16 +438,9 @@
tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
{
Py_ssize_t i;
- PyObject *x;
- for (i = o->ob_size; --i >= 0; ) {
- x = o->ob_item[i];
- if (x != NULL) {
- int err = visit(x, arg);
- if (err)
- return err;
- }
- }
+ for (i = o->ob_size; --i >= 0; )
+ Py_VISIT(o->ob_item[i]);
return 0;
}
@@ -547,7 +540,7 @@
static PyObject *
tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *tmp, *new, *item;
+ PyObject *tmp, *newobj, *item;
Py_ssize_t i, n;
assert(PyType_IsSubtype(type, &PyTuple_Type));
@@ -555,16 +548,16 @@
if (tmp == NULL)
return NULL;
assert(PyTuple_Check(tmp));
- new = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
- if (new == NULL)
+ newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
+ if (newobj == NULL)
return NULL;
for (i = 0; i < n; i++) {
item = PyTuple_GET_ITEM(tmp, i);
Py_INCREF(item);
- PyTuple_SET_ITEM(new, i, item);
+ PyTuple_SET_ITEM(newobj, i, item);
}
Py_DECREF(tmp);
- return new;
+ return newobj;
}
PyDoc_STRVAR(tuple_doc,
@@ -615,6 +608,7 @@
}
else {
result = PyTuple_New(slicelength);
+ if (!result) return NULL;
src = self->ob_item;
dest = ((PyTupleObject *)result)->ob_item;
@@ -790,27 +784,6 @@
PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */
} tupleiterobject;
-PyTypeObject PyTupleIter_Type;
-
-static PyObject *
-tuple_iter(PyObject *seq)
-{
- tupleiterobject *it;
-
- if (!PyTuple_Check(seq)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
- if (it == NULL)
- return NULL;
- it->it_index = 0;
- Py_INCREF(seq);
- it->it_seq = (PyTupleObject *)seq;
- _PyObject_GC_TRACK(it);
- return (PyObject *)it;
-}
-
static void
tupleiter_dealloc(tupleiterobject *it)
{
@@ -822,9 +795,8 @@
static int
tupleiter_traverse(tupleiterobject *it, visitproc visit, void *arg)
{
- if (it->it_seq == NULL)
- return 0;
- return visit((PyObject *)it->it_seq, arg);
+ Py_VISIT(it->it_seq);
+ return 0;
}
static PyObject *
@@ -900,3 +872,22 @@
tupleiter_methods, /* tp_methods */
0,
};
+
+static PyObject *
+tuple_iter(PyObject *seq)
+{
+ tupleiterobject *it;
+
+ if (!PyTuple_Check(seq)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
+ if (it == NULL)
+ return NULL;
+ it->it_index = 0;
+ Py_INCREF(seq);
+ it->it_seq = (PyTupleObject *)seq;
+ _PyObject_GC_TRACK(it);
+ return (PyObject *)it;
+}
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index c02f060..4caf538 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -453,7 +453,7 @@
if (PyType_IS_GC(type))
obj = _PyObject_GC_Malloc(size);
else
- obj = PyObject_MALLOC(size);
+ obj = (PyObject *)PyObject_MALLOC(size);
if (obj == NULL)
return PyErr_NoMemory();
@@ -525,21 +525,15 @@
if (type->tp_dictoffset != base->tp_dictoffset) {
PyObject **dictptr = _PyObject_GetDictPtr(self);
- if (dictptr && *dictptr) {
- int err = visit(*dictptr, arg);
- if (err)
- return err;
- }
+ if (dictptr && *dictptr)
+ Py_VISIT(*dictptr);
}
- if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
+ if (type->tp_flags & Py_TPFLAGS_HEAPTYPE)
/* For a heaptype, the instances count as references
to the type. Traverse the type so the collector
can find cycles involving this link. */
- int err = visit((PyObject *)type, arg);
- if (err)
- return err;
- }
+ Py_VISIT(type);
if (basetraverse)
return basetraverse(self, visit, arg);
@@ -559,8 +553,8 @@
char *addr = (char *)self + mp->offset;
PyObject *obj = *(PyObject **)addr;
if (obj != NULL) {
- Py_DECREF(obj);
*(PyObject **)addr = NULL;
+ Py_DECREF(obj);
}
}
}
@@ -1106,14 +1100,17 @@
char buf[1000];
PyObject *k, *v;
PyObject *set = PyDict_New();
+ if (!set) return;
to_merge_size = PyList_GET_SIZE(to_merge);
for (i = 0; i < to_merge_size; i++) {
PyObject *L = PyList_GET_ITEM(to_merge, i);
if (remain[i] < PyList_GET_SIZE(L)) {
PyObject *c = PyList_GET_ITEM(L, remain[i]);
- if (PyDict_SetItem(set, c, Py_None) < 0)
+ if (PyDict_SetItem(set, c, Py_None) < 0) {
+ Py_DECREF(set);
return;
+ }
}
}
n = PyDict_Size(set);
@@ -1121,12 +1118,12 @@
off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a \
consistent method resolution\norder (MRO) for bases");
i = 0;
- while (PyDict_Next(set, &i, &k, &v) && off < sizeof(buf)) {
+ while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) {
PyObject *name = class_name(k);
off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s",
name ? PyString_AS_STRING(name) : "?");
Py_XDECREF(name);
- if (--n && off+1 < sizeof(buf)) {
+ if (--n && (size_t)(off+1) < sizeof(buf)) {
buf[off++] = ',';
buf[off] = '\0';
}
@@ -1147,7 +1144,7 @@
remain[i] is the index of the next base in to_merge[i]
that is not included in acc.
*/
- remain = PyMem_MALLOC(SIZEOF_INT*to_merge_size);
+ remain = (int *)PyMem_MALLOC(SIZEOF_INT*to_merge_size);
if (remain == NULL)
return -1;
for (i = 0; i < to_merge_size; i++)
@@ -1893,7 +1890,7 @@
PyObject *doc = PyDict_GetItemString(dict, "__doc__");
if (doc != NULL && PyString_Check(doc)) {
const size_t n = (size_t)PyString_GET_SIZE(doc);
- char *tp_doc = PyObject_MALLOC(n+1);
+ char *tp_doc = (char *)PyObject_MALLOC(n+1);
if (tp_doc == NULL) {
Py_DECREF(type);
return NULL;
@@ -2195,51 +2192,31 @@
static int
type_traverse(PyTypeObject *type, visitproc visit, void *arg)
{
- int err;
-
/* Because of type_is_gc(), the collector only calls this
for heaptypes. */
assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
-#define VISIT(SLOT) \
- if (SLOT) { \
- err = visit((PyObject *)(SLOT), arg); \
- if (err) \
- return err; \
- }
-
- VISIT(type->tp_dict);
- VISIT(type->tp_cache);
- VISIT(type->tp_mro);
- VISIT(type->tp_bases);
- VISIT(type->tp_base);
+ Py_VISIT(type->tp_dict);
+ Py_VISIT(type->tp_cache);
+ Py_VISIT(type->tp_mro);
+ Py_VISIT(type->tp_bases);
+ Py_VISIT(type->tp_base);
/* There's no need to visit type->tp_subclasses or
((PyHeapTypeObject *)type)->ht_slots, because they can't be involved
in cycles; tp_subclasses is a list of weak references,
and slots is a tuple of strings. */
-#undef VISIT
-
return 0;
}
static int
type_clear(PyTypeObject *type)
{
- PyObject *tmp;
-
/* Because of type_is_gc(), the collector only calls this
for heaptypes. */
assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
-#define CLEAR(SLOT) \
- if (SLOT) { \
- tmp = (PyObject *)(SLOT); \
- SLOT = NULL; \
- Py_DECREF(tmp); \
- }
-
/* The only field we need to clear is tp_mro, which is part of a
hard cycle (its first element is the class itself) that won't
be broken otherwise (it's a tuple and tuples don't have a
@@ -2265,9 +2242,7 @@
A tuple of strings can't be part of a cycle.
*/
- CLEAR(type->tp_mro);
-
-#undef CLEAR
+ Py_CLEAR(type->tp_mro);
return 0;
}
@@ -2443,23 +2418,23 @@
}
static int
-compatible_for_assignment(PyTypeObject* old, PyTypeObject* new, char* attr)
+compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, char* attr)
{
PyTypeObject *newbase, *oldbase;
- if (new->tp_dealloc != old->tp_dealloc ||
- new->tp_free != old->tp_free)
+ if (newto->tp_dealloc != oldto->tp_dealloc ||
+ newto->tp_free != oldto->tp_free)
{
PyErr_Format(PyExc_TypeError,
"%s assignment: "
"'%s' deallocator differs from '%s'",
attr,
- new->tp_name,
- old->tp_name);
+ newto->tp_name,
+ oldto->tp_name);
return 0;
}
- newbase = new;
- oldbase = old;
+ newbase = newto;
+ oldbase = oldto;
while (equiv_structs(newbase, newbase->tp_base))
newbase = newbase->tp_base;
while (equiv_structs(oldbase, oldbase->tp_base))
@@ -2471,8 +2446,8 @@
"%s assignment: "
"'%s' object layout differs from '%s'",
attr,
- new->tp_name,
- old->tp_name);
+ newto->tp_name,
+ oldto->tp_name);
return 0;
}
@@ -2482,8 +2457,8 @@
static int
object_set_class(PyObject *self, PyObject *value, void *closure)
{
- PyTypeObject *old = self->ob_type;
- PyTypeObject *new;
+ PyTypeObject *oldto = self->ob_type;
+ PyTypeObject *newto;
if (value == NULL) {
PyErr_SetString(PyExc_TypeError,
@@ -2496,18 +2471,18 @@
value->ob_type->tp_name);
return -1;
}
- new = (PyTypeObject *)value;
- if (!(new->tp_flags & Py_TPFLAGS_HEAPTYPE) ||
- !(old->tp_flags & Py_TPFLAGS_HEAPTYPE))
+ newto = (PyTypeObject *)value;
+ if (!(newto->tp_flags & Py_TPFLAGS_HEAPTYPE) ||
+ !(oldto->tp_flags & Py_TPFLAGS_HEAPTYPE))
{
PyErr_Format(PyExc_TypeError,
"__class__ assignment: only for heap types");
return -1;
}
- if (compatible_for_assignment(new, old, "__class__")) {
- Py_INCREF(new);
- self->ob_type = new;
- Py_DECREF(old);
+ if (compatible_for_assignment(newto, oldto, "__class__")) {
+ Py_INCREF(newto);
+ self->ob_type = newto;
+ Py_DECREF(oldto);
return 0;
}
else {
@@ -2785,7 +2760,7 @@
"object", /* tp_name */
sizeof(PyObject), /* tp_basicsize */
0, /* tp_itemsize */
- (destructor)object_dealloc, /* tp_dealloc */
+ object_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
@@ -3326,7 +3301,7 @@
{
Py_ssize_t i;
int result;
- PyObject *list, *ref, *new;
+ PyObject *list, *ref, *newobj;
list = base->tp_subclasses;
if (list == NULL) {
@@ -3335,16 +3310,16 @@
return -1;
}
assert(PyList_Check(list));
- new = PyWeakref_NewRef((PyObject *)type, NULL);
+ newobj = PyWeakref_NewRef((PyObject *)type, NULL);
i = PyList_GET_SIZE(list);
while (--i >= 0) {
ref = PyList_GET_ITEM(list, i);
assert(PyWeakref_CheckRef(ref));
if (PyWeakref_GET_OBJECT(ref) == Py_None)
- return PyList_SetItem(list, i, new);
+ return PyList_SetItem(list, i, newobj);
}
- result = PyList_Append(list, new);
- Py_DECREF(new);
+ result = PyList_Append(list, newobj);
+ Py_DECREF(newobj);
return result;
}
@@ -3536,12 +3511,16 @@
}
static PyObject *
-wrap_ssizeargfunc(PyObject *self, PyObject *args, void *wrapped)
+wrap_indexargfunc(PyObject *self, PyObject *args, void *wrapped)
{
ssizeargfunc func = (ssizeargfunc)wrapped;
+ PyObject* o;
Py_ssize_t i;
- if (!PyArg_ParseTuple(args, "n", &i))
+ if (!PyArg_UnpackTuple(args, "", 1, 1, &o))
+ return NULL;
+ i = PyNumber_Index(o);
+ if (i == -1 && PyErr_Occurred())
return NULL;
return (*func)(self, i);
}
@@ -3551,7 +3530,7 @@
{
Py_ssize_t i;
- i = PyInt_AsSsize_t(arg);
+ i = PyNumber_Index(arg);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0) {
@@ -4359,36 +4338,21 @@
static Py_ssize_t
slot_nb_index(PyObject *self)
{
- PyObject *func, *args;
static PyObject *index_str;
- Py_ssize_t result = -1;
+ PyObject *temp = call_method(self, "__index__", &index_str, "()");
+ Py_ssize_t result;
- func = lookup_maybe(self, "__index__", &index_str);
- if (func == NULL) {
- if (!PyErr_Occurred()) {
- PyErr_SetString(PyExc_TypeError,
- "object cannot be interpreted as an index");
- }
+ if (temp == NULL)
return -1;
- }
- args = PyTuple_New(0);
- if (args != NULL) {
- PyObject *temp = PyObject_Call(func, args, NULL);
- Py_DECREF(args);
- if (temp != NULL) {
- if (PyInt_Check(temp) || PyLong_Check(temp)) {
- result =
- temp->ob_type->tp_as_number->nb_index(temp);
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "__index__ must return an int or a long");
- result = -1;
- }
- Py_DECREF(temp);
- }
+ if (PyInt_CheckExact(temp) || PyLong_CheckExact(temp)) {
+ result = temp->ob_type->tp_as_number->nb_index(temp);
}
- Py_DECREF(func);
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "__index__ must return an int or a long");
+ result = -1;
+ }
+ Py_DECREF(temp);
return result;
}
@@ -5018,9 +4982,9 @@
test_descr.notimplemented() */
SQSLOT("__add__", sq_concat, NULL, wrap_binaryfunc,
"x.__add__(y) <==> x+y"),
- SQSLOT("__mul__", sq_repeat, NULL, wrap_ssizeargfunc,
+ SQSLOT("__mul__", sq_repeat, NULL, wrap_indexargfunc,
"x.__mul__(n) <==> x*n"),
- SQSLOT("__rmul__", sq_repeat, NULL, wrap_ssizeargfunc,
+ SQSLOT("__rmul__", sq_repeat, NULL, wrap_indexargfunc,
"x.__rmul__(n) <==> n*x"),
SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item,
"x.__getitem__(y) <==> x[y]"),
@@ -5046,7 +5010,7 @@
SQSLOT("__iadd__", sq_inplace_concat, NULL,
wrap_binaryfunc, "x.__iadd__(y) <==> x+=y"),
SQSLOT("__imul__", sq_inplace_repeat, NULL,
- wrap_ssizeargfunc, "x.__imul__(y) <==> x*=y"),
+ wrap_indexargfunc, "x.__imul__(y) <==> x*=y"),
MPSLOT("__len__", mp_length, slot_mp_length, wrap_lenfunc,
"x.__len__() <==> len(x)"),
@@ -5211,21 +5175,21 @@
/* Note: this depends on the order of the members of PyHeapTypeObject! */
assert(offset >= 0);
- assert(offset < offsetof(PyHeapTypeObject, as_buffer));
- if (offset >= offsetof(PyHeapTypeObject, as_sequence)) {
- ptr = (void *)type->tp_as_sequence;
+ assert((size_t)offset < offsetof(PyHeapTypeObject, as_buffer));
+ if ((size_t)offset >= offsetof(PyHeapTypeObject, as_sequence)) {
+ ptr = (char *)type->tp_as_sequence;
offset -= offsetof(PyHeapTypeObject, as_sequence);
}
- else if (offset >= offsetof(PyHeapTypeObject, as_mapping)) {
- ptr = (void *)type->tp_as_mapping;
+ else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_mapping)) {
+ ptr = (char *)type->tp_as_mapping;
offset -= offsetof(PyHeapTypeObject, as_mapping);
}
- else if (offset >= offsetof(PyHeapTypeObject, as_number)) {
- ptr = (void *)type->tp_as_number;
+ else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_number)) {
+ ptr = (char *)type->tp_as_number;
offset -= offsetof(PyHeapTypeObject, as_number);
}
else {
- ptr = (void *)type;
+ ptr = (char *)type;
}
if (ptr != NULL)
ptr += offset;
@@ -5743,7 +5707,7 @@
super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
{
superobject *su = (superobject *)self;
- superobject *new;
+ superobject *newobj;
if (obj == NULL || obj == Py_None || su->obj != NULL) {
/* Not binding to an object, or already bound */
@@ -5760,16 +5724,16 @@
PyTypeObject *obj_type = supercheck(su->type, obj);
if (obj_type == NULL)
return NULL;
- new = (superobject *)PySuper_Type.tp_new(&PySuper_Type,
+ newobj = (superobject *)PySuper_Type.tp_new(&PySuper_Type,
NULL, NULL);
- if (new == NULL)
+ if (newobj == NULL)
return NULL;
Py_INCREF(su->type);
Py_INCREF(obj);
- new->type = su->type;
- new->obj = obj;
- new->obj_type = obj_type;
- return (PyObject *)new;
+ newobj->type = su->type;
+ newobj->obj = obj;
+ newobj->obj_type = obj_type;
+ return (PyObject *)newobj;
}
}
@@ -5811,20 +5775,10 @@
super_traverse(PyObject *self, visitproc visit, void *arg)
{
superobject *su = (superobject *)self;
- int err;
-#define VISIT(SLOT) \
- if (SLOT) { \
- err = visit((PyObject *)(SLOT), arg); \
- if (err) \
- return err; \
- }
-
- VISIT(su->obj);
- VISIT(su->type);
- VISIT(su->obj_type);
-
-#undef VISIT
+ Py_VISIT(su->obj);
+ Py_VISIT(su->type);
+ Py_VISIT(su->obj_type);
return 0;
}
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 7fbce14..e62c774 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -36,6 +36,7 @@
*/
+#define PY_SSIZE_T_CLEAN
#include "Python.h"
#include "unicodeobject.h"
@@ -83,6 +84,11 @@
*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
/* Free list for Unicode objects */
static PyUnicodeObject *unicode_freelist;
static int unicode_freelist_size;
@@ -130,14 +136,9 @@
/* Resizing shared object (unicode_empty or single character
objects) in-place is not allowed. Use PyUnicode_Resize()
instead ! */
- if (unicode == unicode_empty ||
- (unicode->length == 1 &&
- /* MvL said unicode->str[] may be signed. Python generally assumes
- * an int contains at least 32 bits, and we don't use more than
- * 32 bits even in a UCS4 build, so casting to unsigned int should
- * be correct.
- */
- (unsigned int)unicode->str[0] < 256U &&
+ if (unicode == unicode_empty ||
+ (unicode->length == 1 &&
+ unicode->str[0] < 256U &&
unicode_latin1[unicode->str[0]] == unicode)) {
PyErr_SetString(PyExc_SystemError,
"can't resize shared unicode objects");
@@ -149,13 +150,12 @@
oldstr = unicode->str;
PyMem_RESIZE(unicode->str, Py_UNICODE, length + 1);
if (!unicode->str) {
- unicode->str = oldstr;
+ unicode->str = (Py_UNICODE *)oldstr;
PyErr_NoMemory();
return -1;
}
unicode->str[length] = 0;
- assert(length < INT_MAX);
- unicode->length = (int)length;
+ unicode->length = length;
reset:
/* Reset the object caches */
@@ -226,8 +226,7 @@
*/
unicode->str[0] = 0;
unicode->str[length] = 0;
- assert(length<INT_MAX);
- unicode->length = (int)length;
+ unicode->length = length;
unicode->hash = -1;
unicode->defenc = NULL;
return unicode;
@@ -368,7 +367,7 @@
#else
{
register Py_UNICODE *u;
- register int i;
+ register Py_ssize_t i;
u = PyUnicode_AS_UNICODE(unicode);
for (i = size; i > 0; i--)
*u++ = *w++;
@@ -396,7 +395,7 @@
#else
{
register Py_UNICODE *u;
- register int i;
+ register Py_ssize_t i;
u = PyUnicode_AS_UNICODE(unicode);
for (i = size; i > 0; i--)
*w++ = *u++;
@@ -1358,7 +1357,7 @@
PyObject *v; /* result string object */
char *p; /* next free byte in output buffer */
Py_ssize_t nallocated; /* number of result bytes allocated */
- int nneeded; /* number of result bytes needed */
+ Py_ssize_t nneeded; /* number of result bytes needed */
char stackbuf[MAX_SHORT_UNICHARS * 4];
assert(s != NULL);
@@ -1427,13 +1426,13 @@
if (v == NULL) {
/* This was stack allocated. */
- nneeded = Py_SAFE_DOWNCAST(p - stackbuf, long, int);
+ nneeded = p - stackbuf;
assert(nneeded <= nallocated);
v = PyString_FromStringAndSize(stackbuf, nneeded);
}
else {
/* Cut back to size actually needed. */
- nneeded = Py_SAFE_DOWNCAST(p - PyString_AS_STRING(v), long, int);
+ nneeded = p - PyString_AS_STRING(v);
assert(nneeded <= nallocated);
_PyString_Resize(&v, nneeded);
}
@@ -1884,7 +1883,7 @@
Py_DECREF(m);
if (api == NULL)
goto ucnhashError;
- ucnhash_CAPI = PyCObject_AsVoidPtr(api);
+ ucnhash_CAPI = (_PyUnicode_Name_CAPI *)PyCObject_AsVoidPtr(api);
Py_DECREF(api);
if (ucnhash_CAPI == NULL)
goto ucnhashError;
@@ -1934,7 +1933,7 @@
nextByte:
;
}
- if (_PyUnicode_Resize(&v, (int)(p - PyUnicode_AS_UNICODE(v))) < 0)
+ if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
@@ -2003,7 +2002,7 @@
#ifdef Py_UNICODE_WIDE
/* Map 21-bit characters to '\U00xxxxxx' */
else if (ch >= 0x10000) {
- int offset = p - PyString_AS_STRING(repr);
+ Py_ssize_t offset = p - PyString_AS_STRING(repr);
/* Resize the string if necessary */
if (offset + 12 > PyString_GET_SIZE(repr)) {
@@ -2205,7 +2204,7 @@
nextByte:
;
}
- if (_PyUnicode_Resize(&v, (int)(p - PyUnicode_AS_UNICODE(v))) < 0)
+ if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
@@ -2348,7 +2347,7 @@
}
}
- if (_PyUnicode_Resize(&v, (int)(p - PyUnicode_AS_UNICODE(v))) < 0)
+ if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
@@ -2499,8 +2498,8 @@
/* current output position */
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)";
+ const char *encoding = (limit == 256) ? "latin-1" : "ascii";
+ const char *reason = (limit == 256) ? "ordinal not in range(256)" : "ordinal not in range(128)";
PyObject *errorHandler = NULL;
PyObject *exc = NULL;
/* the following variable is used for caching string comparisons
@@ -2723,7 +2722,7 @@
}
}
if (p - PyUnicode_AS_UNICODE(v) < PyString_GET_SIZE(v))
- if (_PyUnicode_Resize(&v, (int)(p - PyUnicode_AS_UNICODE(v))) < 0)
+ if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
@@ -2982,7 +2981,7 @@
}
}
if (p - PyUnicode_AS_UNICODE(v) < PyUnicode_GET_SIZE(v))
- if (_PyUnicode_Resize(&v, (int)(p - PyUnicode_AS_UNICODE(v))) < 0)
+ if (_PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
@@ -3336,9 +3335,9 @@
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";
+ static char *argparse = "O!n;translating error handler must return (unicode, int) tuple";
- int i_newpos;
+ Py_ssize_t i_newpos;
PyObject *restuple;
PyObject *resunicode;
@@ -3798,7 +3797,7 @@
Py_ssize_t end,
PyUnicodeObject *substring)
{
- int count = 0;
+ Py_ssize_t count = 0;
if (start < 0)
start += self->length;
@@ -4157,7 +4156,7 @@
PyObject *fseq; /* PySequence_Fast(seq) */
Py_ssize_t seqlen; /* len(fseq) -- number of items in sequence */
PyObject *item;
- int i;
+ Py_ssize_t i;
fseq = PySequence_Fast(seq, "");
if (fseq == NULL) {
@@ -4206,7 +4205,7 @@
}
/* Get space. */
- res = _PyUnicode_New((int)res_alloc);
+ res = _PyUnicode_New(res_alloc);
if (res == NULL)
goto onError;
res_p = PyUnicode_AS_UNICODE(res);
@@ -4220,7 +4219,7 @@
/* Convert item to Unicode. */
if (! PyUnicode_Check(item) && ! PyString_Check(item)) {
PyErr_Format(PyExc_TypeError,
- "sequence item %i: expected string or Unicode,"
+ "sequence item %zd: expected string or Unicode,"
" %.80s found",
i, item->ob_type->tp_name);
goto onError;
@@ -4236,11 +4235,11 @@
/* Make sure we have enough space for the separator and the item. */
itemlen = PyUnicode_GET_SIZE(item);
new_res_used = res_used + itemlen;
- if (new_res_used < res_used || new_res_used > INT_MAX)
+ if (new_res_used < res_used || new_res_used > PY_SSIZE_T_MAX)
goto Overflow;
if (i < seqlen - 1) {
new_res_used += seplen;
- if (new_res_used < res_used || new_res_used > INT_MAX)
+ if (new_res_used < res_used || new_res_used > PY_SSIZE_T_MAX)
goto Overflow;
}
if (new_res_used > res_alloc) {
@@ -4248,10 +4247,10 @@
do {
size_t oldsize = res_alloc;
res_alloc += res_alloc;
- if (res_alloc < oldsize || res_alloc > INT_MAX)
+ if (res_alloc < oldsize || res_alloc > PY_SSIZE_T_MAX)
goto Overflow;
} while (new_res_used > res_alloc);
- if (_PyUnicode_Resize(&res, (int)res_alloc) < 0) {
+ if (_PyUnicode_Resize(&res, res_alloc) < 0) {
Py_DECREF(item);
goto onError;
}
@@ -4259,10 +4258,10 @@
}
/* Copy item, and maybe the separator. */
- Py_UNICODE_COPY(res_p, PyUnicode_AS_UNICODE(item), (int)itemlen);
+ Py_UNICODE_COPY(res_p, PyUnicode_AS_UNICODE(item), itemlen);
res_p += itemlen;
if (i < seqlen - 1) {
- Py_UNICODE_COPY(res_p, sep, (int)seplen);
+ Py_UNICODE_COPY(res_p, sep, seplen);
res_p += seplen;
}
Py_DECREF(item);
@@ -4272,7 +4271,7 @@
/* Shrink res to match the used area; this probably can't fail,
* but it's cheap to check.
*/
- if (_PyUnicode_Resize(&res, (int)res_used) < 0)
+ if (_PyUnicode_Resize(&res, res_used) < 0)
goto onError;
Done:
@@ -4605,7 +4604,7 @@
PyObject *list;
if (maxcount < 0)
- maxcount = INT_MAX;
+ maxcount = PY_SSIZE_T_MAX;
list = PyList_New(0);
if (!list)
@@ -4634,7 +4633,7 @@
PyObject *list;
if (maxcount < 0)
- maxcount = INT_MAX;
+ maxcount = PY_SSIZE_T_MAX;
list = PyList_New(0);
if (!list)
@@ -4664,10 +4663,10 @@
PyUnicodeObject *u;
if (maxcount < 0)
- maxcount = INT_MAX;
+ maxcount = PY_SSIZE_T_MAX;
if (str1->length == 1 && str2->length == 1) {
- int i;
+ Py_ssize_t i;
/* replace characters */
if (!findchar(self->str, self->length, str1->str[0]) &&
@@ -5088,7 +5087,7 @@
{
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *result;
if (!PyArg_ParseTuple(args, "O|O&O&:count", &substring,
@@ -5265,7 +5264,7 @@
{
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *result;
if (!PyArg_ParseTuple(args, "O|O&O&:find", &substring,
@@ -5331,7 +5330,7 @@
Py_ssize_t result;
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
if (!PyArg_ParseTuple(args, "O|O&O&:index", &substring,
_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
@@ -5669,10 +5668,10 @@
static PyObject *
unicode_ljust(PyUnicodeObject *self, PyObject *args)
{
- int width;
+ Py_ssize_t width;
Py_UNICODE fillchar = ' ';
- if (!PyArg_ParseTuple(args, "i|O&:ljust", &width, convert_uc, &fillchar))
+ if (!PyArg_ParseTuple(args, "n|O&:ljust", &width, convert_uc, &fillchar))
return NULL;
if (self->length >= width && PyUnicode_CheckExact(self)) {
@@ -5996,7 +5995,7 @@
{
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *result;
if (!PyArg_ParseTuple(args, "O|O&O&:rfind", &substring,
@@ -6024,7 +6023,7 @@
Py_ssize_t result;
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
if (!PyArg_ParseTuple(args, "O|O&O&:rindex", &substring,
_PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
@@ -6053,10 +6052,10 @@
static PyObject *
unicode_rjust(PyUnicodeObject *self, PyObject *args)
{
- int width;
+ Py_ssize_t width;
Py_UNICODE fillchar = ' ';
- if (!PyArg_ParseTuple(args, "i|O&:rjust", &width, convert_uc, &fillchar))
+ if (!PyArg_ParseTuple(args, "n|O&:rjust", &width, convert_uc, &fillchar))
return NULL;
if (self->length >= width && PyUnicode_CheckExact(self)) {
@@ -6318,7 +6317,7 @@
{
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *result;
if (!PyArg_ParseTuple(args, "O|O&O&:startswith", &substring,
@@ -6349,7 +6348,7 @@
{
PyUnicodeObject *substring;
Py_ssize_t start = 0;
- Py_ssize_t end = INT_MAX;
+ Py_ssize_t end = PY_SSIZE_T_MAX;
PyObject *result;
if (!PyArg_ParseTuple(args, "O|O&O&:endswith", &substring,
@@ -6450,13 +6449,13 @@
static PySequenceMethods unicode_as_sequence = {
(lenfunc) unicode_length, /* sq_length */
- (binaryfunc) PyUnicode_Concat, /* sq_concat */
+ PyUnicode_Concat, /* sq_concat */
(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*/
+ PyUnicode_Contains, /* sq_contains */
};
#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
@@ -6487,7 +6486,8 @@
return PyUnicode_FromUnicode(NULL, 0);
} else {
source_buf = PyUnicode_AS_UNICODE((PyObject*)self);
- result_buf = PyMem_MALLOC(slicelength*sizeof(Py_UNICODE));
+ result_buf = (Py_UNICODE *)PyMem_MALLOC(slicelength*
+ sizeof(Py_UNICODE));
if (result_buf == NULL)
return PyErr_NoMemory();
@@ -7336,7 +7336,7 @@
0, /* tp_getattr */
0, /* tp_setattr */
(cmpfunc) unicode_compare, /* tp_compare */
- (reprfunc) unicode_repr, /* tp_repr */
+ unicode_repr, /* tp_repr */
&unicode_as_number, /* tp_as_number */
&unicode_as_sequence, /* tp_as_sequence */
&unicode_as_mapping, /* tp_as_mapping */
@@ -7416,6 +7416,11 @@
unicode_freelist_size = 0;
}
+#ifdef __cplusplus
+}
+#endif
+
+
/*
Local variables:
c-basic-offset: 4
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index 39595ae..3f2c261 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -109,8 +109,7 @@
static int
gc_traverse(PyWeakReference *self, visitproc visit, void *arg)
{
- if (self->wr_callback != NULL)
- return visit(self->wr_callback, arg);
+ Py_VISIT(self->wr_callback);
return 0;
}
@@ -367,7 +366,7 @@
0, /*tp_descr_get*/
0, /*tp_descr_set*/
0, /*tp_dictoffset*/
- (initproc)weakref___init__, /*tp_init*/
+ weakref___init__, /*tp_init*/
PyType_GenericAlloc, /*tp_alloc*/
weakref___new__, /*tp_new*/
PyObject_GC_Del, /*tp_free*/
@@ -586,38 +585,38 @@
static PyNumberMethods proxy_as_number = {
- (binaryfunc)proxy_add, /*nb_add*/
- (binaryfunc)proxy_sub, /*nb_subtract*/
- (binaryfunc)proxy_mul, /*nb_multiply*/
- (binaryfunc)proxy_mod, /*nb_remainder*/
- (binaryfunc)proxy_divmod, /*nb_divmod*/
- (ternaryfunc)proxy_pow, /*nb_power*/
- (unaryfunc)proxy_neg, /*nb_negative*/
- (unaryfunc)proxy_pos, /*nb_positive*/
- (unaryfunc)proxy_abs, /*nb_absolute*/
- (inquiry)proxy_nonzero, /*nb_nonzero*/
- (unaryfunc)proxy_invert, /*nb_invert*/
- (binaryfunc)proxy_lshift, /*nb_lshift*/
- (binaryfunc)proxy_rshift, /*nb_rshift*/
- (binaryfunc)proxy_and, /*nb_and*/
- (binaryfunc)proxy_xor, /*nb_xor*/
- (binaryfunc)proxy_or, /*nb_or*/
- (coercion)0, /*nb_coerce*/
- (unaryfunc)proxy_int, /*nb_int*/
- (unaryfunc)proxy_long, /*nb_long*/
- (unaryfunc)proxy_float, /*nb_float*/
- (unaryfunc)0, /*nb_oct*/
- (unaryfunc)0, /*nb_hex*/
- (binaryfunc)proxy_iadd, /*nb_inplace_add*/
- (binaryfunc)proxy_isub, /*nb_inplace_subtract*/
- (binaryfunc)proxy_imul, /*nb_inplace_multiply*/
- (binaryfunc)proxy_imod, /*nb_inplace_remainder*/
- (ternaryfunc)proxy_ipow, /*nb_inplace_power*/
- (binaryfunc)proxy_ilshift, /*nb_inplace_lshift*/
- (binaryfunc)proxy_irshift, /*nb_inplace_rshift*/
- (binaryfunc)proxy_iand, /*nb_inplace_and*/
- (binaryfunc)proxy_ixor, /*nb_inplace_xor*/
- (binaryfunc)proxy_ior, /*nb_inplace_or*/
+ proxy_add, /*nb_add*/
+ proxy_sub, /*nb_subtract*/
+ proxy_mul, /*nb_multiply*/
+ proxy_mod, /*nb_remainder*/
+ proxy_divmod, /*nb_divmod*/
+ proxy_pow, /*nb_power*/
+ proxy_neg, /*nb_negative*/
+ proxy_pos, /*nb_positive*/
+ proxy_abs, /*nb_absolute*/
+ (inquiry)proxy_nonzero, /*nb_nonzero*/
+ proxy_invert, /*nb_invert*/
+ proxy_lshift, /*nb_lshift*/
+ proxy_rshift, /*nb_rshift*/
+ proxy_and, /*nb_and*/
+ proxy_xor, /*nb_xor*/
+ proxy_or, /*nb_or*/
+ 0, /*nb_coerce*/
+ proxy_int, /*nb_int*/
+ proxy_long, /*nb_long*/
+ proxy_float, /*nb_float*/
+ 0, /*nb_oct*/
+ 0, /*nb_hex*/
+ proxy_iadd, /*nb_inplace_add*/
+ proxy_isub, /*nb_inplace_subtract*/
+ proxy_imul, /*nb_inplace_multiply*/
+ proxy_imod, /*nb_inplace_remainder*/
+ proxy_ipow, /*nb_inplace_power*/
+ proxy_ilshift, /*nb_inplace_lshift*/
+ proxy_irshift, /*nb_inplace_rshift*/
+ proxy_iand, /*nb_inplace_and*/
+ proxy_ixor, /*nb_inplace_xor*/
+ proxy_ior, /*nb_inplace_or*/
};
static PySequenceMethods proxy_as_sequence = {
@@ -632,8 +631,8 @@
};
static PyMappingMethods proxy_as_mapping = {
- (lenfunc)proxy_length, /*mp_length*/
- (binaryfunc)proxy_getitem, /*mp_subscript*/
+ (lenfunc)proxy_length, /*mp_length*/
+ proxy_getitem, /*mp_subscript*/
(objobjargproc)proxy_setitem, /*mp_ass_subscript*/
};
@@ -651,14 +650,14 @@
0, /* tp_getattr */
0, /* tp_setattr */
proxy_compare, /* tp_compare */
- (unaryfunc)proxy_repr, /* tp_repr */
+ (reprfunc)proxy_repr, /* tp_repr */
&proxy_as_number, /* tp_as_number */
&proxy_as_sequence, /* tp_as_sequence */
&proxy_as_mapping, /* tp_as_mapping */
0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
- (unaryfunc)proxy_str, /* tp_str */
- (getattrofunc)proxy_getattr, /* tp_getattro */
+ 0, /* tp_call */
+ proxy_str, /* tp_str */
+ proxy_getattr, /* tp_getattro */
(setattrofunc)proxy_setattr, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC
@@ -691,9 +690,9 @@
&proxy_as_sequence, /* tp_as_sequence */
&proxy_as_mapping, /* tp_as_mapping */
0, /* tp_hash */
- (ternaryfunc)proxy_call, /* tp_call */
- (unaryfunc)proxy_str, /* tp_str */
- (getattrofunc)proxy_getattr, /* tp_getattro */
+ proxy_call, /* tp_call */
+ proxy_str, /* tp_str */
+ proxy_getattr, /* tp_getattro */
(setattrofunc)proxy_setattr, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC