- support more open flags
*/
-#include "allobjects.h"
-#include "modsupport.h"
+#include "Python.h"
#include <sys/types.h>
#include <sys/stat.h>
(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;
bsddbobject *dp;
HASHINFO info;
- if ((dp = NEWOBJ(bsddbobject, &Bsddbtype)) == NULL)
+ if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
return NULL;
info.bsize = bsize;
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;
bsddbobject *dp;
BTREEINFO info;
- if ((dp = NEWOBJ(bsddbobject, &Bsddbtype)) == NULL)
+ if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
return NULL;
info.flags = btflags;
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;
bsddbobject *dp;
RECNOINFO info;
- if ((dp = NEWOBJ(bsddbobject, &Bsddbtype)) == NULL)
+ if ((dp = PyObject_NEW(bsddbobject, &Bsddbtype)) == NULL)
return NULL;
info.flags = rnflags;
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;
}
fprintf(stderr,
"Python bsddb: close errno %s in dealloc\n", errno);
}
- DEL(dp);
+ PyMem_DEL(dp);
}
static int
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;
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;
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;
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;
}
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;
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;
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),
&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;
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;
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;
}
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
}
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;
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))
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;
}
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
}
psize, lorder);
}
-static object *
+static PyObject *
bsdrnopen(self, args)
- object *self;
- object *args;
+ PyObject *self;
+ PyObject *args;
{
char *file;
char *flag = NULL;
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))
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;
}
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;
}
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");
}
/* 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 <ctype.h>
-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 */
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
|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*/
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) {
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 '>' */
}
}
- if (resizestring(&npattern, n - getstringvalue(npattern)) == 0)
+ if (_PyString_Resize(&npattern, n - PyString_AsString(npattern)) == 0)
return npattern;
else {
return NULL;
}
-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},
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);
}
}
projects / python / commitdiff