#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,
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 */
};
{
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*/
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;
*/
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;
}
}
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;
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);
#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);
/* 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;
}
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 */
};
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*/
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;
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");
}
projects / python / commitdiff