diff --git a/Modules/bsddbmodule.c b/Modules/bsddbmodule.c index 8cf674e959e..3007d3ddb3c 100644 --- a/Modules/bsddbmodule.c +++ b/Modules/bsddbmodule.c @@ -33,8 +33,7 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - support more open flags */ -#include "allobjects.h" -#include "modsupport.h" +#include "Python.h" #include #include @@ -44,18 +43,18 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. (it messes up the info required in the Setup file) */ typedef struct { - OB_HEAD + PyObject_HEAD DB *di_bsddb; int di_size; /* -1 means recompute */ } bsddbobject; -staticforward typeobject Bsddbtype; +staticforward PyTypeObject Bsddbtype; #define is_bsddbobject(v) ((v)->ob_type == &Bsddbtype) -static object *BsddbError; +static PyObject *BsddbError; -static object * +static PyObject * newdbhashobject(file, flags, mode, bsize, ffactor, nelem, cachesize, hash, lorder) char *file; @@ -71,7 +70,7 @@ newdbhashobject(file, flags, mode, bsddbobject *dp; HASHINFO info; - if ((dp = NEWOBJ(bsddbobject, &Bsddbtype)) == NULL) + if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL) return NULL; info.bsize = bsize; @@ -82,17 +81,17 @@ newdbhashobject(file, flags, mode, info.lorder = lorder; if ((dp->di_bsddb = dbopen(file, flags, mode, DB_HASH, &info)) == NULL) { - err_errno(BsddbError); - DECREF(dp); + PyErr_SetFromErrno(BsddbError); + Py_DECREF(dp); return NULL; } dp->di_size = -1; - return (object *)dp; + return (PyObject *)dp; } -static object * +static PyObject * newdbbtobject(file, flags, mode, btflags, cachesize, maxkeypage, minkeypage, psize, lorder) char *file; @@ -108,7 +107,7 @@ newdbbtobject(file, flags, mode, bsddbobject *dp; BTREEINFO info; - if ((dp = NEWOBJ(bsddbobject, &Bsddbtype)) == NULL) + if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL) return NULL; info.flags = btflags; @@ -121,17 +120,17 @@ newdbbtobject(file, flags, mode, info.prefix = 0; if ((dp->di_bsddb = dbopen(file, flags, mode, DB_BTREE, &info)) == NULL) { - err_errno(BsddbError); - DECREF(dp); + PyErr_SetFromErrno(BsddbError); + Py_DECREF(dp); return NULL; } dp->di_size = -1; - return (object *)dp; + return (PyObject *)dp; } -static object * +static PyObject * newdbrnobject(file, flags, mode, rnflags, cachesize, psize, lorder, reclen, bval, bfname) char *file; @@ -148,7 +147,7 @@ newdbrnobject(file, flags, mode, bsddbobject *dp; RECNOINFO info; - if ((dp = NEWOBJ(bsddbobject, &Bsddbtype)) == NULL) + if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL) return NULL; info.flags = rnflags; @@ -160,14 +159,14 @@ newdbrnobject(file, flags, mode, info.bfname = bfname; if ((dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info)) == NULL) { - err_errno(BsddbError); - DECREF(dp); + PyErr_SetFromErrno(BsddbError); + Py_DECREF(dp); return NULL; } dp->di_size = -1; - return (object *)dp; + return (PyObject *)dp; } @@ -180,7 +179,7 @@ bsddb_dealloc(dp) fprintf(stderr, "Python bsddb: close errno %s in dealloc\n", errno); } - DEL(dp); + PyMem_DEL(dp); } static int @@ -196,7 +195,7 @@ bsddb_length(dp) status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_NEXT)) size++; if (status < 0) { - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); return -1; } dp->di_size = size; @@ -204,18 +203,18 @@ bsddb_length(dp) return dp->di_size; } -static object * +static PyObject * bsddb_subscript(dp, key) bsddbobject *dp; - object *key; + PyObject *key; { int status; - object *v; + PyObject *v; DBT krec, drec; char *data; int size; - if (!getargs(key, "s#", &data, &size)) + if (!PyArg_Parse(key, "s#", &data, &size)) return NULL; krec.data = data; krec.size = size; @@ -223,27 +222,27 @@ bsddb_subscript(dp, key) status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0); if (status != 0) { if (status < 0) - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); else - err_setval(KeyError, key); + PyErr_SetObject(PyExc_KeyError, key); return NULL; } - return newsizedstringobject((char *)drec.data, (int)drec.size); + return PyString_FromStringAndSize((char *)drec.data, (int)drec.size); } static int bsddb_ass_sub(dp, key, value) bsddbobject *dp; - object *key, *value; + PyObject *key, *value; { int status; DBT krec, drec; char *data; int size; - if (!getargs(key, "s#", &data, &size)) { - err_setstr(TypeError, "bsddb key type must be string"); + if (!PyArg_Parse(key, "s#", &data, &size)) { + PyErr_SetString(PyExc_TypeError, "bsddb key type must be string"); return -1; } krec.data = data; @@ -253,8 +252,8 @@ bsddb_ass_sub(dp, key, value) status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0); } else { - if (!getargs(value, "s#", &data, &size)) { - err_setstr(TypeError, "bsddb value type must be string"); + if (!PyArg_Parse(value, "s#", &data, &size)) { + PyErr_SetString(PyExc_TypeError, "bsddb value type must be string"); return -1; } drec.data = data; @@ -263,115 +262,115 @@ bsddb_ass_sub(dp, key, value) } if (status != 0) { if (status < 0) - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); else - err_setval(KeyError, key); + PyErr_SetObject(PyExc_KeyError, key); return -1; } return 0; } -static mapping_methods bsddb_as_mapping = { +static PyMappingMethods bsddb_as_mapping = { (inquiry)bsddb_length, /*mp_length*/ (binaryfunc)bsddb_subscript, /*mp_subscript*/ (objobjargproc)bsddb_ass_sub, /*mp_ass_subscript*/ }; -static object * +static PyObject * bsddb_close(dp, args) bsddbobject *dp; - object *args; + PyObject *args; { - if (!getnoarg(args)) + if (!PyArg_NoArgs(args)) return NULL; if (dp->di_bsddb != NULL) { if ((dp->di_bsddb->close)(dp->di_bsddb) != 0) { dp->di_bsddb = NULL; - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); return NULL; } } dp->di_bsddb = NULL; - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } -static object * +static PyObject * bsddb_keys(dp, args) bsddbobject *dp; - object *args; + PyObject *args; { - object *list, *item; + PyObject *list, *item; DBT krec, drec; int status; int err; - if (!getnoarg(args)) + if (!PyArg_NoArgs(args)) return NULL; - list = newlistobject(0); + list = PyList_New(0); if (list == NULL) return NULL; for (status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST); status == 0; status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_NEXT)) { - item = newsizedstringobject((char *)krec.data, (int)krec.size); + item = PyString_FromStringAndSize((char *)krec.data, (int)krec.size); if (item == NULL) { - DECREF(list); + Py_DECREF(list); return NULL; } - err = addlistitem(list, item); - DECREF(item); + err = PyList_Append(list, item); + Py_DECREF(item); if (err != 0) { - DECREF(list); + Py_DECREF(list); return NULL; } } if (status < 0) { - err_errno(BsddbError); - DECREF(list); + PyErr_SetFromErrno(BsddbError); + Py_DECREF(list); return NULL; } if (dp->di_size < 0) - dp->di_size = getlistsize(list); /* We just did the work for this... */ + dp->di_size = PyList_Size(list); /* We just did the work for this... */ return list; } -static object * +static PyObject * bsddb_has_key(dp, args) bsddbobject *dp; - object *args; + PyObject *args; { DBT krec, drec; int status; char *data; int size; - if (!getargs(args, "s#", &data, &size)) + if (!PyArg_Parse(args, "s#", &data, &size)) return NULL; krec.data = data; krec.size = size; status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0); if (status < 0) { - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); return NULL; } - return newintobject(status == 0); + return PyInt_FromLong(status == 0); } -static object * +static PyObject * bsddb_set_location(dp, key) bsddbobject *dp; - object *key; + PyObject *key; { int status; - object *v; + PyObject *v; DBT krec, drec; char *data; int size; - if (!getargs(key, "s#", &data, &size)) + if (!PyArg_Parse(key, "s#", &data, &size)) return NULL; krec.data = data; krec.size = size; @@ -379,25 +378,25 @@ bsddb_set_location(dp, key) status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR); if (status != 0) { if (status < 0) - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); else - err_setval(KeyError, key); + PyErr_SetObject(PyExc_KeyError, key); return NULL; } - return mkvalue("s#s#", krec.data, krec.size, drec.data, drec.size); + return Py_BuildValue("s#s#", krec.data, krec.size, drec.data, drec.size); } -static object * +static PyObject * bsddb_seq(dp, args, sequence_request) bsddbobject *dp; - object *args; + PyObject *args; int sequence_request; { int status; DBT krec, drec; - if (!getnoarg(args)) + if (!PyArg_NoArgs(args)) return NULL; krec.data = 0; @@ -406,80 +405,80 @@ bsddb_seq(dp, args, sequence_request) status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, sequence_request); if (status != 0) { if (status < 0) - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); else - err_setval(KeyError, args); + PyErr_SetObject(PyExc_KeyError, args); return NULL; } - return mkvalue("s#s#", krec.data, krec.size, drec.data, drec.size); + return Py_BuildValue("s#s#", krec.data, krec.size, drec.data, drec.size); } -static object * +static PyObject * bsddb_next(dp, key) bsddbobject *dp; - object *key; + PyObject *key; { return bsddb_seq(dp, key, R_NEXT); } -static object * +static PyObject * bsddb_previous(dp, key) bsddbobject *dp; - object *key; + PyObject *key; { return bsddb_seq(dp, key, R_PREV); } -static object * +static PyObject * bsddb_first(dp, key) bsddbobject *dp; - object *key; + PyObject *key; { return bsddb_seq(dp, key, R_FIRST); } -static object * +static PyObject * bsddb_last(dp, key) bsddbobject *dp; - object *key; + PyObject *key; { return bsddb_seq(dp, key, R_LAST); } -static object * +static PyObject * bsddb_sync(dp, args) bsddbobject *dp; - object *args; + PyObject *args; { int status; status = (dp->di_bsddb->sync)(dp->di_bsddb, 0); if (status != 0) { - err_errno(BsddbError); + PyErr_SetFromErrno(BsddbError); return NULL; } - return newintobject(status = 0); + return PyInt_FromLong(status = 0); } -static struct methodlist bsddb_methods[] = { - {"close", (method)bsddb_close}, - {"keys", (method)bsddb_keys}, - {"has_key", (method)bsddb_has_key}, - {"set_location", (method)bsddb_set_location}, - {"next", (method)bsddb_next}, - {"previous", (method)bsddb_previous}, - {"first", (method)bsddb_first}, - {"last", (method)bsddb_last}, - {"sync", (method)bsddb_sync}, +static PyMethodDef bsddb_methods[] = { + {"close", (PyCFunction)bsddb_close}, + {"keys", (PyCFunction)bsddb_keys}, + {"has_key", (PyCFunction)bsddb_has_key}, + {"set_location", (PyCFunction)bsddb_set_location}, + {"next", (PyCFunction)bsddb_next}, + {"previous", (PyCFunction)bsddb_previous}, + {"first", (PyCFunction)bsddb_first}, + {"last", (PyCFunction)bsddb_last}, + {"sync", (PyCFunction)bsddb_sync}, {NULL, NULL} /* sentinel */ }; -static object * +static PyObject * bsddb_getattr(dp, name) - object *dp; + PyObject *dp; char *name; { - return findmethod(bsddb_methods, dp, name); + return Py_FindMethod(bsddb_methods, dp, name); } -static typeobject Bsddbtype = { - OB_HEAD_INIT(&Typetype) +static PyTypeObject Bsddbtype = { + PyObject_HEAD_INIT(&PyType_Type) 0, "bsddb", sizeof(bsddbobject), @@ -495,10 +494,10 @@ static typeobject Bsddbtype = { &bsddb_as_mapping, /*tp_as_mapping*/ }; -static object * +static PyObject * bsdhashopen(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { char *file; char *flag = NULL; @@ -511,7 +510,7 @@ bsdhashopen(self, args) int hash = 0; /* XXX currently ignored */ int lorder = 0; - if (!newgetargs(args, "s|siiiiiii", + if (!PyArg_ParseTuple(args, "s|siiiiiii", &file, &flag, &mode, &bsize, &ffactor, &nelem, &cachesize, &hash, &lorder)) return NULL; @@ -526,7 +525,7 @@ bsdhashopen(self, args) else if (flag[0] == 'n') flags = O_RDWR|O_CREAT|O_TRUNC; else { - err_setstr(BsddbError, + PyErr_SetString(BsddbError, "Flag should begin with 'r', 'w', 'c' or 'n'"); return NULL; } @@ -537,7 +536,7 @@ bsdhashopen(self, args) else flags |= O_EXLOCK; #else - err_setstr(BsddbError, "locking not supported on this platform"); + PyErr_SetString(BsddbError, "locking not supported on this platform"); return NULL; #endif } @@ -546,10 +545,10 @@ bsdhashopen(self, args) bsize, ffactor, nelem, cachesize, hash, lorder); } -static object * +static PyObject * bsdbtopen(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { char *file; char *flag = NULL; @@ -562,7 +561,7 @@ bsdbtopen(self, args) unsigned int psize = 0; int lorder = 0; - if (!newgetargs(args, "s|siiiiiii", + if (!PyArg_ParseTuple(args, "s|siiiiiii", &file, &flag, &mode, &btflags, &cachesize, &maxkeypage, &minkeypage, &psize, &lorder)) @@ -578,7 +577,7 @@ bsdbtopen(self, args) else if (flag[0] == 'n') flags = O_RDWR|O_CREAT|O_TRUNC; else { - err_setstr(BsddbError, + PyErr_SetString(BsddbError, "Flag should begin with 'r', 'w', 'c' or 'n'"); return NULL; } @@ -589,7 +588,7 @@ bsdbtopen(self, args) else flags |= O_EXLOCK; #else - err_setstr(BsddbError, "locking not supported on this platform"); + PyErr_SetString(BsddbError, "locking not supported on this platform"); return NULL; #endif } @@ -599,10 +598,10 @@ bsdbtopen(self, args) psize, lorder); } -static object * +static PyObject * bsdrnopen(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { char *file; char *flag = NULL; @@ -616,7 +615,7 @@ bsdrnopen(self, args) char *bval = ""; char *bfname = NULL; - if (!newgetargs(args, "s|siiiiiiss", + if (!PyArg_ParseTuple(args, "s|siiiiiiss", &file, &flag, &mode, &rnflags, &cachesize, &psize, &lorder, &reclen, &bval, &bfname)) @@ -632,7 +631,7 @@ bsdrnopen(self, args) else if (flag[0] == 'n') flags = O_RDWR|O_CREAT|O_TRUNC; else { - err_setstr(BsddbError, + PyErr_SetString(BsddbError, "Flag should begin with 'r', 'w', 'c' or 'n'"); return NULL; } @@ -643,12 +642,12 @@ bsdrnopen(self, args) else flags |= O_EXLOCK; #else - err_setstr(BsddbError, "locking not supported on this platform"); + PyErr_SetString(BsddbError, "locking not supported on this platform"); return NULL; #endif } else if (flag[1] != '\0') { - err_setstr(BsddbError, + PyErr_SetString(BsddbError, "Flag char 2 should be 'l' or absent"); return NULL; } @@ -657,20 +656,20 @@ bsdrnopen(self, args) rnflags, cachesize, psize, lorder, bval[0], bfname); } -static struct methodlist bsddbmodule_methods[] = { - {"hashopen", (method)bsdhashopen, 1}, - {"btopen", (method)bsdbtopen, 1}, - {"rnopen", (method)bsdrnopen, 1}, +static PyMethodDef bsddbmodule_methods[] = { + {"hashopen", (PyCFunction)bsdhashopen, 1}, + {"btopen", (PyCFunction)bsdbtopen, 1}, + {"rnopen", (PyCFunction)bsdrnopen, 1}, {0, 0}, }; void initbsddb() { - object *m, *d; + PyObject *m, *d; - m = initmodule("bsddb", bsddbmodule_methods); - d = getmoduledict(m); - BsddbError = newstringobject("bsddb.error"); - if (BsddbError == NULL || dictinsert(d, "error", BsddbError)) - fatal("can't define bsddb.error"); + m = Py_InitModule("bsddb", bsddbmodule_methods); + d = PyModule_GetDict(m); + BsddbError = PyString_FromString("bsddb.error"); + if (BsddbError == NULL || PyDict_SetItemString(d, "error", BsddbError)) + Py_FatalError("can't define bsddb.error"); } diff --git a/Modules/regexmodule.c b/Modules/regexmodule.c index 33801afa905..9cbd4bf4aca 100644 --- a/Modules/regexmodule.c +++ b/Modules/regexmodule.c @@ -31,24 +31,22 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. /* This uses Tatu Ylonen's copyleft-free reimplementation of GNU regular expressions */ -#include "allobjects.h" -#include "modsupport.h" +#include "Python.h" #include "regexpr.h" -#include -static object *RegexError; /* Exception */ +static PyObject *RegexError; /* Exception */ typedef struct { - OB_HEAD + PyObject_HEAD struct re_pattern_buffer re_patbuf; /* The compiled expression */ struct re_registers re_regs; /* The registers from the last match */ char re_fastmap[256]; /* Storage for fastmap */ - object *re_translate; /* String object for translate table */ - object *re_lastok; /* String object last matched/searched */ - object *re_groupindex; /* Group name to index dictionary */ - object *re_givenpat; /* Pattern with symbolic groups */ - object *re_realpat; /* Pattern without symbolic groups */ + PyObject *re_translate; /* String object for translate table */ + PyObject *re_lastok; /* String object last matched/searched */ + PyObject *re_groupindex; /* Group name to index dictionary */ + PyObject *re_givenpat; /* Pattern with symbolic groups */ + PyObject *re_realpat; /* Pattern without symbolic groups */ } regexobject; /* Regex object methods */ @@ -57,99 +55,99 @@ static void reg_dealloc(re) regexobject *re; { - XDEL(re->re_patbuf.buffer); - XDECREF(re->re_translate); - XDECREF(re->re_lastok); - XDECREF(re->re_groupindex); - XDECREF(re->re_givenpat); - XDECREF(re->re_realpat); - DEL(re); + PyMem_XDEL(re->re_patbuf.buffer); + Py_XDECREF(re->re_translate); + Py_XDECREF(re->re_lastok); + Py_XDECREF(re->re_groupindex); + Py_XDECREF(re->re_givenpat); + Py_XDECREF(re->re_realpat); + PyMem_DEL(re); } -static object * +static PyObject * makeresult(regs) struct re_registers *regs; { - object *v = newtupleobject(RE_NREGS); + PyObject *v = PyTuple_New(RE_NREGS); if (v != NULL) { int i; for (i = 0; i < RE_NREGS; i++) { - object *w; - w = mkvalue("(ii)", regs->start[i], regs->end[i]); + PyObject *w; + w = Py_BuildValue("(ii)", regs->start[i], regs->end[i]); if (w == NULL) { - XDECREF(v); + Py_XDECREF(v); v = NULL; break; } - settupleitem(v, i, w); + PyTuple_SetItem(v, i, w); } } return v; } -static object * +static PyObject * reg_match(re, args) regexobject *re; - object *args; + PyObject *args; { - object *argstring; + PyObject *argstring; char *buffer; int size; int offset; int result; - if (getargs(args, "S", &argstring)) { + if (PyArg_Parse(args, "S", &argstring)) { offset = 0; } else { - err_clear(); - if (!getargs(args, "(Si)", &argstring, &offset)) + PyErr_Clear(); + if (!PyArg_Parse(args, "(Si)", &argstring, &offset)) return NULL; } - buffer = getstringvalue(argstring); - size = getstringsize(argstring); + buffer = PyString_AsString(argstring); + size = PyString_Size(argstring); if (offset < 0 || offset > size) { - err_setstr(RegexError, "match offset out of range"); + PyErr_SetString(RegexError, "match offset out of range"); return NULL; } - XDECREF(re->re_lastok); + Py_XDECREF(re->re_lastok); re->re_lastok = NULL; result = re_match(&re->re_patbuf, buffer, size, offset, &re->re_regs); if (result < -1) { /* Failure like stack overflow */ - err_setstr(RegexError, "match failure"); + PyErr_SetString(RegexError, "match failure"); return NULL; } if (result >= 0) { - INCREF(argstring); + Py_INCREF(argstring); re->re_lastok = argstring; } - return newintobject((long)result); /* Length of the match or -1 */ + return PyInt_FromLong((long)result); /* Length of the match or -1 */ } -static object * +static PyObject * reg_search(re, args) regexobject *re; - object *args; + PyObject *args; { - object *argstring; + PyObject *argstring; char *buffer; int size; int offset; int range; int result; - if (getargs(args, "S", &argstring)) { + if (PyArg_Parse(args, "S", &argstring)) { offset = 0; } else { - err_clear(); - if (!getargs(args, "(Si)", &argstring, &offset)) + PyErr_Clear(); + if (!PyArg_Parse(args, "(Si)", &argstring, &offset)) return NULL; } - buffer = getstringvalue(argstring); - size = getstringsize(argstring); + buffer = PyString_AsString(argstring); + size = PyString_Size(argstring); if (offset < 0 || offset > size) { - err_setstr(RegexError, "search offset out of range"); + PyErr_SetString(RegexError, "search offset out of range"); return NULL; } /* NB: In Emacs 18.57, the documentation for re_search[_2] and @@ -157,159 +155,159 @@ reg_search(re, args) |range| positions are tried, while the code tries |range|+1 positions. It seems more productive to believe the code! */ range = size - offset; - XDECREF(re->re_lastok); + Py_XDECREF(re->re_lastok); re->re_lastok = NULL; result = re_search(&re->re_patbuf, buffer, size, offset, range, &re->re_regs); if (result < -1) { /* Failure like stack overflow */ - err_setstr(RegexError, "match failure"); + PyErr_SetString(RegexError, "match failure"); return NULL; } if (result >= 0) { - INCREF(argstring); + Py_INCREF(argstring); re->re_lastok = argstring; } - return newintobject((long)result); /* Position of the match or -1 */ + return PyInt_FromLong((long)result); /* Position of the match or -1 */ } -static object * +static PyObject * reg_group(re, args) regexobject *re; - object *args; + PyObject *args; { int i, a, b; - if (args != NULL && is_tupleobject(args)) { - int n = gettuplesize(args); - object *res = newtupleobject(n); + if (args != NULL && PyTuple_Check(args)) { + int n = PyTuple_Size(args); + PyObject *res = PyTuple_New(n); if (res == NULL) return NULL; for (i = 0; i < n; i++) { - object *v = reg_group(re, gettupleitem(args, i)); + PyObject *v = reg_group(re, PyTuple_GetItem(args, i)); if (v == NULL) { - DECREF(res); + Py_DECREF(res); return NULL; } - settupleitem(res, i, v); + PyTuple_SetItem(res, i, v); } return res; } - if (!getargs(args, "i", &i)) { - object *n; - err_clear(); - if (!getargs(args, "S", &n)) + if (!PyArg_Parse(args, "i", &i)) { + PyObject *n; + PyErr_Clear(); + if (!PyArg_Parse(args, "S", &n)) return NULL; else { - object *index; + PyObject *index; if (re->re_groupindex == NULL) index = NULL; else - index = mappinglookup(re->re_groupindex, n); + index = PyDict_GetItem(re->re_groupindex, n); if (index == NULL) { - err_setstr(RegexError, "group() group name doesn't exist"); + PyErr_SetString(RegexError, "group() group name doesn't exist"); return NULL; } - i = getintvalue(index); + i = PyInt_AsLong(index); } } if (i < 0 || i >= RE_NREGS) { - err_setstr(RegexError, "group() index out of range"); + PyErr_SetString(RegexError, "group() index out of range"); return NULL; } if (re->re_lastok == NULL) { - err_setstr(RegexError, + PyErr_SetString(RegexError, "group() only valid after successful match/search"); return NULL; } a = re->re_regs.start[i]; b = re->re_regs.end[i]; if (a < 0 || b < 0) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } - return newsizedstringobject(getstringvalue(re->re_lastok)+a, b-a); + return PyString_FromStringAndSize(PyString_AsString(re->re_lastok)+a, b-a); } -static struct methodlist reg_methods[] = { - {"match", (method)reg_match}, - {"search", (method)reg_search}, - {"group", (method)reg_group}, +static struct PyMethodDef reg_methods[] = { + {"match", (PyCFunction)reg_match}, + {"search", (PyCFunction)reg_search}, + {"group", (PyCFunction)reg_group}, {NULL, NULL} /* sentinel */ }; -static object * +static PyObject * reg_getattr(re, name) regexobject *re; char *name; { if (strcmp(name, "regs") == 0) { if (re->re_lastok == NULL) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } return makeresult(&re->re_regs); } if (strcmp(name, "last") == 0) { if (re->re_lastok == NULL) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } - INCREF(re->re_lastok); + Py_INCREF(re->re_lastok); return re->re_lastok; } if (strcmp(name, "translate") == 0) { if (re->re_translate == NULL) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } - INCREF(re->re_translate); + Py_INCREF(re->re_translate); return re->re_translate; } if (strcmp(name, "groupindex") == 0) { if (re->re_groupindex == NULL) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } - INCREF(re->re_groupindex); + Py_INCREF(re->re_groupindex); return re->re_groupindex; } if (strcmp(name, "realpat") == 0) { if (re->re_realpat == NULL) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } - INCREF(re->re_realpat); + Py_INCREF(re->re_realpat); return re->re_realpat; } if (strcmp(name, "givenpat") == 0) { if (re->re_givenpat == NULL) { - INCREF(None); - return None; + Py_INCREF(Py_None); + return Py_None; } - INCREF(re->re_givenpat); + Py_INCREF(re->re_givenpat); return re->re_givenpat; } if (strcmp(name, "__members__") == 0) { - object *list = newlistobject(6); + PyObject *list = PyList_New(6); if (list) { - setlistitem(list, 0, newstringobject("last")); - setlistitem(list, 1, newstringobject("regs")); - setlistitem(list, 2, newstringobject("translate")); - setlistitem(list, 3, newstringobject("groupindex")); - setlistitem(list, 4, newstringobject("realpat")); - setlistitem(list, 5, newstringobject("givenpat")); - if (err_occurred()) { - DECREF(list); + PyList_SetItem(list, 0, PyString_FromString("last")); + PyList_SetItem(list, 1, PyString_FromString("regs")); + PyList_SetItem(list, 2, PyString_FromString("translate")); + PyList_SetItem(list, 3, PyString_FromString("groupindex")); + PyList_SetItem(list, 4, PyString_FromString("realpat")); + PyList_SetItem(list, 5, PyString_FromString("givenpat")); + if (PyErr_Occurred()) { + Py_DECREF(list); list = NULL; } } return list; } - return findmethod(reg_methods, (object *)re, name); + return Py_FindMethod(reg_methods, (PyObject *)re, name); } -static typeobject Regextype = { - OB_HEAD_INIT(&Typetype) +static PyTypeObject Regextype = { + PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "regex", /*tp_name*/ sizeof(regexobject), /*tp_size*/ @@ -323,90 +321,90 @@ static typeobject Regextype = { 0, /*tp_repr*/ }; -static object * +static PyObject * newregexobject(pattern, translate, givenpat, groupindex) - object *pattern; - object *translate; - object *givenpat; - object *groupindex; + PyObject *pattern; + PyObject *translate; + PyObject *givenpat; + PyObject *groupindex; { regexobject *re; - char *pat = getstringvalue(pattern); - int size = getstringsize(pattern); + char *pat = PyString_AsString(pattern); + int size = PyString_Size(pattern); - if (translate != NULL && getstringsize(translate) != 256) { - err_setstr(RegexError, + if (translate != NULL && PyString_Size(translate) != 256) { + PyErr_SetString(RegexError, "translation table must be 256 bytes"); return NULL; } - re = NEWOBJ(regexobject, &Regextype); + re = PyObject_NEW(regexobject, &Regextype); if (re != NULL) { char *error; re->re_patbuf.buffer = NULL; re->re_patbuf.allocated = 0; re->re_patbuf.fastmap = re->re_fastmap; if (translate) - re->re_patbuf.translate = getstringvalue(translate); + re->re_patbuf.translate = PyString_AsString(translate); else re->re_patbuf.translate = NULL; - XINCREF(translate); + Py_XINCREF(translate); re->re_translate = translate; re->re_lastok = NULL; re->re_groupindex = groupindex; - INCREF(pattern); + Py_INCREF(pattern); re->re_realpat = pattern; - INCREF(givenpat); + Py_INCREF(givenpat); re->re_givenpat = givenpat; error = re_compile_pattern(pat, size, &re->re_patbuf); if (error != NULL) { - err_setstr(RegexError, error); - DECREF(re); + PyErr_SetString(RegexError, error); + Py_DECREF(re); re = NULL; } } - return (object *)re; + return (PyObject *)re; } -static object * +static PyObject * regex_compile(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - object *pat = NULL; - object *tran = NULL; - if (!getargs(args, "S", &pat)) { - err_clear(); - if (!getargs(args, "(SS)", &pat, &tran)) + PyObject *pat = NULL; + PyObject *tran = NULL; + if (!PyArg_Parse(args, "S", &pat)) { + PyErr_Clear(); + if (!PyArg_Parse(args, "(SS)", &pat, &tran)) return NULL; } return newregexobject(pat, tran, pat, NULL); } -static object * +static PyObject * symcomp(pattern, gdict) - object *pattern; - object *gdict; + PyObject *pattern; + PyObject *gdict; { - char *opat = getstringvalue(pattern); - char *oend = opat + getstringsize(pattern); + char *opat = PyString_AsString(pattern); + char *oend = opat + PyString_Size(pattern); int group_count = 0; int escaped = 0; char *o = opat; char *n; char name_buf[128]; char *g; - object *npattern; + PyObject *npattern; int require_escape = re_syntax & RE_NO_BK_PARENS ? 0 : 1; if (oend == opat) { - INCREF(pattern); + Py_INCREF(pattern); return pattern; } - npattern = newsizedstringobject((char*)NULL, getstringsize(pattern)); + npattern = PyString_FromStringAndSize((char*)NULL, PyString_Size(pattern)); if (npattern == NULL) return NULL; - n = getstringvalue(npattern); + n = PyString_AsString(npattern); while (o < oend) { if (*o == '(' && escaped == require_escape) { @@ -423,16 +421,16 @@ symcomp(pattern, gdict) g = name_buf; for (++o; o < oend;) { if (*o == '>') { - object *group_name = NULL; - object *group_index = NULL; + PyObject *group_name = NULL; + PyObject *group_index = NULL; *g++ = '\0'; - group_name = newstringobject(name_buf); - group_index = newintobject(group_count); + group_name = PyString_FromString(name_buf); + group_index = PyInt_FromLong(group_count); if (group_name == NULL || group_index == NULL - || mappinginsert(gdict, group_name, group_index) != 0) { - XDECREF(group_name); - XDECREF(group_index); - XDECREF(npattern); + || PyDict_SetItem(gdict, group_name, group_index) != 0) { + Py_XDECREF(group_name); + Py_XDECREF(group_index); + Py_XDECREF(npattern); return NULL; } ++o; /* eat the '>' */ @@ -468,7 +466,7 @@ symcomp(pattern, gdict) } } - if (resizestring(&npattern, n - getstringvalue(npattern)) == 0) + if (_PyString_Resize(&npattern, n - PyString_AsString(npattern)) == 0) return npattern; else { return NULL; @@ -476,89 +474,89 @@ symcomp(pattern, gdict) } -static object * +static PyObject * regex_symcomp(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - object *pattern; - object *tran = NULL; - object *gdict = NULL; - object *npattern; - if (!getargs(args, "S", &pattern)) { - err_clear(); - if (!getargs(args, "(SS)", &pattern, &tran)) + PyObject *pattern; + PyObject *tran = NULL; + PyObject *gdict = NULL; + PyObject *npattern; + if (!PyArg_Parse(args, "S", &pattern)) { + PyErr_Clear(); + if (!PyArg_Parse(args, "(SS)", &pattern, &tran)) return NULL; } - gdict = newmappingobject(); + gdict = PyDict_New(); if (gdict == NULL || (npattern = symcomp(pattern, gdict)) == NULL) { - DECREF(gdict); - DECREF(pattern); + Py_DECREF(gdict); + Py_DECREF(pattern); return NULL; } return newregexobject(npattern, tran, pattern, gdict); } -static object *cache_pat; -static object *cache_prog; +static PyObject *cache_pat; +static PyObject *cache_prog; static int update_cache(pat) - object *pat; + PyObject *pat; { if (pat != cache_pat) { - XDECREF(cache_pat); + Py_XDECREF(cache_pat); cache_pat = NULL; - XDECREF(cache_prog); - cache_prog = regex_compile((object *)NULL, pat); + Py_XDECREF(cache_prog); + cache_prog = regex_compile((PyObject *)NULL, pat); if (cache_prog == NULL) return -1; cache_pat = pat; - INCREF(cache_pat); + Py_INCREF(cache_pat); } return 0; } -static object * +static PyObject * regex_match(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - object *pat, *string; - if (!getargs(args, "(SS)", &pat, &string)) + PyObject *pat, *string; + if (!PyArg_Parse(args, "(SS)", &pat, &string)) return NULL; if (update_cache(pat) < 0) return NULL; return reg_match((regexobject *)cache_prog, string); } -static object * +static PyObject * regex_search(self, args) - object *self; - object *args; + PyObject *self; + PyObject *args; { - object *pat, *string; - if (!getargs(args, "(SS)", &pat, &string)) + PyObject *pat, *string; + if (!PyArg_Parse(args, "(SS)", &pat, &string)) return NULL; if (update_cache(pat) < 0) return NULL; return reg_search((regexobject *)cache_prog, string); } -static object * +static PyObject * regex_set_syntax(self, args) - object *self, *args; + PyObject *self, *args; { int syntax; - if (!getintarg(args, &syntax)) + if (!PyArg_Parse(args, "i", &syntax)) return NULL; syntax = re_set_syntax(syntax); - return newintobject((long)syntax); + return PyInt_FromLong((long)syntax); } -static struct methodlist regex_global_methods[] = { +static struct PyMethodDef regex_global_methods[] = { {"compile", regex_compile, 0}, {"symcomp", regex_symcomp, 0}, {"match", regex_match, 0}, @@ -569,28 +567,28 @@ static struct methodlist regex_global_methods[] = { initregex() { - object *m, *d, *v; + PyObject *m, *d, *v; - m = initmodule("regex", regex_global_methods); - d = getmoduledict(m); + m = Py_InitModule("regex", regex_global_methods); + d = PyModule_GetDict(m); /* Initialize regex.error exception */ - RegexError = newstringobject("regex.error"); - if (RegexError == NULL || dictinsert(d, "error", RegexError) != 0) - fatal("can't define regex.error"); + RegexError = PyString_FromString("regex.error"); + if (RegexError == NULL || PyDict_SetItemString(d, "error", RegexError) != 0) + Py_FatalError("can't define regex.error"); /* Initialize regex.casefold constant */ - v = newsizedstringobject((char *)NULL, 256); + v = PyString_FromStringAndSize((char *)NULL, 256); if (v != NULL) { int i; - char *s = getstringvalue(v); + char *s = PyString_AsString(v); for (i = 0; i < 256; i++) { if (isupper(i)) s[i] = tolower(i); else s[i] = i; } - dictinsert(d, "casefold", v); - DECREF(v); + PyDict_SetItemString(d, "casefold", v); + Py_DECREF(v); } }