}
/* 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);
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 */
{
register PyObject *v;
register char *sname = PyString_AsString(name);
- PyClassObject *class;
+ PyClassObject *klass;
descrgetfunc f;
if (sname[0] == '_' && sname[1] == '_') {
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'",
};
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))
instance_getattr2(register PyInstanceObject *inst, PyObject *name)
{
register PyObject *v;
- PyClassObject *class;
+ PyClassObject *klass;
descrgetfunc f;
v = PyDict_GetItem(inst->in_dict, name);
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);
_PyInstance_Lookup(PyObject *pinst, PyObject *name)
{
PyObject *v;
- PyClassObject *class;
+ PyClassObject *klass;
PyInstanceObject *inst; /* pinst cast to the right type */
assert(PyInstance_Check(pinst));
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;
}
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)) {
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;
}
}
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();
static void
getinstclassname(PyObject *inst, char *buf, int bufsize)
{
- PyObject *class;
+ PyObject *klass;
if (inst == NULL) {
assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
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);
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 "
PyObject* en_result; /* result tuple */
} enumobject;
-PyTypeObject PyEnum_Type;
-
static PyObject *
enum_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
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);
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;
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;
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;
}
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;
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 *
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;
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));
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 *
PyObject *value;
} sortwrapperobject;
-static PyTypeObject sortwrapper_type;
-
+PyDoc_STRVAR(sortwrapper_doc, "Object wrapper with a custom sort key.");
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);
-}
-
+sortwrapper_richcompare(sortwrapperobject *, sortwrapperobject *, int);
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.");
+sortwrapper_dealloc(sortwrapperobject *);
static PyTypeObject sortwrapper_type = {
PyObject_HEAD_INIT(&PyType_Type)
(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. */
PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
} listiterobject;
-PyTypeObject PyListIter_Type;
+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)).");
+
+static PyMethodDef listiter_methods[] = {
+ {"__length_hint__", (PyCFunction)listiter_len, METH_NOARGS, length_hint_doc},
+ {NULL, NULL} /* sentinel */
+};
+
+PyTypeObject PyListIter_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /* ob_size */
+ "listiterator", /* tp_name */
+ sizeof(listiterobject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)listiter_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 */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)listiter_traverse, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ PyObject_SelfIter, /* tp_iter */
+ (iternextfunc)listiter_next, /* tp_iternext */
+ listiter_methods, /* tp_methods */
+ 0, /* tp_members */
+};
+
static PyObject *
list_iter(PyObject *seq)
}
return PyInt_FromLong(0);
}
+/*********************** List Reverse Iterator **************************/
-PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
+typedef struct {
+ PyObject_HEAD
+ Py_ssize_t it_index;
+ PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
+} listreviterobject;
-static PyMethodDef listiter_methods[] = {
- {"__length_hint__", (PyCFunction)listiter_len, METH_NOARGS, length_hint_doc},
- {NULL, NULL} /* sentinel */
+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 */
+ 0, /* sq_concat */
};
-PyTypeObject PyListIter_Type = {
+PyTypeObject PyListRevIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
- "listiterator", /* tp_name */
- sizeof(listiterobject), /* tp_basicsize */
+ "listreverseiterator", /* tp_name */
+ sizeof(listreviterobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
- (destructor)listiter_dealloc, /* tp_dealloc */
+ (destructor)listreviter_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 */
+ &listreviter_as_sequence, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
0, /* tp_doc */
- (traverseproc)listiter_traverse, /* tp_traverse */
+ (traverseproc)listreviter_traverse, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
PyObject_SelfIter, /* tp_iter */
- (iternextfunc)listiter_next, /* tp_iternext */
- listiter_methods, /* tp_methods */
- 0, /* tp_members */
+ (iternextfunc)listreviter_next, /* tp_iternext */
+ 0,
};
-/*********************** List Reverse Iterator **************************/
-
-typedef struct {
- PyObject_HEAD
- Py_ssize_t it_index;
- PyListObject *it_seq; /* Set to NULL when iterator is exhausted */
-} listreviterobject;
-
-PyTypeObject PyListRevIter_Type;
-
static PyObject *
list_reversed(PyListObject *seq, PyObject *unused)
{
return len;
}
-static PySequenceMethods listreviter_as_sequence = {
- (lenfunc)listreviter_len, /* sq_length */
- 0, /* sq_concat */
-};
-
-PyTypeObject PyListRevIter_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0, /* ob_size */
- "listreverseiterator", /* tp_name */
- sizeof(listreviterobject), /* tp_basicsize */
- 0, /* tp_itemsize */
- /* methods */
- (destructor)listreviter_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_compare */
- 0, /* tp_repr */
- 0, /* tp_as_number */
- &listreviter_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 | Py_TPFLAGS_HAVE_GC,/* tp_flags */
- 0, /* tp_doc */
- (traverseproc)listreviter_traverse, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- PyObject_SelfIter, /* tp_iter */
- (iternextfunc)listreviter_next, /* tp_iternext */
- 0,
-};
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;
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));
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 *
projects / python / commitdiff