traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Converted to new style names by Skip Montanaro

This commit is contained in:
Guido van Rossum 1996-07-24 00:51:20 +00:00
parent 9687a921c8
commit dfe8ad969c
2 changed files with 319 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

259
Modules/bsddbmodule.c
View File

@ -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 <sys/types.h>
#include <sys/stat.h>
@ -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");
}

382
Modules/regexmodule.c
View File

@ -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 <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 */
@ -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);
}
}