Renamed but not well tested.

Modules/cdmodule.c

@@ -34,117 +34,113 @@ PERFORMANCE OF THIS SOFTWARE.
 
 #include <sys/types.h>
 #include <cdaudio.h>
-/* #include <sigfpe.h> */
-#include "allobjects.h"
-#include "import.h"
-#include "modsupport.h"
-#include "ceval.h"
+#include "Python.h"
 
 #define NCALLBACKS	8
 
 typedef struct {
-	OB_HEAD
+	PyObject_HEAD
 	CDPLAYER *ob_cdplayer;
 } cdplayerobject;
 
-static object *CdError;		/* exception cd.error */
+static PyObject *CdError;		/* exception cd.error */
 
-static object *
+static PyObject *
 CD_allowremoval(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	CDallowremoval(self->ob_cdplayer);
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_preventremoval(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	CDpreventremoval(self->ob_cdplayer);
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_bestreadsize(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
-	return newintobject((long) CDbestreadsize(self->ob_cdplayer));
+	return PyInt_FromLong((long) CDbestreadsize(self->ob_cdplayer));
 }
 
-static object *
+static PyObject *
 CD_close(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	if (!CDclose(self->ob_cdplayer)) {
-		err_errno(CdError); /* XXX - ??? */
+		PyErr_SetFromErrno(CdError); /* XXX - ??? */
 		return NULL;
 	}
 	self->ob_cdplayer = NULL;
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_eject(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	CDSTATUS status;
 
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	if (!CDeject(self->ob_cdplayer)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "eject failed");
+			PyErr_SetString(CdError, "eject failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static object *
+static PyObject *
 CD_getstatus(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	CDSTATUS status;
 
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	if (!CDgetstatus(self->ob_cdplayer, &status)) {
-		err_errno(CdError); /* XXX - ??? */
+		PyErr_SetFromErrno(CdError); /* XXX - ??? */
 		return NULL;
 	}
 
-	return mkvalue("(ii(iii)(iii)(iii)iiii)", status.state,
+	return Py_BuildValue("(ii(iii)(iii)(iii)iiii)", status.state,
 		       status.track, status.min, status.sec, status.frame,
 		       status.abs_min, status.abs_sec, status.abs_frame,
 		       status.total_min, status.total_sec, status.total_frame,
@@ -152,294 +148,296 @@ CD_getstatus(self, args)
 		       status.cur_block);
 }
 	
-static object *
+static PyObject *
 CD_gettrackinfo(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int track;
 	CDTRACKINFO info;
 	CDSTATUS status;
 
-	if (!newgetargs(args, "i", &track))
+	if (!PyArg_ParseTuple(args, "i", &track))
 		return NULL;
 
 	if (!CDgettrackinfo(self->ob_cdplayer, track, &info)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "gettrackinfo failed");
+			PyErr_SetString(CdError, "gettrackinfo failed");
 		return NULL;
 	}
 
-	return mkvalue("((iii)(iii))",
+	return Py_BuildValue("((iii)(iii))",
 		       info.start_min, info.start_sec, info.start_frame,
 		       info.total_min, info.total_sec, info.total_frame);
 }
 	
-static object *
+static PyObject *
 CD_msftoblock(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int min, sec, frame;
 
-	if (!newgetargs(args, "iii", &min, &sec, &frame))
+	if (!PyArg_ParseTuple(args, "iii", &min, &sec, &frame))
 		return NULL;
 
-	return newintobject((long) CDmsftoblock(self->ob_cdplayer,
+	return PyInt_FromLong((long) CDmsftoblock(self->ob_cdplayer,
 						min, sec, frame));
 }
 	
-static object *
+static PyObject *
 CD_play(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int start, play;
 	CDSTATUS status;
 
-	if (!newgetargs(args, "ii", &start, &play))
+	if (!PyArg_ParseTuple(args, "ii", &start, &play))
 		return NULL;
 
 	if (!CDplay(self->ob_cdplayer, start, play)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "play failed");
+			PyErr_SetString(CdError, "play failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static object *
+static PyObject *
 CD_playabs(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int min, sec, frame, play;
 	CDSTATUS status;
 
-	if (!newgetargs(args, "iiii", &min, &sec, &frame, &play))
+	if (!PyArg_ParseTuple(args, "iiii", &min, &sec, &frame, &play))
 		return NULL;
 
 	if (!CDplayabs(self->ob_cdplayer, min, sec, frame, play)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "playabs failed");
+			PyErr_SetString(CdError, "playabs failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static object *
+static PyObject *
 CD_playtrack(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int start, play;
 	CDSTATUS status;
 
-	if (!newgetargs(args, "ii", &start, &play))
+	if (!PyArg_ParseTuple(args, "ii", &start, &play))
 		return NULL;
 
 	if (!CDplaytrack(self->ob_cdplayer, start, play)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "playtrack failed");
+			PyErr_SetString(CdError, "playtrack failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static object *
+static PyObject *
 CD_playtrackabs(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int track, min, sec, frame, play;
 	CDSTATUS status;
 
-	if (!newgetargs(args, "iiiii", &track, &min, &sec, &frame, &play))
+	if (!PyArg_ParseTuple(args, "iiiii", &track, &min, &sec,
+			      &frame, &play))
 		return NULL;
 
 	if (!CDplaytrackabs(self->ob_cdplayer, track, min, sec, frame, play)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "playtrackabs failed");
+			PyErr_SetString(CdError, "playtrackabs failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static object *
+static PyObject *
 CD_readda(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int numframes, n;
-	object *result;
+	PyObject *result;
 
-	if (!newgetargs(args, "i", &numframes))
+	if (!PyArg_ParseTuple(args, "i", &numframes))
 		return NULL;
 
-	result = newsizedstringobject(NULL, numframes * sizeof(CDFRAME));
+	result = PyString_FromStringAndSize(NULL, numframes * sizeof(CDFRAME));
 	if (result == NULL)
 		return NULL;
 
-	n = CDreadda(self->ob_cdplayer, (CDFRAME *) getstringvalue(result), numframes);
+	n = CDreadda(self->ob_cdplayer,
+		       (CDFRAME *) PyString_AsString(result), numframes);
 	if (n == -1) {
-		DECREF(result);
-		err_errno(CdError);
+		Py_DECREF(result);
+		PyErr_SetFromErrno(CdError);
 		return NULL;
 	}
 	if (n < numframes)
-		if (resizestring(&result, n * sizeof(CDFRAME)))
+		if (_PyString_Resize(&result, n * sizeof(CDFRAME)))
 			return NULL;
 
 	return result;
 }
 
-static object *
+static PyObject *
 CD_seek(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int min, sec, frame;
-	long block;
+	long PyTryBlock;
 
-	if (!newgetargs(args, "iii", &min, &sec, &frame))
+	if (!PyArg_ParseTuple(args, "iii", &min, &sec, &frame))
 		return NULL;
 
-	block = CDseek(self->ob_cdplayer, min, sec, frame);
-	if (block == -1) {
-		err_errno(CdError);
+	PyTryBlock = CDseek(self->ob_cdplayer, min, sec, frame);
+	if (PyTryBlock == -1) {
+		PyErr_SetFromErrno(CdError);
 		return NULL;
 	}
 
-	return newintobject(block);
+	return PyInt_FromLong(PyTryBlock);
 }
 	
-static object *
+static PyObject *
 CD_seektrack(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	int track;
-	long block;
+	long PyTryBlock;
 
-	if (!newgetargs(args, "i", &track))
+	if (!PyArg_ParseTuple(args, "i", &track))
 		return NULL;
 
-	block = CDseektrack(self->ob_cdplayer, track);
-	if (block == -1) {
-		err_errno(CdError);
+	PyTryBlock = CDseektrack(self->ob_cdplayer, track);
+	if (PyTryBlock == -1) {
+		PyErr_SetFromErrno(CdError);
 		return NULL;
 	}
 
-	return newintobject(block);
+	return PyInt_FromLong(PyTryBlock);
 }
 	
-static object *
+static PyObject *
 CD_seekblock(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
-	unsigned long block;
+	unsigned long PyTryBlock;
 
-	if (!newgetargs(args, "l", &block))
+	if (!PyArg_ParseTuple(args, "l", &PyTryBlock))
 		return NULL;
 
-	block = CDseekblock(self->ob_cdplayer, block);
-	if (block == (unsigned long) -1) {
-		err_errno(CdError);
+	PyTryBlock = CDseekblock(self->ob_cdplayer, PyTryBlock);
+	if (PyTryBlock == (unsigned long) -1) {
+		PyErr_SetFromErrno(CdError);
 		return NULL;
 	}
 
-	return newintobject(block);
+	return PyInt_FromLong(PyTryBlock);
 }
 	
-static object *
+static PyObject *
 CD_stop(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	CDSTATUS status;
 
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	if (!CDstop(self->ob_cdplayer)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "stop failed");
+			PyErr_SetString(CdError, "stop failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static object *
+static PyObject *
 CD_togglepause(self, args)
 	cdplayerobject *self;
-	object *args;
+	PyObject *args;
 {
 	CDSTATUS status;
 
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	if (!CDtogglepause(self->ob_cdplayer)) {
 		if (CDgetstatus(self->ob_cdplayer, &status) &&
 		    status.state == CD_NODISC)
-			err_setstr(CdError, "no disc in player");
+			PyErr_SetString(CdError, "no disc in player");
 		else
-			err_setstr(CdError, "togglepause failed");
+			PyErr_SetString(CdError, "togglepause failed");
 		return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 	
-static struct methodlist cdplayer_methods[] = {
-	{"allowremoval",	(method)CD_allowremoval,	1},
-	{"bestreadsize",	(method)CD_bestreadsize,	1},
-	{"close",		(method)CD_close,		1},
-	{"eject",		(method)CD_eject,		1},
-	{"getstatus",		(method)CD_getstatus,		1},
-	{"gettrackinfo",	(method)CD_gettrackinfo,	1},
-	{"msftoblock",		(method)CD_msftoblock,		1},
-	{"play",		(method)CD_play,		1},
-	{"playabs",		(method)CD_playabs,		1},
-	{"playtrack",		(method)CD_playtrack,		1},
-	{"playtrackabs",	(method)CD_playtrackabs,	1},
-	{"preventremoval",	(method)CD_preventremoval,	1},
-	{"readda",		(method)CD_readda,		1},
-	{"seek",		(method)CD_seek,		1},
-	{"seekblock",		(method)CD_seekblock,		1},
-	{"seektrack",		(method)CD_seektrack,		1},
-	{"stop",		(method)CD_stop,		1},
-	{"togglepause",		(method)CD_togglepause,		1},
+static PyMethodDef cdplayer_methods[] = {
+	{"allowremoval",	(PyCFunction)CD_allowremoval,	1},
+	{"bestreadsize",	(PyCFunction)CD_bestreadsize,	1},
+	{"close",		(PyCFunction)CD_close,		1},
+	{"eject",		(PyCFunction)CD_eject,		1},
+	{"getstatus",		(PyCFunction)CD_getstatus,		1},
+	{"gettrackinfo",	(PyCFunction)CD_gettrackinfo,	1},
+	{"msftoblock",		(PyCFunction)CD_msftoblock,		1},
+	{"play",		(PyCFunction)CD_play,		1},
+	{"playabs",		(PyCFunction)CD_playabs,		1},
+	{"playtrack",		(PyCFunction)CD_playtrack,		1},
+	{"playtrackabs",	(PyCFunction)CD_playtrackabs,	1},
+	{"preventremoval",	(PyCFunction)CD_preventremoval,	1},
+	{"readda",		(PyCFunction)CD_readda,		1},
+	{"seek",		(PyCFunction)CD_seek,		1},
+	{"seekblock",		(PyCFunction)CD_seekblock,		1},
+	{"seektrack",		(PyCFunction)CD_seektrack,		1},
+	{"stop",		(PyCFunction)CD_stop,		1},
+	{"togglepause",		(PyCFunction)CD_togglepause,   	1},
 	{NULL,			NULL} 		/* sentinel */
 };
 
@@ -449,23 +447,23 @@ cdplayer_dealloc(self)
 {
 	if (self->ob_cdplayer != NULL)
 		CDclose(self->ob_cdplayer);
-	DEL(self);
+	PyMem_DEL(self);
 }
 
-static object *
+static PyObject *
 cdplayer_getattr(self, name)
 	cdplayerobject *self;
 	char *name;
 {
 	if (self->ob_cdplayer == NULL) {
-		err_setstr(RuntimeError, "no player active");
+		PyErr_SetString(PyExc_RuntimeError, "no player active");
 		return NULL;
 	}
-	return findmethod(cdplayer_methods, (object *)self, name);
+	return Py_FindMethod(cdplayer_methods, (PyObject *)self, name);
 }
 
-typeobject CdPlayertype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject CdPlayertype = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,			/*ob_size*/
 	"cdplayer",		/*tp_name*/
 	sizeof(cdplayerobject),	/*tp_size*/
@@ -479,22 +477,22 @@ typeobject CdPlayertype = {
 	0,			/*tp_repr*/
 };
 
-static object *
+static PyObject *
 newcdplayerobject(cdp)
 	CDPLAYER *cdp;
 {
 	cdplayerobject *p;
 
-	p = NEWOBJ(cdplayerobject, &CdPlayertype);
+	p = PyObject_NEW(cdplayerobject, &CdPlayertype);
 	if (p == NULL)
 		return NULL;
 	p->ob_cdplayer = cdp;
-	return (object *) p;
+	return (PyObject *) p;
 }
 
-static object *
+static PyObject *
 CD_open(self, args)
-	object *self, *args;
+	PyObject *self, *args;
 {
 	char *dev, *direction;
 	CDPLAYER *cdp;
@@ -505,12 +503,12 @@ CD_open(self, args)
 	 */
 	dev = NULL;
 	direction = "r";
-	if (!newgetargs(args, "|zs", &dev, &direction))
+	if (!PyArg_ParseTuple(args, "|zs", &dev, &direction))
 		return NULL;
 
 	cdp = CDopen(dev, direction);
 	if (cdp == NULL) {
-		err_errno(CdError);
+		PyErr_SetFromErrno(CdError);
 		return NULL;
 	}
 
@@ -518,11 +516,11 @@ CD_open(self, args)
 }
 
 typedef struct {
-	OB_HEAD
+	PyObject_HEAD
 	CDPARSER *ob_cdparser;
 	struct {
-		object *ob_cdcallback;
-		object *ob_cdcallbackarg;
+		PyObject *ob_cdcallback;
+		PyObject *ob_cdcallbackarg;
 	} ob_cdcallbacks[NCALLBACKS];
 } cdparserobject;
 
@@ -532,45 +530,45 @@ CD_callback(arg, type, data)
 	CDDATATYPES type;
 	void *data;
 {
-	object *result, *args, *v = NULL;
+	PyObject *result, *args, *v = NULL;
 	char *p;
 	int i;
 	cdparserobject *self;
 
 	self = (cdparserobject *) arg;
-	args = newtupleobject(3);
+	args = PyTuple_New(3);
 	if (args == NULL)
 		return;
-	INCREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
-	settupleitem(args, 0, self->ob_cdcallbacks[type].ob_cdcallbackarg);
-	settupleitem(args, 1, newintobject((long) type));
+	Py_INCREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	PyTuple_SetItem(args, 0, self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	PyTuple_SetItem(args, 1, PyInt_FromLong((long) type));
 	switch (type) {
 	case cd_audio:
-		v = newsizedstringobject(data, CDDA_DATASIZE);
+		v = PyString_FromStringAndSize(data, CDDA_DATASIZE);
 		break;
 	case cd_pnum:
 	case cd_index:
-		v = newintobject(((CDPROGNUM *) data)->value);
+		v = PyInt_FromLong(((CDPROGNUM *) data)->value);
 		break;
 	case cd_ptime:
 	case cd_atime:
 #define ptr ((struct cdtimecode *) data)
-		v = mkvalue("(iii)",
+		v = Py_BuildValue("(iii)",
 			    ptr->mhi * 10 + ptr->mlo,
 			    ptr->shi * 10 + ptr->slo,
 			    ptr->fhi * 10 + ptr->flo);
 #undef ptr
 		break;
 	case cd_catalog:
-		v = newsizedstringobject(NULL, 13);
-		p = getstringvalue(v);
+		v = PyString_FromStringAndSize(NULL, 13);
+		p = PyString_AsString(v);
 		for (i = 0; i < 13; i++)
 			*p++ = ((char *) data)[i] + '0';
 		break;
 	case cd_ident:
 #define ptr ((struct cdident *) data)
-		v = newsizedstringobject(NULL, 12);
-		p = getstringvalue(v);
+		v = PyString_FromStringAndSize(NULL, 12);
+		p = PyString_AsString(v);
 		CDsbtoa(p, ptr->country, 2);
 		p += 2;
 		CDsbtoa(p, ptr->owner, 3);
@@ -585,28 +583,29 @@ CD_callback(arg, type, data)
 #undef ptr
 		break;
 	case cd_control:
-		v = newintobject((long) *((unchar *) data));
+		v = PyInt_FromLong((long) *((unchar *) data));
 		break;
 	}
-	settupleitem(args, 2, v);
-	if (err_occurred()) {
-		DECREF(args);
+	PyTuple_SetItem(args, 2, v);
+	if (PyErr_Occurred()) {
+		Py_DECREF(args);
 		return;
 	}
 	
-	result = call_object(self->ob_cdcallbacks[type].ob_cdcallback, args);
-	DECREF(args);
-	XDECREF(result);
+	result = PyEval_CallObject(self->ob_cdcallbacks[type].ob_cdcallback,
+				   args);
+	Py_DECREF(args);
+	Py_XDECREF(result);
 }
 
-static object *
+static PyObject *
 CD_deleteparser(self, args)
 	cdparserobject *self;
-	object *args;
+	PyObject *args;
 {
 	int i;
 
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	CDdeleteparser(self->ob_cdparser);
@@ -614,30 +613,30 @@ CD_deleteparser(self, args)
 
 	/* no sense in keeping the callbacks, so remove them */
 	for (i = 0; i < NCALLBACKS; i++) {
-		XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
+		Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
 		self->ob_cdcallbacks[i].ob_cdcallback = NULL;
-		XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
+		Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
 		self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_parseframe(self, args)
 	cdparserobject *self;
-	object *args;
+	PyObject *args;
 {
 	char *cdfp;
 	int length;
 	CDFRAME *p;
 
-	if (!newgetargs(args, "s#", &cdfp, &length))
+	if (!PyArg_ParseTuple(args, "s#", &cdfp, &length))
 		return NULL;
 
 	if (length % sizeof(CDFRAME) != 0) {
-		err_setstr(TypeError, "bad length");
+		PyErr_SetString(PyExc_TypeError, "bad length");
 		return NULL;
 	}
 
@@ -646,102 +645,106 @@ CD_parseframe(self, args)
 		CDparseframe(self->ob_cdparser, p);
 		length -= sizeof(CDFRAME);
 		p++;
-		if (err_occurred())
+		if (PyErr_Occurred())
 			return NULL;
 	}
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_removecallback(self, args)
 	cdparserobject *self;
-	object *args;
+	PyObject *args;
 {
 	int type;
 
-	if (!newgetargs(args, "i", &type))
+	if (!PyArg_ParseTuple(args, "i", &type))
 		return NULL;
 
 	if (type < 0 || type >= NCALLBACKS) {
-		err_setstr(TypeError, "bad type");
+		PyErr_SetString(PyExc_TypeError, "bad type");
 		return NULL;
 	}
 
 	CDremovecallback(self->ob_cdparser, (CDDATATYPES) type);
 
-	XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
+	Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
 	self->ob_cdcallbacks[type].ob_cdcallback = NULL;
 
-	XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
 	self->ob_cdcallbacks[type].ob_cdcallbackarg = NULL;
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_resetparser(self, args)
 	cdparserobject *self;
-	object *args;
+	PyObject *args;
 {
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 
 	CDresetparser(self->ob_cdparser);
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static object *
+static PyObject *
 CD_addcallback(self, args)
 	cdparserobject *self;
-	object *args;
+	PyObject *args;
 {
 	int type;
-	object *func, *funcarg;
+	PyObject *func, *funcarg;
 
 	/* XXX - more work here */
-	if (!newgetargs(args, "iOO", &type, &func, &funcarg))
+	if (!PyArg_ParseTuple(args, "iOO", &type, &func, &funcarg))
 		return NULL;
 
 	if (type < 0 || type >= NCALLBACKS) {
-		err_setstr(TypeError, "argument out of range");
+		PyErr_SetString(PyExc_TypeError, "argument out of range");
 		return NULL;
 	}
 
 #ifdef CDsetcallback
-	CDaddcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback, (void *) self);
+	CDaddcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback,
+		      (void *) self);
 #else
-	CDsetcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback, (void *) self);
+	CDsetcallback(self->ob_cdparser, (CDDATATYPES) type, CD_callback,
+		      (void *) self);
 #endif
-	XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
-	INCREF(func);
+	Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallback);
+	Py_INCREF(func);
 	self->ob_cdcallbacks[type].ob_cdcallback = func;
-	XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
-	INCREF(funcarg);
+	Py_XDECREF(self->ob_cdcallbacks[type].ob_cdcallbackarg);
+	Py_INCREF(funcarg);
 	self->ob_cdcallbacks[type].ob_cdcallbackarg = funcarg;
 
 /*
 	if (type == cd_audio) {
 		sigfpe_[_UNDERFL].repls = _ZERO;
-		handle_sigfpes(_ON, _EN_UNDERFL, NULL, _ABORT_ON_ERROR, NULL);
+		handle_sigfpes(_ON, _EN_UNDERFL, NULL,
+		                        _ABORT_ON_ERROR, NULL);
 	}
 */
 
-	INCREF(None);
-	return None;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
-static struct methodlist cdparser_methods[] = {
-	{"addcallback",		(method)CD_addcallback,		1},
-	{"deleteparser",	(method)CD_deleteparser,	1},
-	{"parseframe",		(method)CD_parseframe,		1},
-	{"removecallback",	(method)CD_removecallback,	1},
-	{"resetparser",		(method)CD_resetparser,		1},
-	{"setcallback",		(method)CD_addcallback,		1}, /* backward compatibility */
+static PyMethodDef cdparser_methods[] = {
+	{"addcallback",		(PyCFunction)CD_addcallback,   	1},
+	{"deleteparser",	(PyCFunction)CD_deleteparser,	1},
+	{"parseframe",		(PyCFunction)CD_parseframe,	1},
+	{"removecallback",	(PyCFunction)CD_removecallback,	1},
+	{"resetparser",		(PyCFunction)CD_resetparser,	1},
+		                                /* backward compatibility */
+	{"setcallback",		(PyCFunction)CD_addcallback,   	1},
 	{NULL,			NULL} 		/* sentinel */
 };
 
@@ -752,30 +755,30 @@ cdparser_dealloc(self)
 	int i;
 
 	for (i = 0; i < NCALLBACKS; i++) {
-		XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
+		Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallback);
 		self->ob_cdcallbacks[i].ob_cdcallback = NULL;
-		XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
+		Py_XDECREF(self->ob_cdcallbacks[i].ob_cdcallbackarg);
 		self->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
 	}
 	CDdeleteparser(self->ob_cdparser);
-	DEL(self);
+	PyMem_DEL(self);
 }
 
-static object *
+static PyObject *
 cdparser_getattr(self, name)
 	cdparserobject *self;
 	char *name;
 {
 	if (self->ob_cdparser == NULL) {
-		err_setstr(RuntimeError, "no parser active");
+		PyErr_SetString(PyExc_RuntimeError, "no parser active");
 		return NULL;
 	}
 
-	return findmethod(cdparser_methods, (object *)self, name);
+	return Py_FindMethod(cdparser_methods, (PyObject *)self, name);
 }
 
-typeobject CdParsertype = {
-	OB_HEAD_INIT(&Typetype)
+PyTypeObject CdParsertype = {
+	PyObject_HEAD_INIT(&PyType_Type)
 	0,			/*ob_size*/
 	"cdparser",		/*tp_name*/
 	sizeof(cdparserobject),	/*tp_size*/
@@ -789,14 +792,14 @@ typeobject CdParsertype = {
 	0,			/*tp_repr*/
 };
 
-static object *
+static PyObject *
 newcdparserobject(cdp)
 	CDPARSER *cdp;
 {
 	cdparserobject *p;
 	int i;
 
-	p = NEWOBJ(cdparserobject, &CdParsertype);
+	p = PyObject_NEW(cdparserobject, &CdParsertype);
 	if (p == NULL)
 		return NULL;
 	p->ob_cdparser = cdp;
@@ -804,81 +807,83 @@ newcdparserobject(cdp)
 		p->ob_cdcallbacks[i].ob_cdcallback = NULL;
 		p->ob_cdcallbacks[i].ob_cdcallbackarg = NULL;
 	}
-	return (object *) p;
+	return (PyObject *) p;
 }
 
-static object *
+static PyObject *
 CD_createparser(self, args)
-	object *self, *args;
+	PyObject *self, *args;
 {
 	CDPARSER *cdp;
 
-	if (!newgetargs(args, ""))
+	if (!PyArg_ParseTuple(args, ""))
 		return NULL;
 	cdp = CDcreateparser();
 	if (cdp == NULL) {
-		err_setstr(CdError, "createparser failed");
+		PyErr_SetString(CdError, "createparser failed");
 		return NULL;
 	}
 
 	return newcdparserobject(cdp);
 }
 
-static object *
+static PyObject *
 CD_msftoframe(self, args)
-	object *self, *args;
+	PyObject *self, *args;
 {
 	int min, sec, frame;
 
-	if (!newgetargs(args, "iii", &min, &sec, &frame))
+	if (!PyArg_ParseTuple(args, "iii", &min, &sec, &frame))
 		return NULL;
 
-	return newintobject((long) CDmsftoframe(min, sec, frame));
+	return PyInt_FromLong((long) CDmsftoframe(min, sec, frame));
 }
 	
-static struct methodlist CD_methods[] = {
-	{"open",		(method)CD_open,		1},
-	{"createparser",	(method)CD_createparser,	1},
-	{"msftoframe",		(method)CD_msftoframe,		1},
+static PyMethodDef CD_methods[] = {
+	{"open",		(PyCFunction)CD_open,		1},
+	{"createparser",	(PyCFunction)CD_createparser,	1},
+	{"msftoframe",		(PyCFunction)CD_msftoframe,	1},
 	{NULL,		NULL}	/* Sentinel */
 };
 
 void
 initcd()
 {
-	object *m, *d;
+	PyObject *m, *d;
 
-	m = initmodule("cd", CD_methods);
-	d = getmoduledict(m);
+	m = Py_InitModule("cd", CD_methods);
+	d = PyModule_GetDict(m);
 
-	CdError = newstringobject("cd.error");
-	dictinsert(d, "error", CdError);
+	CdError = PyString_FromString("cd.error");
+	PyDict_SetItemString(d, "error", CdError);
 
 	/* Identifiers for the different types of callbacks from the parser */
-	dictinsert(d, "audio", newintobject((long) cd_audio));
-	dictinsert(d, "pnum", newintobject((long) cd_pnum));
-	dictinsert(d, "index", newintobject((long) cd_index));
-	dictinsert(d, "ptime", newintobject((long) cd_ptime));
-	dictinsert(d, "atime", newintobject((long) cd_atime));
-	dictinsert(d, "catalog", newintobject((long) cd_catalog));
-	dictinsert(d, "ident", newintobject((long) cd_ident));
-	dictinsert(d, "control", newintobject((long) cd_control));
+	PyDict_SetItemString(d, "audio", PyInt_FromLong((long) cd_audio));
+	PyDict_SetItemString(d, "pnum", PyInt_FromLong((long) cd_pnum));
+	PyDict_SetItemString(d, "index", PyInt_FromLong((long) cd_index));
+	PyDict_SetItemString(d, "ptime", PyInt_FromLong((long) cd_ptime));
+	PyDict_SetItemString(d, "atime", PyInt_FromLong((long) cd_atime));
+	PyDict_SetItemString(d, "catalog", PyInt_FromLong((long) cd_catalog));
+	PyDict_SetItemString(d, "ident", PyInt_FromLong((long) cd_ident));
+	PyDict_SetItemString(d, "control", PyInt_FromLong((long) cd_control));
 
 	/* Block size information for digital audio data */
-	dictinsert(d, "DATASIZE", newintobject((long) CDDA_DATASIZE));
-	dictinsert(d, "BLOCKSIZE", newintobject((long) CDDA_BLOCKSIZE));
+	PyDict_SetItemString(d, "DATASIZE",
+			   PyInt_FromLong((long) CDDA_DATASIZE));
+	PyDict_SetItemString(d, "BLOCKSIZE",
+			   PyInt_FromLong((long) CDDA_BLOCKSIZE));
 
 	/* Possible states for the cd player */
-	dictinsert(d, "ERROR", newintobject((long) CD_ERROR));
-	dictinsert(d, "NODISC", newintobject((long) CD_NODISC));
-	dictinsert(d, "READY", newintobject((long) CD_READY));
-	dictinsert(d, "PLAYING", newintobject((long) CD_PLAYING));
-	dictinsert(d, "PAUSED", newintobject((long) CD_PAUSED));
-	dictinsert(d, "STILL", newintobject((long) CD_STILL));
+	PyDict_SetItemString(d, "ERROR", PyInt_FromLong((long) CD_ERROR));
+	PyDict_SetItemString(d, "NODISC", PyInt_FromLong((long) CD_NODISC));
+	PyDict_SetItemString(d, "READY", PyInt_FromLong((long) CD_READY));
+	PyDict_SetItemString(d, "PLAYING", PyInt_FromLong((long) CD_PLAYING));
+	PyDict_SetItemString(d, "PAUSED", PyInt_FromLong((long) CD_PAUSED));
+	PyDict_SetItemString(d, "STILL", PyInt_FromLong((long) CD_STILL));
 #ifdef CD_CDROM			/* only newer versions of the library */
-	dictinsert(d, "CDROM", newintobject((long) CD_CDROM));
+	PyDict_SetItemString(d, "CDROM", PyInt_FromLong((long) CD_CDROM));
 #endif
 
-	if (err_occurred())
-		fatal("can't initialize module cd");
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module cd");
 }