/* ctbcm objects */
-#include "allobjects.h"
+#include "Python.h"
#include "macglue.h"
#define _CommToolboxTrap 0x8B
#define _UnimplementedOSTrap 0x9F
-extern object *PyErr_Mac(object *,int);
+extern PyObject *PyErr_Mac(PyObject *,int);
-static object *ErrorObject;
+static PyObject *ErrorObject;
typedef struct {
- OB_HEAD
+ PyObject_HEAD
ConnHandle hdl; /* The handle to the connection */
- object *callback; /* Python callback routine */
+ PyObject *callback; /* Python callback routine */
int has_callback; /* True if callback not None */
int err; /* Error to pass to the callback */
} ctbcmobject;
-staticforward typeobject ctbcmtype;
+staticforward PyTypeObject ctbcmtype;
#define is_ctbcmobject(v) ((v)->ob_type == &ctbcmtype)
initialized = 0;
if ( !TrapAvailable(_CommToolboxTrap, OSTrap) ) {
- err_setstr(ErrorObject, "CTB not available");
+ PyErr_SetString(ErrorObject, "CTB not available");
return 0;
}
if ( (err=InitCTBUtilities()) ) {
void *arg;
{
ctbcmobject *self = (ctbcmobject *)arg;
- object *args, *rv;
+ PyObject *args, *rv;
if ( !self->has_callback ) /* It could have been removed in the meantime */
return 0;
- args = mkvalue("(i)", self->err);
- rv = call_object(self->callback, args);
- DECREF(args);
+ args = Py_BuildValue("(i)", self->err);
+ rv = PyEval_CallObject(self->callback, args);
+ Py_DECREF(args);
if( rv == NULL )
return -1;
- DECREF(rv);
+ Py_DECREF(rv);
return 0;
}
static ctbcmobject *
newctbcmobject(arg)
- object *arg;
+ PyObject *arg;
{
ctbcmobject *self;
- self = NEWOBJ(ctbcmobject, &ctbcmtype);
+ self = PyObject_NEW(ctbcmobject, &ctbcmtype);
if (self == NULL)
return NULL;
self->hdl = NULL;
- INCREF(None);
- self->callback = None;
+ Py_INCREF(Py_None);
+ self->callback = Py_None;
self->has_callback = 0;
return self;
}
CMDispose(self->hdl);
self->hdl = NULL;
}
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
ctbcm_open(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
long timeout;
OSErr err;
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
- if (!getargs(args, "l", &timeout))
+ if (!PyArg_Parse(args, "l", &timeout))
return NULL;
if ( (err=CMOpen(self->hdl, self->has_callback, cb_upp, timeout)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_listen(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
long timeout;
OSErr err;
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
- if (!getargs(args, "l", &timeout))
+ if (!PyArg_Parse(args, "l", &timeout))
return NULL;
if ( (err=CMListen(self->hdl,self->has_callback, cb_upp, timeout)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_accept(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
int accept;
OSErr err;
- if (!getargs(args, "i", &accept))
+ if (!PyArg_Parse(args, "i", &accept))
return NULL;
if ( (err=CMAccept(self->hdl, accept)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_close(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
int now;
long timeout;
OSErr err;
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
- if (!getargs(args, "(li)", &timeout, &now))
+ if (!PyArg_Parse(args, "(li)", &timeout, &now))
return NULL;
if ( (err=CMClose(self->hdl, self->has_callback, cb_upp, timeout, now)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_read(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
long timeout, len;
int chan;
CMFlags flags;
OSErr err;
- object *rv;
+ PyObject *rv;
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
- if (!getargs(args, "(lil)", &len, &chan, &timeout))
+ if (!PyArg_Parse(args, "(lil)", &len, &chan, &timeout))
return NULL;
- if ((rv=newsizedstringobject(NULL, len)) == NULL)
+ if ((rv=PyString_FromStringAndSize(NULL, len)) == NULL)
return NULL;
- if ((err=CMRead(self->hdl, (Ptr)getstringvalue(rv), &len, (CMChannel)chan,
+ if ((err=CMRead(self->hdl, (Ptr)PyString_AsString(rv), &len, (CMChannel)chan,
self->has_callback, cb_upp, timeout, &flags)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- resizestring(&rv, len);
- return mkvalue("(Oi)", rv, (int)flags);
+ _PyString_Resize(&rv, len);
+ return Py_BuildValue("(Oi)", rv, (int)flags);
}
-static object *
+static PyObject *
ctbcm_write(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
long timeout, len;
int chan, ilen, flags;
char *buf;
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
- if (!getargs(args, "(s#ili)", &buf, &ilen, &chan, &timeout, &flags))
+ if (!PyArg_Parse(args, "(s#ili)", &buf, &ilen, &chan, &timeout, &flags))
return NULL;
len = ilen;
if ((err=CMWrite(self->hdl, (Ptr)buf, &len, (CMChannel)chan,
self->has_callback, cb_upp, timeout, (CMFlags)flags)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- return newintobject((int)len);
+ return PyInt_FromLong((int)len);
}
-static object *
+static PyObject *
ctbcm_status(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
CMBufferSizes sizes;
CMStatFlags flags;
OSErr err;
- object *rv;
+ PyObject *rv;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ((err=CMStatus(self->hdl, sizes, &flags)) < 0)
return PyErr_Mac(ErrorObject, (int)err);
- rv = mkvalue("(llllll)", sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5]);
+ rv = Py_BuildValue("(llllll)", sizes[0], sizes[1], sizes[2], sizes[3], sizes[4], sizes[5]);
if ( rv == NULL )
return NULL;
- return mkvalue("(Ol)", rv, (long)flags);
+ return Py_BuildValue("(Ol)", rv, (long)flags);
}
-static object *
+static PyObject *
ctbcm_getconfig(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
char *rv;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ((rv=(char *)CMGetConfig(self->hdl)) == NULL ) {
- err_setstr(ErrorObject, "CMGetConfig failed");
+ PyErr_SetString(ErrorObject, "CMGetConfig failed");
return NULL;
}
- return newstringobject(rv);
+ return PyString_FromString(rv);
}
-static object *
+static PyObject *
ctbcm_setconfig(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
char *cfg;
OSErr err;
- if (!getargs(args, "s", &cfg))
+ if (!PyArg_Parse(args, "s", &cfg))
return NULL;
if ((err=CMSetConfig(self->hdl, (Ptr)cfg)) < 0)
return PyErr_Mac(ErrorObject, err);
- return newintobject((int)err);
+ return PyInt_FromLong((int)err);
}
-static object *
+static PyObject *
ctbcm_choose(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
int rv;
Point pt;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
pt.v = 40;
pt.h = 40;
rv=CMChoose(&self->hdl, pt, (ConnectionChooseIdleUPP)0);
- return newintobject(rv);
+ return PyInt_FromLong(rv);
}
-static object *
+static PyObject *
ctbcm_idle(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
CMIdle(self->hdl);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_abort(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
CMAbort(self->hdl);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_reset(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
CMReset(self->hdl);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
ctbcm_break(self, args)
ctbcmobject *self;
- object *args;
+ PyObject *args;
{
long duration;
ConnectionCompletionUPP cb_upp = NewConnectionCompletionProc(ctbcm_ctbcallback);
- if (!getargs(args, "l", &duration))
+ if (!PyArg_Parse(args, "l", &duration))
return NULL;
CMBreak(self->hdl, duration,self->has_callback, cb_upp);
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static struct methodlist ctbcm_methods[] = {
- {"Open", (method)ctbcm_open},
- {"Close", (method)ctbcm_close},
- {"Read", (method)ctbcm_read},
- {"Write", (method)ctbcm_write},
- {"Status", (method)ctbcm_status},
- {"GetConfig", (method)ctbcm_getconfig},
- {"SetConfig", (method)ctbcm_setconfig},
- {"Choose", (method)ctbcm_choose},
- {"Idle", (method)ctbcm_idle},
- {"Listen", (method)ctbcm_listen},
- {"Accept", (method)ctbcm_accept},
- {"Abort", (method)ctbcm_abort},
- {"Reset", (method)ctbcm_reset},
- {"Break", (method)ctbcm_break},
+static struct PyMethodDef ctbcm_methods[] = {
+ {"Open", (PyCFunction)ctbcm_open},
+ {"Close", (PyCFunction)ctbcm_close},
+ {"Read", (PyCFunction)ctbcm_read},
+ {"Write", (PyCFunction)ctbcm_write},
+ {"Status", (PyCFunction)ctbcm_status},
+ {"GetConfig", (PyCFunction)ctbcm_getconfig},
+ {"SetConfig", (PyCFunction)ctbcm_setconfig},
+ {"Choose", (PyCFunction)ctbcm_choose},
+ {"Idle", (PyCFunction)ctbcm_idle},
+ {"Listen", (PyCFunction)ctbcm_listen},
+ {"Accept", (PyCFunction)ctbcm_accept},
+ {"Abort", (PyCFunction)ctbcm_abort},
+ {"Reset", (PyCFunction)ctbcm_reset},
+ {"Break", (PyCFunction)ctbcm_break},
{NULL, NULL} /* sentinel */
};
-static object *
+static PyObject *
ctbcm_getattr(self, name)
ctbcmobject *self;
char *name;
{
if ( strcmp(name, "callback") == 0 ) {
- INCREF(self->callback);
+ Py_INCREF(self->callback);
return self->callback;
}
- return findmethod(ctbcm_methods, (object *)self, name);
+ return Py_FindMethod(ctbcm_methods, (PyObject *)self, name);
}
static int
ctbcm_setattr(self, name, v)
ctbcmobject *self;
char *name;
- object *v;
+ PyObject *v;
{
if ( strcmp(name, "callback") != 0 ) {
- err_setstr(AttributeError, "ctbcm objects have callback attr only");
+ PyErr_SetString(PyExc_AttributeError, "ctbcm objects have callback attr only");
return -1;
}
if ( v == NULL ) {
- v = None;
+ v = Py_None;
}
- INCREF(v); /* XXXX Must I do this? */
+ Py_INCREF(v); /* XXXX Must I do this? */
self->callback = v;
- self->has_callback = (v != None);
+ self->has_callback = (v != Py_None);
return 0;
}
-statichere typeobject ctbcmtype = {
- OB_HEAD_INIT(&Typetype)
+statichere PyTypeObject ctbcmtype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"ctbcm", /*tp_name*/
sizeof(ctbcmobject), /*tp_basicsize*/
/* Function of no arguments returning new ctbcm object */
-static object *
+static PyObject *
ctb_cmnew(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
int strlen;
- object *sizes_obj;
+ PyObject *sizes_obj;
char *c_str;
unsigned char p_str[255];
CMBufferSizes sizes;
ConnHandle hdl;
ctbcmobject *rv;
- if (!getargs(args, "(s#O)", &c_str, &strlen, &sizes_obj))
+ if (!PyArg_Parse(args, "(s#O)", &c_str, &strlen, &sizes_obj))
return NULL;
strncpy((char *)p_str+1, c_str, strlen);
p_str[0] = strlen;
if (!initialize_ctb())
return NULL;
- if ( sizes_obj == None ) {
+ if ( sizes_obj == Py_None ) {
memset(sizes, '\0', sizeof sizes);
} else {
- if ( !getargs(sizes_obj, "(llllll)", &sizes[0], &sizes[1], &sizes[2],
+ if ( !PyArg_Parse(sizes_obj, "(llllll)", &sizes[0], &sizes[1], &sizes[2],
&sizes[3], &sizes[4], &sizes[5]))
return NULL;
}
return PyErr_Mac(ErrorObject, procid);
hdl = CMNew(procid, cmNoMenus|cmQuiet, sizes, 0, 0);
if ( hdl == NULL ) {
- err_setstr(ErrorObject, "CMNew failed");
+ PyErr_SetString(ErrorObject, "CMNew failed");
return NULL;
}
rv = newctbcmobject(args);
return NULL; /* XXXX Should dispose of hdl */
rv->hdl = hdl;
CMSetUserData(hdl, (long)rv);
- return (object *)rv;
+ return (PyObject *)rv;
}
-static object *
+static PyObject *
ctb_available(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int ok;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
ok = initialize_ctb();
- err_clear();
- return newintobject(ok);
+ PyErr_Clear();
+ return PyInt_FromLong(ok);
}
/* List of functions defined in the module */
-static struct methodlist ctb_methods[] = {
+static struct PyMethodDef ctb_methods[] = {
{"CMNew", ctb_cmnew},
{"available", ctb_available},
{NULL, NULL} /* sentinel */
void
initctb()
{
- object *m, *d, *o;
+ PyObject *m, *d, *o;
/* Create the module and add the functions */
- m = initmodule("ctb", ctb_methods);
+ m = Py_InitModule("ctb", ctb_methods);
/* Add some symbolic constants to the module */
- d = getmoduledict(m);
+ d = PyModule_GetDict(m);
-#define CMCONST(name, value) o = newintobject(value); dictinsert(d, name, o)
+#define CMCONST(name, value) o = PyInt_FromLong(value); PyDict_SetItemString(d, name, o)
CMCONST("cmData", 1);
CMCONST("cmCntl", 2);
CMCONST("cmStatusListenPend", 0x2000);
CMCONST("cmStatusIncomingCallPresent", 0x4000);
- ErrorObject = newstringobject("ctb.error");
- dictinsert(d, "error", ErrorObject);
+ ErrorObject = PyString_FromString("ctb.error");
+ PyDict_SetItemString(d, "error", ErrorObject);
/* Check for errors */
- if (err_occurred())
- fatal("can't initialize module ctb");
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module ctb");
}
/* Macintosh Gestalt interface */
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
#include <Types.h>
#include <GestaltEqu.h>
-static object *
+static PyObject *
gestalt_gestalt(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
OSErr iErr;
char *str;
int size;
OSType selector;
long response;
- if (!getargs(args, "s#", &str, &size))
+ if (!PyArg_Parse(args, "s#", &str, &size))
return NULL;
if (size != 4) {
- err_setstr(TypeError, "gestalt arg must be 4-char string");
+ PyErr_SetString(PyExc_TypeError, "gestalt arg must be 4-char string");
return NULL;
}
selector = *(OSType*)str;
if (iErr != 0) {
char buf[100];
sprintf(buf, "Gestalt error code %d", iErr);
- err_setstr(RuntimeError, buf);
+ PyErr_SetString(PyExc_RuntimeError, buf);
return NULL;
}
- return newintobject(response);
+ return PyInt_FromLong(response);
}
-static struct methodlist gestalt_methods[] = {
+static struct PyMethodDef gestalt_methods[] = {
{"gestalt", gestalt_gestalt},
{NULL, NULL} /* Sentinel */
};
void
initgestalt()
{
- initmodule("gestalt", gestalt_methods);
+ Py_InitModule("gestalt", gestalt_methods);
}
******************************************************************/
-#include "allobjects.h"
-#include "modsupport.h" /* For getargs() etc. */
+#include "Python.h"
#include "macglue.h"
#include <Memory.h>
#define FileFilterUPP FileFilterProcPtr
#endif
-static object *ErrorObject;
+static PyObject *ErrorObject;
/* ----------------------------------------------------- */
/* Declarations for objects of type Alias */
typedef struct {
- OB_HEAD
+ PyObject_HEAD
AliasHandle alias;
} mfsaobject;
-staticforward typeobject Mfsatype;
+staticforward PyTypeObject Mfsatype;
#define is_mfsaobject(v) ((v)->ob_type == &Mfsatype)
/* Declarations for objects of type FSSpec */
typedef struct {
- OB_HEAD
+ PyObject_HEAD
FSSpec fsspec;
} mfssobject;
-staticforward typeobject Mfsstype;
+staticforward PyTypeObject Mfsstype;
#define is_mfssobject(v) ((v)->ob_type == &Mfsstype)
/* Declarations for objects of type FInfo */
typedef struct {
- OB_HEAD
+ PyObject_HEAD
FInfo finfo;
} mfsiobject;
-staticforward typeobject Mfsitype;
+staticforward PyTypeObject Mfsitype;
#define is_mfsiobject(v) ((v)->ob_type == &Mfsitype)
/* ---------------------------------------------------------------- */
-static object *
+static PyObject *
mfsa_Resolve(self, args)
mfsaobject *self;
- object *args;
+ PyObject *args;
{
FSSpec from, *fromp, result;
Boolean changed;
OSErr err;
from.name[0] = 0;
- if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &from))
+ if (!PyArg_ParseTuple(args, "|O&", PyMac_GetFSSpec, &from))
return NULL;
if (from.name[0] )
fromp = &from;
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return mkvalue("(Oi)", newmfssobject(&result), (int)changed);
+ return Py_BuildValue("(Oi)", newmfssobject(&result), (int)changed);
}
-static object *
+static PyObject *
mfsa_GetInfo(self, args)
mfsaobject *self;
- object *args;
+ PyObject *args;
{
Str63 value;
int i;
OSErr err;
- if (!newgetargs(args, "i", &i))
+ if (!PyArg_ParseTuple(args, "i", &i))
return NULL;
err = GetAliasInfo(self->alias, (AliasInfoType)i, value);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return 0;
}
- return newsizedstringobject((char *)&value[1], value[0]);
+ return PyString_FromStringAndSize((char *)&value[1], value[0]);
}
-static object *
+static PyObject *
mfsa_Update(self, args)
mfsaobject *self;
- object *args;
+ PyObject *args;
{
FSSpec target, fromfile, *fromfilep;
OSErr err;
Boolean changed;
fromfile.name[0] = 0;
- if (!newgetargs(args, "O&|O&", PyMac_GetFSSpec, &target,
+ if (!PyArg_ParseTuple(args, "O&|O&", PyMac_GetFSSpec, &target,
PyMac_GetFSSpec, &fromfile))
return NULL;
if ( fromfile.name[0] )
PyErr_Mac(ErrorObject, err);
return 0;
}
- return mkvalue("i", (int)changed);
+ return Py_BuildValue("i", (int)changed);
}
-static struct methodlist mfsa_methods[] = {
- {"Resolve", (method)mfsa_Resolve, 1},
- {"GetInfo", (method)mfsa_GetInfo, 1},
- {"Update", (method)mfsa_Update, 1},
+static struct PyMethodDef mfsa_methods[] = {
+ {"Resolve", (PyCFunction)mfsa_Resolve, 1},
+ {"GetInfo", (PyCFunction)mfsa_GetInfo, 1},
+ {"Update", (PyCFunction)mfsa_Update, 1},
{NULL, NULL} /* sentinel */
};
/* ---------- */
-static object *
+static PyObject *
mfsa_getattr(self, name)
mfsaobject *self;
char *name;
HUnlock((Handle)self->alias);
return rv;
}
- return findmethod(mfsa_methods, (object *)self, name);
+ return Py_FindMethod(mfsa_methods, (PyObject *)self, name);
}
mfsaobject *
{
mfsaobject *self;
- self = NEWOBJ(mfsaobject, &Mfsatype);
+ self = PyObject_NEW(mfsaobject, &Mfsatype);
if (self == NULL)
return NULL;
self->alias = alias;
}
#endif
- DEL(self);
+ PyMem_DEL(self);
}
-statichere typeobject Mfsatype = {
- OB_HEAD_INIT(&Typetype)
+statichere PyTypeObject Mfsatype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"Alias", /*tp_name*/
sizeof(mfsaobject), /*tp_basicsize*/
/* ---------------------------------------------------------------- */
-static struct methodlist mfsi_methods[] = {
+static struct PyMethodDef mfsi_methods[] = {
{NULL, NULL} /* sentinel */
};
{
mfsiobject *self;
- self = NEWOBJ(mfsiobject, &Mfsitype);
+ self = PyObject_NEW(mfsiobject, &Mfsitype);
if (self == NULL)
return NULL;
memset((char *)&self->finfo, '\0', sizeof(self->finfo));
mfsi_dealloc(self)
mfsiobject *self;
{
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
mfsi_getattr(self, name)
mfsiobject *self;
char *name;
else if ( strcmp(name, "Fldr") == 0 )
return Py_BuildValue("i", (int)self->finfo.fdFldr);
else
- return findmethod(mfsi_methods, (object *)self, name);
+ return Py_FindMethod(mfsi_methods, (PyObject *)self, name);
}
mfsi_setattr(self, name, v)
mfsiobject *self;
char *name;
- object *v;
+ PyObject *v;
{
int rv;
int i;
if ( v == NULL ) {
- err_setstr(AttributeError, "Cannot delete attribute");
+ PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute");
return -1;
}
if ( strcmp(name, "Type") == 0 )
rv = PyArg_Parse(v, "i", &i);
self->finfo.fdFldr = (short)i;
} else {
- err_setstr(AttributeError, "No such attribute");
+ PyErr_SetString(PyExc_AttributeError, "No such attribute");
return -1;
}
if (rv)
}
-static typeobject Mfsitype = {
- OB_HEAD_INIT(&Typetype)
+static PyTypeObject Mfsitype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"FInfo object", /*tp_name*/
sizeof(mfsiobject), /*tp_basicsize*/
*/
FSSpec *
mfs_GetFSSpecFSSpec(self)
- object *self;
+ PyObject *self;
{
if ( is_mfssobject(self) )
return &((mfssobject *)self)->fsspec;
return error;
}
-static object *
+static PyObject *
mfss_as_pathname(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
char strbuf[257];
OSErr err;
- if (!newgetargs(args, ""))
+ if (!PyArg_ParseTuple(args, ""))
return NULL;
err = PyMac_GetFullPath(&self->fsspec, strbuf);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return newstringobject(strbuf);
+ return PyString_FromString(strbuf);
}
-static object *
+static PyObject *
mfss_as_tuple(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
- if (!newgetargs(args, ""))
+ if (!PyArg_ParseTuple(args, ""))
return NULL;
return Py_BuildValue("(iis#)", self->fsspec.vRefNum, self->fsspec.parID,
&self->fsspec.name[1], self->fsspec.name[0]);
}
-static object *
+static PyObject *
mfss_NewAlias(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
FSSpec src, *srcp;
OSErr err;
AliasHandle alias;
src.name[0] = 0;
- if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &src))
+ if (!PyArg_ParseTuple(args, "|O&", PyMac_GetFSSpec, &src))
return NULL;
if ( src.name[0] )
srcp = &src;
return NULL;
}
- return (object *)newmfsaobject(alias);
+ return (PyObject *)newmfsaobject(alias);
}
-static object *
+static PyObject *
mfss_NewAliasMinimal(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
AliasHandle alias;
- if (!newgetargs(args, ""))
+ if (!PyArg_ParseTuple(args, ""))
return NULL;
err = NewAliasMinimal(&self->fsspec, &alias);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return (object *)newmfsaobject(alias);
+ return (PyObject *)newmfsaobject(alias);
}
/* XXXX These routines should be replaced by a wrapper to the *FInfo routines */
-static object *
+static PyObject *
mfss_GetCreatorType(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
FInfo info;
- if (!newgetargs(args, ""))
+ if (!PyArg_ParseTuple(args, ""))
return NULL;
err = FSpGetFInfo(&self->fsspec, &info);
if ( err ) {
PyMac_BuildOSType, info.fdCreator, PyMac_BuildOSType, info.fdType);
}
-static object *
+static PyObject *
mfss_SetCreatorType(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
OSType creator, type;
FInfo info;
- if (!newgetargs(args, "O&O&", PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
+ if (!PyArg_ParseTuple(args, "O&O&", PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
return NULL;
err = FSpGetFInfo(&self->fsspec, &info);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mfss_GetFInfo(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
mfsiobject *fip;
- if (!newgetargs(args, ""))
+ if (!PyArg_ParseTuple(args, ""))
return NULL;
if ( (fip=newmfsiobject()) == NULL )
return NULL;
err = FSpGetFInfo(&self->fsspec, &fip->finfo);
if ( err ) {
PyErr_Mac(ErrorObject, err);
- DECREF(fip);
+ Py_DECREF(fip);
return NULL;
}
- return (object *)fip;
+ return (PyObject *)fip;
}
-static object *
+static PyObject *
mfss_SetFInfo(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
mfsiobject *fip;
- if (!newgetargs(args, "O!", &Mfsitype, &fip))
+ if (!PyArg_ParseTuple(args, "O!", &Mfsitype, &fip))
return NULL;
err = FSpSetFInfo(&self->fsspec, &fip->finfo);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mfss_GetDates(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
unsigned long crdat, mddat, bkdat;
- if (!newgetargs(args, ""))
+ if (!PyArg_ParseTuple(args, ""))
return NULL;
err = PyMac_GetFileDates(&self->fsspec, &crdat, &mddat, &bkdat);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return mkvalue("ddd", (double)crdat, (double)mddat, (double)bkdat);
+ return Py_BuildValue("ddd", (double)crdat, (double)mddat, (double)bkdat);
}
-static object *
+static PyObject *
mfss_SetDates(self, args)
mfssobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
double crdat, mddat, bkdat;
- if (!newgetargs(args, "ddd", &crdat, &mddat, &bkdat))
+ if (!PyArg_ParseTuple(args, "ddd", &crdat, &mddat, &bkdat))
return NULL;
err = PyMac_SetFileDates(&self->fsspec, (unsigned long)crdat,
(unsigned long)mddat, (unsigned long)bkdat);
PyErr_Mac(ErrorObject, err);
return NULL;
}
- INCREF(None);
- return None;
-}
-
-static struct methodlist mfss_methods[] = {
- {"as_pathname", (method)mfss_as_pathname, 1},
- {"as_tuple", (method)mfss_as_tuple, 1},
- {"NewAlias", (method)mfss_NewAlias, 1},
- {"NewAliasMinimal", (method)mfss_NewAliasMinimal, 1},
- {"GetCreatorType", (method)mfss_GetCreatorType, 1},
- {"SetCreatorType", (method)mfss_SetCreatorType, 1},
- {"GetFInfo", (method)mfss_GetFInfo, 1},
- {"SetFInfo", (method)mfss_SetFInfo, 1},
- {"GetDates", (method)mfss_GetDates, 1},
- {"SetDates", (method)mfss_SetDates, 1},
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static struct PyMethodDef mfss_methods[] = {
+ {"as_pathname", (PyCFunction)mfss_as_pathname, 1},
+ {"as_tuple", (PyCFunction)mfss_as_tuple, 1},
+ {"NewAlias", (PyCFunction)mfss_NewAlias, 1},
+ {"NewAliasMinimal", (PyCFunction)mfss_NewAliasMinimal, 1},
+ {"GetCreatorType", (PyCFunction)mfss_GetCreatorType, 1},
+ {"SetCreatorType", (PyCFunction)mfss_SetCreatorType, 1},
+ {"GetFInfo", (PyCFunction)mfss_GetFInfo, 1},
+ {"SetFInfo", (PyCFunction)mfss_SetFInfo, 1},
+ {"GetDates", (PyCFunction)mfss_GetDates, 1},
+ {"SetDates", (PyCFunction)mfss_SetDates, 1},
{NULL, NULL} /* sentinel */
};
/* ---------- */
-static object *
+static PyObject *
mfss_getattr(self, name)
mfssobject *self;
char *name;
{
if ( strcmp(name, "data") == 0)
return PyString_FromStringAndSize((char *)&self->fsspec, sizeof(FSSpec));
- return findmethod(mfss_methods, (object *)self, name);
+ return Py_FindMethod(mfss_methods, (PyObject *)self, name);
}
mfssobject *
{
mfssobject *self;
- self = NEWOBJ(mfssobject, &Mfsstype);
+ self = PyObject_NEW(mfssobject, &Mfsstype);
if (self == NULL)
return NULL;
self->fsspec = *fss;
mfss_dealloc(self)
mfssobject *self;
{
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
mfss_repr(self)
mfssobject *self;
{
self->fsspec.vRefNum,
self->fsspec.parID,
self->fsspec.name[0], self->fsspec.name+1);
- return newstringobject(buf);
+ return PyString_FromString(buf);
}
static int
return res;
}
-statichere typeobject Mfsstype = {
- OB_HEAD_INIT(&Typetype)
+statichere PyTypeObject Mfsstype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"FSSpec", /*tp_name*/
sizeof(mfssobject), /*tp_basicsize*/
/* End of code for FSSpec objects */
/* -------------------------------------------------------- */
-static object *
+static PyObject *
mfs_ResolveAliasFile(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
FSSpec fss;
Boolean chain = 1, isfolder, wasaliased;
OSErr err;
- if (!newgetargs(args, "O&|i", PyMac_GetFSSpec, &fss, &chain))
+ if (!PyArg_ParseTuple(args, "O&|i", PyMac_GetFSSpec, &fss, &chain))
return NULL;
err = ResolveAliasFile(&fss, chain, &isfolder, &wasaliased);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return mkvalue("Oii", newmfssobject(&fss), (int)isfolder, (int)wasaliased);
+ return Py_BuildValue("Oii", newmfssobject(&fss), (int)isfolder, (int)wasaliased);
}
-static object *
+static PyObject *
mfs_StandardGetFile(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
SFTypeList list;
short numtypes;
list[0] = list[1] = list[2] = list[3] = 0;
numtypes = 0;
- if (!newgetargs(args, "|O&O&O&O&", PyMac_GetOSType, &list[0],
+ if (!PyArg_ParseTuple(args, "|O&O&O&O&", PyMac_GetOSType, &list[0],
PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
PyMac_GetOSType, &list[3]) )
return NULL;
if ( numtypes == 0 )
numtypes = -1;
StandardGetFile((FileFilterUPP)0, numtypes, list, &reply);
- return mkvalue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
+ return Py_BuildValue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
}
-static object *
+static PyObject *
mfs_PromptGetFile(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
SFTypeList list;
short numtypes;
list[0] = list[1] = list[2] = list[3] = 0;
numtypes = 0;
- if (!newgetargs(args, "s|O&O&O&O&", &prompt, PyMac_GetOSType, &list[0],
+ if (!PyArg_ParseTuple(args, "s|O&O&O&O&", &prompt, PyMac_GetOSType, &list[0],
PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
PyMac_GetOSType, &list[3]) )
return NULL;
if ( numtypes == 0 )
numtypes = -1;
PyMac_PromptGetFile(numtypes, list, &reply, prompt);
- return mkvalue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
+ return Py_BuildValue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
}
-static object *
+static PyObject *
mfs_StandardPutFile(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
Str255 prompt, dft;
StandardFileReply reply;
dft[0] = 0;
- if (!newgetargs(args, "O&|O&", PyMac_GetStr255, &prompt, PyMac_GetStr255, &dft) )
+ if (!PyArg_ParseTuple(args, "O&|O&", PyMac_GetStr255, &prompt, PyMac_GetStr255, &dft) )
return NULL;
StandardPutFile(prompt, dft, &reply);
- return mkvalue("(Oi)",newmfssobject(&reply.sfFile), reply.sfGood);
+ return Py_BuildValue("(Oi)",newmfssobject(&reply.sfFile), reply.sfGood);
}
/*
** Set initial directory for file dialogs */
-static object *
+static PyObject *
mfs_SetFolder(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
FSSpec spec;
FSSpec ospec;
/* Go to working directory by default */
(void)FSMakeFSSpec(0, 0, "\p:placeholder", &spec);
- if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &spec))
+ if (!PyArg_ParseTuple(args, "|O&", PyMac_GetFSSpec, &spec))
return NULL;
/* Set standard-file working directory */
LMSetSFSaveDisk(-spec.vRefNum);
LMSetCurDirStore(spec.parID);
- return (object *)newmfssobject(&ospec);
+ return (PyObject *)newmfssobject(&ospec);
}
-static object *
+static PyObject *
mfs_FSSpec(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
FSSpec fss;
- if (!newgetargs(args, "O&", PyMac_GetFSSpec, &fss))
+ if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSSpec, &fss))
return NULL;
- return (object *)newmfssobject(&fss);
+ return (PyObject *)newmfssobject(&fss);
}
-static object *
+static PyObject *
mfs_RawFSSpec(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
FSSpec *fssp;
int size;
- if (!newgetargs(args, "s#", &fssp, &size))
+ if (!PyArg_ParseTuple(args, "s#", &fssp, &size))
return NULL;
if ( size != sizeof(FSSpec) ) {
PyErr_SetString(PyExc_TypeError, "Incorrect size for FSSpec record");
return NULL;
}
- return (object *)newmfssobject(fssp);
+ return (PyObject *)newmfssobject(fssp);
}
-static object *
+static PyObject *
mfs_RawAlias(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
char *dataptr;
Handle h;
int size;
- if (!newgetargs(args, "s#", &dataptr, &size))
+ if (!PyArg_ParseTuple(args, "s#", &dataptr, &size))
return NULL;
h = NewHandle(size);
if ( h == NULL ) {
HLock(h);
memcpy((char *)*h, dataptr, size);
HUnlock(h);
- return (object *)newmfsaobject((AliasHandle)h);
+ return (PyObject *)newmfsaobject((AliasHandle)h);
}
-static object *
+static PyObject *
mfs_GetDirectory(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
FSSpec fsdir;
int ok;
char *prompt = NULL;
- if (!newgetargs(args, "|s", &prompt) )
+ if (!PyArg_ParseTuple(args, "|s", &prompt) )
return NULL;
ok = PyMac_GetDirectory(&fsdir, prompt);
- return mkvalue("(Oi)", newmfssobject(&fsdir), ok);
+ return Py_BuildValue("(Oi)", newmfssobject(&fsdir), ok);
}
-static object *
+static PyObject *
mfs_FindFolder(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
OSErr err;
short where;
short refnum;
long dirid;
- if (!newgetargs(args, "hO&i", &where, PyMac_GetOSType, &which, &create) )
+ if (!PyArg_ParseTuple(args, "hO&i", &where, PyMac_GetOSType, &which, &create) )
return NULL;
err = FindFolder(where, which, (Boolean)create, &refnum, &dirid);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return mkvalue("(ii)", refnum, dirid);
+ return Py_BuildValue("(ii)", refnum, dirid);
}
-static object *
+static PyObject *
mfs_FindApplication(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
OSErr err;
OSType which;
FSSpec fss;
- if (!newgetargs(args, "O&", PyMac_GetOSType, &which) )
+ if (!PyArg_ParseTuple(args, "O&", PyMac_GetOSType, &which) )
return NULL;
err = FindApplicationFromCreator(which, &fss);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
- return (object *)newmfssobject(&fss);
+ return (PyObject *)newmfssobject(&fss);
}
-static object *
+static PyObject *
mfs_FInfo(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- return (object *)newmfsiobject();
+ return (PyObject *)newmfsiobject();
}
/* List of methods defined in the module */
-static struct methodlist mfs_methods[] = {
+static struct PyMethodDef mfs_methods[] = {
{"ResolveAliasFile", mfs_ResolveAliasFile, 1},
{"StandardGetFile", mfs_StandardGetFile, 1},
{"PromptGetFile", mfs_PromptGetFile, 1},
void
initmacfs()
{
- object *m, *d;
+ PyObject *m, *d;
/* Create the module and add the functions */
- m = initmodule("macfs", mfs_methods);
+ m = Py_InitModule("macfs", mfs_methods);
/* Add some symbolic constants to the module */
- d = getmoduledict(m);
- ErrorObject = newstringobject("macfs.error");
- dictinsert(d, "error", ErrorObject);
+ d = PyModule_GetDict(m);
+ ErrorObject = PyString_FromString("macfs.error");
+ PyDict_SetItemString(d, "error", ErrorObject);
/* XXXX Add constants here */
/* Check for errors */
- if (err_occurred())
- fatal("can't initialize module macfs");
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module macfs");
}
/* Mac module implementation */
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
#include "ceval.h"
#include <stdio.h>
#ifndef USE_GUSI
-int chdir PROTO((const char *path));
-int mkdir PROTO((const char *path, int mode));
-DIR * opendir PROTO((char *));
-void closedir PROTO((DIR *));
-struct dirent * readdir PROTO((DIR *));
-int rmdir PROTO((const char *path));
-int sync PROTO((void));
+int chdir Py_PROTO((const char *path));
+int mkdir Py_PROTO((const char *path, int mode));
+DIR * opendir Py_PROTO((char *));
+void closedir Py_PROTO((DIR *));
+struct dirent * readdir Py_PROTO((DIR *));
+int rmdir Py_PROTO((const char *path));
+int sync Py_PROTO((void));
#if defined(THINK_C) || defined(__SC__)
-int unlink PROTO((char *));
+int unlink Py_PROTO((char *));
#else
-int unlink PROTO((const char *));
+int unlink Py_PROTO((const char *));
#endif
#endif /* USE_GUSI */
-char *getwd PROTO((char *));
-char *getbootvol PROTO((void));
+char *getwd Py_PROTO((char *));
+char *getbootvol Py_PROTO((void));
-static object *MacError; /* Exception mac.error */
+static PyObject *MacError; /* Exception mac.error */
/* Set a MAC-specific error from errno, and return NULL */
-static object *
+static PyObject *
mac_error()
{
- return err_errno(MacError);
+ return PyErr_SetFromErrno(MacError);
}
/* MAC generic methods */
-static object *
+static PyObject *
mac_1str(args, func)
- object *args;
- int (*func) FPROTO((const char *));
+ PyObject *args;
+ int (*func) Py_FPROTO((const char *));
{
char *path1;
int res;
- if (!getargs(args, "s", &path1))
+ if (!PyArg_Parse(args, "s", &path1))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = (*func)(path1);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res < 0)
return mac_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mac_2str(args, func)
- object *args;
- int (*func) FPROTO((const char *, const char *));
+ PyObject *args;
+ int (*func) Py_FPROTO((const char *, const char *));
{
char *path1, *path2;
int res;
- if (!getargs(args, "(ss)", &path1, &path2))
+ if (!PyArg_Parse(args, "(ss)", &path1, &path2))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = (*func)(path1, path2);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res < 0)
return mac_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mac_strint(args, func)
- object *args;
- int (*func) FPROTO((const char *, int));
+ PyObject *args;
+ int (*func) Py_FPROTO((const char *, int));
{
char *path;
int i;
int res;
- if (!getargs(args, "(si)", &path, &i))
+ if (!PyArg_Parse(args, "(si)", &path, &i))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = (*func)(path, i);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res < 0)
return mac_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mac_chdir(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
#ifdef USE_GUSI
- object *rv;
+ PyObject *rv;
/* Change MacOS's idea of wd too */
rv = mac_1str(args, chdir);
}
-static object *
+static PyObject *
mac_close(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int fd, res;
- if (!getargs(args, "i", &fd))
+ if (!PyArg_Parse(args, "i", &fd))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = close(fd);
- END_SAVE
+ Py_END_ALLOW_THREADS
#ifndef USE_GUSI
/* GUSI gives surious errors here? */
if (res < 0)
return mac_error();
#endif
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#ifdef WEHAVE_DUP
-static object *
+static PyObject *
mac_dup(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int fd;
- if (!getargs(args, "i", &fd))
+ if (!PyArg_Parse(args, "i", &fd))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
fd = dup(fd);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (fd < 0)
return mac_error();
- return newintobject((long)fd);
+ return PyInt_FromLong((long)fd);
}
#endif
#ifdef WEHAVE_FDOPEN
-static object *
+static PyObject *
mac_fdopen(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
- extern int fclose PROTO((FILE *));
+ extern int fclose Py_PROTO((FILE *));
int fd;
char *mode;
FILE *fp;
- if (!getargs(args, "(is)", &fd, &mode))
+ if (!PyArg_Parse(args, "(is)", &fd, &mode))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
fp = fdopen(fd, mode);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (fp == NULL)
return mac_error();
- return newopenfileobject(fp, "(fdopen)", mode, fclose);
+ return PyFile_FromFile(fp, "(fdopen)", mode, fclose);
}
#endif
-static object *
+static PyObject *
mac_getbootvol(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
char *res;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = getbootvol();
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res == NULL)
return mac_error();
- return newstringobject(res);
+ return PyString_FromString(res);
}
-static object *
+static PyObject *
mac_getcwd(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
char path[MAXPATHLEN];
char *res;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
#ifdef USE_GUSI
res = getcwd(path, sizeof path);
#else
res = getwd(path);
#endif
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res == NULL) {
- err_setstr(MacError, path);
+ PyErr_SetString(MacError, path);
return NULL;
}
- return newstringobject(res);
+ return PyString_FromString(res);
}
-static object *
+static PyObject *
mac_listdir(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
char *name;
- object *d, *v;
+ PyObject *d, *v;
DIR *dirp;
struct dirent *ep;
- if (!getargs(args, "s", &name))
+ if (!PyArg_Parse(args, "s", &name))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
if ((dirp = opendir(name)) == NULL) {
- RET_SAVE
+ Py_BLOCK_THREADS
return mac_error();
}
- if ((d = newlistobject(0)) == NULL) {
+ if ((d = PyList_New(0)) == NULL) {
closedir(dirp);
- RET_SAVE
+ Py_BLOCK_THREADS
return NULL;
}
while ((ep = readdir(dirp)) != NULL) {
- v = newstringobject(ep->d_name);
+ v = PyString_FromString(ep->d_name);
if (v == NULL) {
- DECREF(d);
+ Py_DECREF(d);
d = NULL;
break;
}
- if (addlistitem(d, v) != 0) {
- DECREF(v);
- DECREF(d);
+ if (PyList_Append(d, v) != 0) {
+ Py_DECREF(v);
+ Py_DECREF(d);
d = NULL;
break;
}
- DECREF(v);
+ Py_DECREF(v);
}
closedir(dirp);
- END_SAVE
+ Py_END_ALLOW_THREADS
return d;
}
-static object *
+static PyObject *
mac_lseek(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int fd;
int where;
int how;
long res;
- if (!getargs(args, "(iii)", &fd, &where, &how))
+ if (!PyArg_Parse(args, "(iii)", &fd, &where, &how))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = lseek(fd, (long)where, how);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res < 0)
return mac_error();
- return newintobject(res);
+ return PyInt_FromLong(res);
}
-static object *
+static PyObject *
mac_mkdir(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int res;
char *path;
int mode = 0777; /* Unused */
- if (!newgetargs(args, "s|i", &path, &mode))
+ if (!PyArg_ParseTuple(args, "s|i", &path, &mode))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
#ifdef USE_GUSI
res = mkdir(path);
#else
res = mkdir(path, mode);
#endif
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res < 0)
return mac_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mac_open(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
char *path;
int mode;
int fd;
- if (!getargs(args, "(si)", &path, &mode))
+ if (!PyArg_Parse(args, "(si)", &path, &mode))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
fd = open(path, mode);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (fd < 0)
return mac_error();
- return newintobject((long)fd);
+ return PyInt_FromLong((long)fd);
}
-static object *
+static PyObject *
mac_read(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int fd, size;
- object *buffer;
- if (!getargs(args, "(ii)", &fd, &size))
+ PyObject *buffer;
+ if (!PyArg_Parse(args, "(ii)", &fd, &size))
return NULL;
- buffer = newsizedstringobject((char *)NULL, size);
+ buffer = PyString_FromStringAndSize((char *)NULL, size);
if (buffer == NULL)
return NULL;
- BGN_SAVE
- size = read(fd, getstringvalue(buffer), size);
- END_SAVE
+ Py_BEGIN_ALLOW_THREADS
+ size = read(fd, PyString_AsString(buffer), size);
+ Py_END_ALLOW_THREADS
if (size < 0) {
- DECREF(buffer);
+ Py_DECREF(buffer);
return mac_error();
}
- resizestring(&buffer, size);
+ _PyString_Resize(&buffer, size);
return buffer;
}
-static object *
+static PyObject *
mac_rename(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
return mac_2str(args, rename);
}
-static object *
+static PyObject *
mac_rmdir(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
return mac_1str(args, rmdir);
}
-static object *
+static PyObject *
mac_stat(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
struct stat st;
char *path;
int res;
- if (!getargs(args, "s", &path))
+ if (!PyArg_Parse(args, "s", &path))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = stat(path, &st);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res != 0)
return mac_error();
#if 1
- return mkvalue("(lllllllddd)",
+ return Py_BuildValue("(lllllllddd)",
(long)st.st_mode,
(long)st.st_ino,
(long)st.st_dev,
(double)st.st_mtime,
(double)st.st_ctime);
#else
- return mkvalue("(llllllllll)",
+ return Py_BuildValue("(llllllllll)",
(long)st.st_mode,
(long)st.st_ino,
(long)st.st_dev,
#endif
}
-static object *
+static PyObject *
mac_xstat(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
struct macstat mst;
struct stat st;
char *path;
int res;
- if (!getargs(args, "s", &path))
+ if (!PyArg_Parse(args, "s", &path))
return NULL;
/*
** Convoluted: we want stat() and xstat() to agree, so we call both
** stat and macstat, and use the latter only for values not provided by
** the former.
*/
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = macstat(path, &mst);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res != 0)
return mac_error();
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = stat(path, &st);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res != 0)
return mac_error();
#if 1
- return mkvalue("(llllllldddls#s#)",
+ return Py_BuildValue("(llllllldddls#s#)",
(long)st.st_mode,
(long)st.st_ino,
(long)st.st_dev,
mst.st_creator, 4,
mst.st_type, 4);
#else
- return mkvalue("(llllllllllls#s#)",
+ return Py_BuildValue("(llllllllllls#s#)",
(long)st.st_mode,
(long)st.st_ino,
(long)st.st_dev,
#endif
}
-static object *
+static PyObject *
mac_sync(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int res;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
res = sync();
- END_SAVE
+ Py_END_ALLOW_THREADS
if (res != 0)
return mac_error();
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
mac_unlink(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
return mac_1str(args, (int (*)(const char *))unlink);
}
-static object *
+static PyObject *
mac_write(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
int fd, size;
char *buffer;
- if (!getargs(args, "(is#)", &fd, &buffer, &size))
+ if (!PyArg_Parse(args, "(is#)", &fd, &buffer, &size))
return NULL;
- BGN_SAVE
+ Py_BEGIN_ALLOW_THREADS
size = write(fd, buffer, size);
- END_SAVE
+ Py_END_ALLOW_THREADS
if (size < 0)
return mac_error();
- return newintobject((long)size);
+ return PyInt_FromLong((long)size);
}
#ifdef USE_MALLOC_DEBUG
-static object *
+static PyObject *
mac_mstats(self, args)
- object*self;
- object *args;
+ PyObject*self;
+ PyObject *args;
{
mstats("python");
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
#endif USE_MALLOC_DEBUG
-static struct methodlist mac_methods[] = {
+static struct PyMethodDef mac_methods[] = {
{"chdir", mac_chdir},
{"close", mac_close},
#ifdef WEHAVE_DUP
void
initmac()
{
- object *m, *d;
+ PyObject *m, *d;
- m = initmodule("mac", mac_methods);
- d = getmoduledict(m);
+ m = Py_InitModule("mac", mac_methods);
+ d = PyModule_GetDict(m);
/* Initialize mac.error exception */
- MacError = newstringobject("mac.error");
- if (MacError == NULL || dictinsert(d, "error", MacError) != 0)
- fatal("can't define mac.error");
+ MacError = PyString_FromString("mac.error");
+ if (MacError == NULL || PyDict_SetItemString(d, "error", MacError) != 0)
+ Py_FatalError("can't define mac.error");
}
/* xx module */
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
#include <GestaltEqu.h>
#include "Speech.h"
#define double2fixed(x) ((Fixed)((x)*32768.0))
char *CurrentSpeech;
-object *ms_error_object;
+PyObject *ms_error_object;
int speech_available;
static
static
check_available() {
if ( !speech_available ) {
- err_setstr(ms_error_object, "Speech Mgr not available");
+ PyErr_SetString(ms_error_object, "Speech Mgr not available");
return 0;
}
#ifdef __powerc
if ( !lib_available ) {
- err_setstr(ms_error_object, "Speech Mgr available, but shared lib missing");
+ PyErr_SetString(ms_error_object, "Speech Mgr available, but shared lib missing");
return 0;
}
#endif
** Part one - the speech channel object
*/
typedef struct {
- OB_HEAD
+ PyObject_HEAD
SpeechChannel chan;
- object *curtext; /* If non-NULL current text being spoken */
+ PyObject *curtext; /* If non-NULL current text being spoken */
} scobject;
-staticforward typeobject sctype;
+staticforward PyTypeObject sctype;
#define is_scobject(v) ((v)->ob_type == &sctype)
scobject *self;
OSErr err;
- self = NEWOBJ(scobject, &sctype);
+ self = PyObject_NEW(scobject, &sctype);
if (self == NULL)
return NULL;
if ( (err=NewSpeechChannel(arg, &self->chan)) != 0) {
- DECREF(self);
+ Py_DECREF(self);
return (scobject *)PyErr_Mac(ms_error_object, err);
}
self->curtext = NULL;
scobject *self;
{
DisposeSpeechChannel(self->chan);
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
sc_Stop(self, args)
scobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ((err=StopSpeech(self->chan)) != 0) {
PyErr_Mac(ms_error_object, err);
return NULL;
}
if ( self->curtext ) {
- DECREF(self->curtext);
+ Py_DECREF(self->curtext);
self->curtext = NULL;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sc_SpeakText(self, args)
scobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
char *str;
int len;
- if (!getargs(args, "s#", &str, &len))
+ if (!PyArg_Parse(args, "s#", &str, &len))
return NULL;
if ( self->curtext ) {
StopSpeech(self->chan);
- DECREF(self->curtext);
+ Py_DECREF(self->curtext);
self->curtext = NULL;
}
if ((err=SpeakText(self->chan, (Ptr)str, (long)len)) != 0) {
PyErr_Mac(ms_error_object, err);
return 0;
}
- (void)getargs(args, "O", &self->curtext); /* Or should I check this? */
- INCREF(self->curtext);
- INCREF(None);
- return None;
+ (void)PyArg_Parse(args, "O", &self->curtext); /* Or should I check this? */
+ Py_INCREF(self->curtext);
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sc_GetRate(self, args)
scobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
Fixed farg;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ((err=GetSpeechRate(self->chan, &farg)) != 0) {
PyErr_Mac(ms_error_object, err);
return 0;
}
- return newfloatobject(fixed2double(farg));
+ return PyFloat_FromDouble(fixed2double(farg));
}
-static object *
+static PyObject *
sc_GetPitch(self, args)
scobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
Fixed farg;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ((err=GetSpeechPitch(self->chan, &farg)) != 0) {
PyErr_Mac(ms_error_object, err);
return 0;
}
- return newfloatobject(fixed2double(farg));
+ return PyFloat_FromDouble(fixed2double(farg));
}
-static object *
+static PyObject *
sc_SetRate(self, args)
scobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
double darg;
- if (!getargs(args, "d", &darg))
+ if (!PyArg_Parse(args, "d", &darg))
return NULL;
if ((err=SetSpeechRate(self->chan, double2fixed(darg))) != 0) {
PyErr_Mac(ms_error_object, err);
return 0;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static object *
+static PyObject *
sc_SetPitch(self, args)
scobject *self;
- object *args;
+ PyObject *args;
{
OSErr err;
double darg;
- if (!getargs(args, "d", &darg))
+ if (!PyArg_Parse(args, "d", &darg))
return NULL;
if ((err=SetSpeechPitch(self->chan, double2fixed(darg))) != 0) {
PyErr_Mac(ms_error_object, err);
return NULL;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
-static struct methodlist sc_methods[] = {
- {"Stop", (method)sc_Stop},
- {"SetRate", (method)sc_SetRate},
- {"GetRate", (method)sc_GetRate},
- {"SetPitch", (method)sc_SetPitch},
- {"GetPitch", (method)sc_GetPitch},
- {"SpeakText", (method)sc_SpeakText},
+static struct PyMethodDef sc_methods[] = {
+ {"Stop", (PyCFunction)sc_Stop},
+ {"SetRate", (PyCFunction)sc_SetRate},
+ {"GetRate", (PyCFunction)sc_GetRate},
+ {"SetPitch", (PyCFunction)sc_SetPitch},
+ {"GetPitch", (PyCFunction)sc_GetPitch},
+ {"SpeakText", (PyCFunction)sc_SpeakText},
{NULL, NULL} /* sentinel */
};
-static object *
+static PyObject *
sc_getattr(self, name)
scobject *self;
char *name;
{
- return findmethod(sc_methods, (object *)self, name);
+ return Py_FindMethod(sc_methods, (PyObject *)self, name);
}
-static typeobject sctype = {
- OB_HEAD_INIT(&Typetype)
+static PyTypeObject sctype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"MacSpeechChannel", /*tp_name*/
sizeof(scobject), /*tp_basicsize*/
** Part two - the voice object
*/
typedef struct {
- OB_HEAD
+ PyObject_HEAD
int initialized;
VoiceSpec vs;
VoiceDescription vd;
} mvobject;
-staticforward typeobject mvtype;
+staticforward PyTypeObject mvtype;
#define is_mvobject(v) ((v)->ob_type == &mvtype)
newmvobject()
{
mvobject *self;
- self = NEWOBJ(mvobject, &mvtype);
+ self = PyObject_NEW(mvobject, &mvtype);
if (self == NULL)
return NULL;
self->initialized = 0;
mv_dealloc(self)
mvobject *self;
{
- DEL(self);
+ PyMem_DEL(self);
}
-static object *
+static PyObject *
mv_getgender(self, args)
mvobject *self;
- object *args;
+ PyObject *args;
{
- object *rv;
+ PyObject *rv;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if (!self->initialized) {
- err_setstr(ms_error_object, "Uninitialized voice");
+ PyErr_SetString(ms_error_object, "Uninitialized voice");
return NULL;
}
- rv = newintobject(self->vd.gender);
+ rv = PyInt_FromLong(self->vd.gender);
return rv;
}
-static object *
+static PyObject *
mv_newchannel(self, args)
mvobject *self;
- object *args;
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if (!self->initialized) {
- err_setstr(ms_error_object, "Uninitialized voice");
+ PyErr_SetString(ms_error_object, "Uninitialized voice");
return NULL;
}
- return (object *)newscobject(&self->vs);
+ return (PyObject *)newscobject(&self->vs);
}
-static struct methodlist mv_methods[] = {
- {"GetGender", (method)mv_getgender},
- {"NewChannel", (method)mv_newchannel},
+static struct PyMethodDef mv_methods[] = {
+ {"GetGender", (PyCFunction)mv_getgender},
+ {"NewChannel", (PyCFunction)mv_newchannel},
{NULL, NULL} /* sentinel */
};
-static object *
+static PyObject *
mv_getattr(self, name)
mvobject *self;
char *name;
{
- return findmethod(mv_methods, (object *)self, name);
+ return Py_FindMethod(mv_methods, (PyObject *)self, name);
}
-static typeobject mvtype = {
- OB_HEAD_INIT(&Typetype)
+static PyTypeObject mvtype = {
+ PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"MacVoice", /*tp_name*/
sizeof(mvobject), /*tp_basicsize*/
/* See if Speech manager available */
-static object *
+static PyObject *
ms_Available(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
- return newintobject(speech_available);
+ return PyInt_FromLong(speech_available);
}
/* Count number of busy speeches */
-static object *
+static PyObject *
ms_Busy(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
short result;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ( !check_available() )
return NULL;
result = SpeechBusy();
- return newintobject(result);
+ return PyInt_FromLong(result);
}
/* Say something */
-static object *
+static PyObject *
ms_SpeakString(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
OSErr err;
char *str;
int len;
- if (!getstrarg(args, &str))
+ if (!PyArg_Parse(args, "s", &str))
return NULL;
if ( !check_available())
return NULL;
PyErr_Mac(ms_error_object, err);
return NULL;
}
- INCREF(None);
- return None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
/* Count number of available voices */
-static object *
+static PyObject *
ms_CountVoices(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
short result;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ( !check_available())
return NULL;
CountVoices(&result);
- return newintobject(result);
+ return PyInt_FromLong(result);
}
-static object *
+static PyObject *
ms_GetIndVoice(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
mvobject *rv;
long ind;
- if( !getargs(args, "i", &ind))
+ if( !PyArg_Parse(args, "i", &ind))
return NULL;
if ( !check_available() )
return NULL;
rv = newmvobject();
if ( !initmvobject(rv, ind) ) {
- DECREF(rv);
+ Py_DECREF(rv);
return NULL;
}
- return (object *)rv;
+ return (PyObject *)rv;
}
-static object *
+static PyObject *
ms_Version(self, args)
- object *self; /* Not used */
- object *args;
+ PyObject *self; /* Not used */
+ PyObject *args;
{
NumVersion v;
- if (!getnoarg(args))
+ if (!PyArg_NoArgs(args))
return NULL;
if ( !check_available())
return NULL;
v = SpeechManagerVersion();
- return newintobject(*(int *)&v);
+ return PyInt_FromLong(*(int *)&v);
}
/* List of functions defined in the module */
-static struct methodlist ms_methods[] = {
+static struct PyMethodDef ms_methods[] = {
{"Available", ms_Available},
{"CountVoices", ms_CountVoices},
{"Busy", ms_Busy},
void
initmacspeech()
{
- object *m, *d;
+ PyObject *m, *d;
speech_available = init_available();
/* Create the module and add the functions */
- m = initmodule("macspeech", ms_methods);
+ m = Py_InitModule("macspeech", ms_methods);
/* Add some symbolic constants to the module */
- d = getmoduledict(m);
- ms_error_object = newstringobject("macspeech.error");
- dictinsert(d, "error", ms_error_object);
+ d = PyModule_GetDict(m);
+ ms_error_object = PyString_FromString("macspeech.error");
+ PyDict_SetItemString(d, "error", ms_error_object);
/* Check for errors */
- if (err_occurred())
- fatal("can't initialize module macspeech");
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module macspeech");
}
projects / python / commitdiff