Quickly renamed the last directory.
diff --git a/Objects/object.c b/Objects/object.c
index fc1d086..a2198e6 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -31,10 +31,10 @@
/* Generic object operations; and implementation of None (NoObject) */
-#include "allobjects.h"
+#include "Python.h"
#if defined( Py_TRACE_REFS ) || defined( Py_REF_DEBUG )
-long ref_total;
+long _Py_RefTotal;
#endif
/* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
@@ -42,14 +42,14 @@
Do not call them otherwise, they do not initialize the object! */
#ifdef COUNT_ALLOCS
-static typeobject *type_list;
+static PyTypeObject *type_list;
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()
{
- typeobject *tp;
+ PyTypeObject *tp;
for (tp = type_list; tp; tp = tp->tp_next)
fprintf(stderr, "%s alloc'd: %d, freed: %d, max in use: %d\n",
@@ -92,12 +92,12 @@
void
inc_count(tp)
- typeobject *tp;
+ PyTypeObject *tp;
{
if (tp->tp_alloc == 0) {
/* first time; insert in linked list */
if (tp->tp_next != NULL) /* sanity check */
- fatal("XXX inc_count sanity check");
+ Py_FatalError("XXX inc_count sanity check");
tp->tp_next = type_list;
type_list = tp;
}
@@ -108,35 +108,35 @@
#endif
#ifndef MS_COREDLL
-object *
-newobject(tp)
- typeobject *tp;
+PyObject *
+_PyObject_New(tp)
+ PyTypeObject *tp;
#else
-object *
-newobject(tp,op)
- typeobject *tp;
+PyObject *
+_PyObject_New(tp,op)
+ PyTypeObject *tp;
PyObject *op;
#endif
{
#ifndef MS_COREDLL
- object *op = (object *) malloc(tp->tp_basicsize);
+ PyObject *op = (PyObject *) malloc(tp->tp_basicsize);
#endif
if (op == NULL)
- return err_nomem();
+ return PyErr_NoMemory();
op->ob_type = tp;
- NEWREF(op);
+ _Py_NewReference(op);
return op;
}
#ifndef MS_COREDLL
varobject *
-newvarobject(tp, size)
- typeobject *tp;
+_PyObject_NewVar(tp, size)
+ PyTypeObject *tp;
int size;
#else
varobject *
-newvarobject(tp, size, op)
- typeobject *tp;
+_PyObject_NewVar(tp, size, op)
+ PyTypeObject *tp;
int size;
varobject *op;
#endif
@@ -146,21 +146,21 @@
malloc(tp->tp_basicsize + size * tp->tp_itemsize);
#endif
if (op == NULL)
- return (varobject *)err_nomem();
+ return (varobject *)PyErr_NoMemory();
op->ob_type = tp;
op->ob_size = size;
- NEWREF(op);
+ _Py_NewReference(op);
return op;
}
int
-printobject(op, fp, flags)
- object *op;
+PyObject_Print(op, fp, flags)
+ PyObject *op;
FILE *fp;
int flags;
{
int ret = 0;
- if (sigcheck())
+ if (PyErr_CheckSignals())
return -1;
if (op == NULL) {
fprintf(fp, "<nil>");
@@ -175,22 +175,23 @@
op->ob_type->tp_name, (long)op);
}
else {
- object *s;
- if (flags & PRINT_RAW)
- s = strobject(op);
+ PyObject *s;
+ if (flags & Py_PRINT_RAW)
+ s = PyObject_Str(op);
else
- s = reprobject(op);
+ s = PyObject_Repr(op);
if (s == NULL)
ret = -1;
- else if (!is_stringobject(s)) {
- err_setstr(TypeError,
+ else if (!PyString_Check(s)) {
+ PyErr_SetString(PyExc_TypeError,
"repr not string");
ret = -1;
}
else {
- fprintf(fp, "%s", getstringvalue(s));
+ fprintf(fp, "%s",
+ PyString_AsString(s));
}
- XDECREF(s);
+ Py_XDECREF(s);
}
}
else
@@ -198,7 +199,7 @@
}
if (ret == 0) {
if (ferror(fp)) {
- err_errno(IOError);
+ PyErr_SetFromErrno(PyExc_IOError);
clearerr(fp);
ret = -1;
}
@@ -206,104 +207,104 @@
return ret;
}
-object *
-reprobject(v)
- object *v;
+PyObject *
+PyObject_Repr(v)
+ PyObject *v;
{
- if (sigcheck())
+ if (PyErr_CheckSignals())
return NULL;
if (v == NULL)
- return newstringobject("<NULL>");
+ return PyString_FromString("<NULL>");
else if (v->ob_type->tp_repr == NULL) {
char buf[120];
sprintf(buf, "<%.80s object at %lx>",
v->ob_type->tp_name, (long)v);
- return newstringobject(buf);
+ return PyString_FromString(buf);
}
else
return (*v->ob_type->tp_repr)(v);
}
-object *
-strobject(v)
- object *v;
+PyObject *
+PyObject_Str(v)
+ PyObject *v;
{
if (v == NULL)
- return newstringobject("<NULL>");
- else if (is_stringobject(v)) {
- INCREF(v);
+ return PyString_FromString("<NULL>");
+ else if (PyString_Check(v)) {
+ Py_INCREF(v);
return v;
}
else if (v->ob_type->tp_str != NULL)
return (*v->ob_type->tp_str)(v);
else {
- object *func;
- object *res;
- if (!is_instanceobject(v) ||
- (func = getattr(v, "__str__")) == NULL) {
- err_clear();
- return reprobject(v);
+ PyObject *func;
+ PyObject *res;
+ if (!PyInstance_Check(v) ||
+ (func = PyObject_GetAttrString(v, "__str__")) == NULL) {
+ PyErr_Clear();
+ return PyObject_Repr(v);
}
- res = call_object(func, (object *)NULL);
- DECREF(func);
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
return res;
}
}
-static object *
+static PyObject *
do_cmp(v, w)
- object *v, *w;
+ PyObject *v, *w;
{
/* __rcmp__ actually won't be called unless __cmp__ isn't defined,
because the check in cmpobject() reverses the objects first.
- This is intentional -- it makes no sense to define cmp(x,y) different
- than -cmp(y,x). */
- if (is_instanceobject(v) || is_instanceobject(w))
- return instancebinop(v, w, "__cmp__", "__rcmp__", do_cmp);
- return newintobject((long)cmpobject(v, w));
+ This is intentional -- it makes no sense to define cmp(x,y)
+ different than -cmp(y,x). */
+ if (PyInstance_Check(v) || PyInstance_Check(w))
+ return PyInstance_DoBinOp(v, w, "__cmp__", "__rcmp__", do_cmp);
+ return PyInt_FromLong((long)PyObject_Compare(v, w));
}
int
-cmpobject(v, w)
- object *v, *w;
+PyObject_Compare(v, w)
+ PyObject *v, *w;
{
- typeobject *tp;
+ PyTypeObject *tp;
if (v == w)
return 0;
if (v == NULL)
return -1;
if (w == NULL)
return 1;
- if (is_instanceobject(v) || is_instanceobject(w)) {
- object *res;
+ if (PyInstance_Check(v) || PyInstance_Check(w)) {
+ PyObject *res;
int c;
- if (!is_instanceobject(v))
- return -cmpobject(w, v);
+ if (!PyInstance_Check(v))
+ return -PyObject_Compare(w, v);
res = do_cmp(v, w);
if (res == NULL) {
- err_clear();
+ PyErr_Clear();
return (v < w) ? -1 : 1;
}
- if (!is_intobject(res)) {
- DECREF(res);
+ if (!PyInt_Check(res)) {
+ Py_DECREF(res);
return (v < w) ? -1 : 1;
}
- c = getintvalue(res);
- DECREF(res);
+ c = PyInt_AsLong(res);
+ Py_DECREF(res);
return (c < 0) ? -1 : (c > 0) ? 1 : 0;
}
if ((tp = v->ob_type) != w->ob_type) {
if (tp->tp_as_number != NULL &&
w->ob_type->tp_as_number != NULL) {
- if (coerce(&v, &w) != 0) {
- err_clear();
+ if (PyNumber_Coerce(&v, &w) != 0) {
+ PyErr_Clear();
/* XXX Should report the error,
XXX but the interface isn't there... */
}
else {
int cmp = (*v->ob_type->tp_compare)(v, w);
- DECREF(v);
- DECREF(w);
+ Py_DECREF(v);
+ Py_DECREF(w);
return cmp;
}
}
@@ -315,36 +316,36 @@
}
long
-hashobject(v)
- object *v;
+PyObject_Hash(v)
+ PyObject *v;
{
- typeobject *tp = v->ob_type;
+ PyTypeObject *tp = v->ob_type;
if (tp->tp_hash != NULL)
return (*tp->tp_hash)(v);
if (tp->tp_compare == NULL)
return (long) v; /* Use address as hash value */
/* If there's a cmp but no hash defined, the object can't be hashed */
- err_setstr(TypeError, "unhashable type");
+ PyErr_SetString(PyExc_TypeError, "unhashable type");
return -1;
}
-object *
-getattr(v, name)
- object *v;
+PyObject *
+PyObject_GetAttrString(v, name)
+ PyObject *v;
char *name;
{
if (v->ob_type->tp_getattro != NULL) {
- object *w, *res;
+ PyObject *w, *res;
w = PyString_InternFromString(name);
if (w == NULL)
return NULL;
res = (*v->ob_type->tp_getattro)(v, w);
- XDECREF(w);
+ Py_XDECREF(w);
return res;
}
if (v->ob_type->tp_getattr == NULL) {
- err_setstr(AttributeError, "attribute-less object");
+ PyErr_SetString(PyExc_AttributeError, "attribute-less object");
return NULL;
}
else {
@@ -353,42 +354,42 @@
}
int
-hasattr(v, name)
- object *v;
+PyObject_HasAttrString(v, name)
+ PyObject *v;
char *name;
{
- object *res = getattr(v, name);
+ PyObject *res = PyObject_GetAttrString(v, name);
if (res != NULL) {
- DECREF(res);
+ Py_DECREF(res);
return 1;
}
- err_clear();
+ PyErr_Clear();
return 0;
}
int
-setattr(v, name, w)
- object *v;
+PyObject_SetAttrString(v, name, w)
+ PyObject *v;
char *name;
- object *w;
+ PyObject *w;
{
if (v->ob_type->tp_setattro != NULL) {
- object *s;
+ PyObject *s;
int res;
s = PyString_InternFromString(name);
if (s == NULL)
return -1;
res = (*v->ob_type->tp_setattro)(v, s, w);
- XDECREF(s);
+ Py_XDECREF(s);
return res;
}
if (v->ob_type->tp_setattr == NULL) {
if (v->ob_type->tp_getattr == NULL)
- err_setstr(TypeError,
+ PyErr_SetString(PyExc_TypeError,
"attribute-less object (assign or del)");
else
- err_setstr(TypeError,
+ PyErr_SetString(PyExc_TypeError,
"object has read-only attributes");
return -1;
}
@@ -401,11 +402,11 @@
Return -1 if an error occurred */
int
-testbool(v)
- object *v;
+PyObject_IsTrue(v)
+ PyObject *v;
{
int res;
- if (v == None)
+ if (v == Py_None)
res = 0;
else if (v->ob_type->tp_as_number != NULL)
res = (*v->ob_type->tp_as_number->nb_nonzero)(v);
@@ -427,16 +428,16 @@
*/
int
-coerce(pv, pw)
- object **pv, **pw;
+PyNumber_Coerce(pv, pw)
+ PyObject **pv, **pw;
{
- register object *v = *pv;
- register object *w = *pw;
+ register PyObject *v = *pv;
+ register PyObject *w = *pw;
int res;
- if (v->ob_type == w->ob_type && !is_instanceobject(v)) {
- INCREF(v);
- INCREF(w);
+ if (v->ob_type == w->ob_type && !PyInstance_Check(v)) {
+ Py_INCREF(v);
+ Py_INCREF(w);
return 0;
}
if (v->ob_type->tp_as_number && v->ob_type->tp_as_number->nb_coerce) {
@@ -449,7 +450,7 @@
if (res <= 0)
return res;
}
- err_setstr(TypeError, "number coercion failed");
+ PyErr_SetString(PyExc_TypeError, "number coercion failed");
return -1;
}
@@ -457,26 +458,26 @@
/* Test whether an object can be called */
int
-callable(x)
- object *x;
+PyCallable_Check(x)
+ PyObject *x;
{
if (x == NULL)
return 0;
if (x->ob_type->tp_call != NULL ||
- is_funcobject(x) ||
- is_instancemethodobject(x) ||
- is_methodobject(x) ||
- is_classobject(x))
+ PyFunction_Check(x) ||
+ PyMethod_Check(x) ||
+ PyCFunction_Check(x) ||
+ PyClass_Check(x))
return 1;
- if (is_instanceobject(x)) {
- object *call = getattr(x, "__call__");
+ if (PyInstance_Check(x)) {
+ PyObject *call = PyObject_GetAttrString(x, "__call__");
if (call == NULL) {
- err_clear();
+ PyErr_Clear();
return 0;
}
/* Could test recursively but don't, for fear of endless
recursion if some joker sets self.__call__ = self */
- DECREF(call);
+ Py_DECREF(call);
return 1;
}
return 0;
@@ -490,15 +491,15 @@
*/
/* ARGSUSED */
-static object *
+static PyObject *
none_repr(op)
- object *op;
+ PyObject *op;
{
- return newstringobject("None");
+ return PyString_FromString("None");
}
-static typeobject Notype = {
- OB_HEAD_INIT(&Typetype)
+static PyTypeObject PyNothing_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
0,
"None",
0,
@@ -515,20 +516,20 @@
0, /*tp_hash */
};
-object NoObject = {
- OB_HEAD_INIT(&Notype)
+PyObject _Py_NoneStruct = {
+ PyObject_HEAD_INIT(&PyNothing_Type)
};
#ifdef Py_TRACE_REFS
-static object refchain = {&refchain, &refchain};
+static PyObject refchain = {&refchain, &refchain};
void
-NEWREF(op)
- object *op;
+_Py_NewReference(op)
+ PyObject *op;
{
- ref_total++;
+ _Py_RefTotal++;
op->ob_refcnt = 1;
op->_ob_next = refchain._ob_next;
op->_ob_prev = &refchain;
@@ -540,22 +541,22 @@
}
void
-UNREF(op)
- register object *op;
+_Py_ForgetReference(op)
+ register PyObject *op;
{
- register object *p;
+ register PyObject *p;
if (op->ob_refcnt < 0)
- fatal("UNREF negative refcnt");
+ Py_FatalError("UNREF negative refcnt");
if (op == &refchain ||
op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op)
- fatal("UNREF invalid object");
+ Py_FatalError("UNREF invalid object");
#ifdef SLOW_UNREF_CHECK
for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) {
if (p == op)
break;
}
if (p == &refchain) /* Not found */
- fatal("UNREF unknown object");
+ Py_FatalError("UNREF unknown object");
#endif
op->_ob_next->_ob_prev = op->_ob_prev;
op->_ob_prev->_ob_next = op->_ob_next;
@@ -566,11 +567,11 @@
}
void
-DELREF(op)
- object *op;
+_Py_Dealloc(op)
+ PyObject *op;
{
destructor dealloc = op->ob_type->tp_dealloc;
- UNREF(op);
+ _Py_ForgetReference(op);
op->ob_type = NULL;
(*dealloc)(op);
}
@@ -579,14 +580,14 @@
_Py_PrintReferences(fp)
FILE *fp;
{
- object *op;
+ PyObject *op;
fprintf(fp, "Remaining objects (except strings referenced once):\n");
for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
- if (op->ob_refcnt == 1 && is_stringobject(op))
+ if (op->ob_refcnt == 1 && PyString_Check(op))
continue; /* Will be printed elsewhere */
fprintf(fp, "[%d] ", op->ob_refcnt);
- if (printobject(op, fp, 0) != 0)
- err_clear();
+ if (PyObject_Print(op, fp, 0) != 0)
+ PyErr_Clear();
putc('\n', fp);
}
}
@@ -630,4 +631,4 @@
/* Hack to force loading of abstract.o */
-int (*_Py_abstract_hack) FPROTO((PyObject *)) = &PyObject_Length;
+int (*_Py_abstract_hack) Py_FPROTO((PyObject *)) = &PyObject_Length;