static PyObject *kxmeth___init__(PyObject *me, PyObject *arg)
{
- int err;
+ long err;
PyObject *x = 0;
Py_ssize_t n;
n = PyTuple_GET_SIZE(arg);
- if (!PyArg_ParseTuple(arg, "Oi:__init__", &me, &err) ||
- (x = PyInt_FromLong(err)) == 0 ||
- PyObject_SetAttrString(me, "err", x))
- goto end;
+ if (n < 2) TYERR("__init__() takes at least two arguments");
+ me = PyTuple_GET_ITEM(arg, 0);
+ err = PyInt_AsLong(PyTuple_GET_ITEM(arg, 1));
+ if (err == -1 && PyErr_Occurred()) goto end;
+ if (INT_MIN > err || err > INT_MAX) OVFERR("error code out of range");
+
+ x = PyInt_FromLong(err); if (!x) goto end;
+ if (PyObject_SetAttrString(me, "err", x)) goto end;
Py_DECREF(x); x = 0;
- if ((x = PyString_FromString(key_strerror(err))) == 0 ||
- PyObject_SetAttrString(me, "errstring", x))
- goto end;
+
+ x = PyString_FromString(key_strerror(err)); if (!x) goto end;
+ if (PyObject_SetAttrString(me, "errstring", x)) goto end;
Py_DECREF(x); x = 0;
- if ((x = PyTuple_GetSlice(arg, 1, n)) == 0 ||
- PyObject_SetAttrString(me, "args", x))
- goto end;
+
+ x = PyTuple_GetSlice(arg, 1, n); if (!x) goto end;
+ if (PyObject_SetAttrString(me, "args", x)) goto end;
Py_DECREF(x); x = 0;
RETURN_NONE;
return (rc);
}
-static PyMethodDef keyexc_pymethods[] = {
+static const PyMethodDef keyexc_pymethods[] = {
#define METHNAME(func) kxmeth_##func
- METH (__init__, "KeyError(CODE)")
- METH (__str__, "E.__str__() -> STRING")
+ METH (__init__, "KeyError(CODE)")
+ METH (__str__, "E.__str__() -> STRING")
#undef METHNAME
{ 0 }
};
static PyObject *kdmeth_copy(PyObject *me, PyObject *arg, PyObject *kw)
{
key_filter f = { 0, 0 };
- static char *kwlist[] = { "filter", 0 };
+ static const char *const kwlist[] = { "filter", 0 };
key_data *kd;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:copy", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:copy", KWLIST,
convfilter, &f))
return (0);
if ((kd = key_copydata(KEYDATA_KD(me), &f)) == 0)
key_filter f = { 0, 0 };
dstr d = DSTR_INIT;
PyObject *rc = 0;
- static char *kwlist[] = { "filter", 0 };
+ static const char *const kwlist[] = { "filter", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:write", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:write", KWLIST,
convfilter, &f))
return (0);
key_write(KEYDATA_KD(me), &d, &f);
key_filter f = { 0, 0 };
dstr d = DSTR_INIT;
PyObject *rc = 0;
- static char *kwlist[] = { "filter", 0 };
+ static const char *const kwlist[] = { "filter", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:encode", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O&:encode", KWLIST,
convfilter, &f))
return (0);
key_encode(KEYDATA_KD(me), &d, &f);
static PyObject *kdget_flags(PyObject *me, void *hunoz)
{ return (getulong(KEYDATA_KD(me)->e)); }
-static PyMethodDef keydata_pymethods[] = {
+static const PyMethodDef keydata_pymethods[] = {
#define METHNAME(func) kdmeth_##func
- METH (matchp, "KD.matchp(FILTER) -> BOOL")
- METH (split, "KD.split()")
- KWMETH(write, "KD.write([filter = <any>]) -> STRING")
- KWMETH(encode, "KD.encode([filter = <any>]) -> BYTES")
- KWMETH(copy, "KD.copy([filter = <any>]) -> KD")
- METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD")
- METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD")
+ METH (matchp, "KD.matchp(FILTER) -> BOOL")
+ METH (split, "KD.split()")
+ KWMETH(write, "KD.write([filter = <any>]) -> STRING")
+ KWMETH(encode, "KD.encode([filter = <any>]) -> BYTES")
+ KWMETH(copy, "KD.copy([filter = <any>]) -> KD")
+ METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD")
+ METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD")
#undef METHNAME
{ 0 }
};
-static PyGetSetDef keydata_pygetset[] = {
+static const PyGetSetDef keydata_pygetset[] = {
#define GETSETNAME(op, name) kd##op##_##name
- GET (flags, "KD.flags -> FLAGS")
+ GET (flags, "KD.flags -> FLAGS")
#undef GETSETNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data base class.",
+ "Key data base class.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- keydata_pymethods, /* @tp_methods@ */
+ PYMETHODS(keydata), /* @tp_methods@ */
0, /* @tp_members@ */
- keydata_pygetset, /* @tp_getset@ */
+ PYGETSET(keydata), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
Py_ssize_t n;
unsigned f = 0;
keydata_pyobj *me = 0;
- static char *kwlist[] = { "key", "flags", 0 };
+ static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", KWLIST,
&p, &n, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
{ return (bytestring_pywrap(KEYDATA_KD(me)->u.k.k,
KEYDATA_KD(me)->u.k.sz)); }
-static PyGetSetDef keydatabin_pygetset[] = {
+static const PyGetSetDef keydatabin_pygetset[] = {
#define GETSETNAME(op, name) kdb##op##_##name
- GET (bin, "KD.bin -> BYTES")
+ GET (bin, "KD.bin -> BYTES")
#undef GETSETNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data for binary keys.",
+ "KeyDataBinary(KEY, [flags = 0]): key data for binary keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
- keydatabin_pygetset, /* @tp_getset@ */
+ PYGETSET(keydatabin), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
Py_ssize_t n;
unsigned f = 0;
keydata_pyobj *me = 0;
- static char *kwlist[] = { "key", "flags", 0 };
+ static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "s#|O&:new", KWLIST,
&p, &n, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
#define kdeget_ct kdbget_bin
-static PyMethodDef keydataenc_pymethods[] = {
+static const PyMethodDef keydataenc_pymethods[] = {
#define METHNAME(func) kdemeth_##func
- METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD")
- METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD")
- METH (punlock, "KD.punlock(TAG) -> KD")
- METH (unlock, "KD.unlock(KEY) -> KD")
+ METH (plock, "KD.plock(TAG) -> ENCRYPTED-KD")
+ METH (lock, "KD.lock(KEY) -> ENCRYPTED-KD")
+ METH (punlock, "KD.punlock(TAG) -> KD")
+ METH (unlock, "KD.unlock(KEY) -> KD")
#undef METHNAME
{ 0 }
};
-static PyGetSetDef keydataenc_pygetset[] = {
+static const PyGetSetDef keydataenc_pygetset[] = {
#define GETSETNAME(op, name) kde##op##_##name
- GET (ct, "KD.ct -> BYTES")
+ GET (ct, "KD.ct -> BYTES")
#undef GETSETNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data for encrypted keys.",
+ "KeyDataEncrypted(KEY, [flags = 0]): key data for encrypted keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- keydataenc_pymethods, /* @tp_methods@ */
+ PYMETHODS(keydataenc), /* @tp_methods@ */
0, /* @tp_members@ */
- keydataenc_pygetset, /* @tp_getset@ */
+ PYGETSET(keydataenc), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
mp *x = 0;
unsigned f = 0;
keydata_pyobj *me = 0;
- static char *kwlist[] = { "key", "flags", 0 };
+ static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST,
convmp, &x, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
static PyObject *kdmget_mp(PyObject *me, void *hunoz)
{ return (mp_pywrap(MP_COPY(KEYDATA_KD(me)->u.m))); }
-static PyGetSetDef keydatamp_pygetset[] = {
+static const PyGetSetDef keydatamp_pygetset[] = {
#define GETSETNAME(op, name) kdm##op##_##name
- GET (mp, "KD.mp -> X")
+ GET (mp, "KD.mp -> X")
#undef GETSETNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data for large-integer keys.",
+ "KeyDataMP(KEY, [flags = 0]): key data for large-integer keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
- keydatamp_pygetset, /* @tp_getset@ */
+ PYGETSET(keydatamp), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
char *p;
unsigned f = 0;
keydata_pyobj *me = 0;
- static char *kwlist[] = { "key", "flags", 0 };
+ static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O&:new", KWLIST,
&p, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
static PyObject *kdsget_str(PyObject *me, void *hunoz)
{ return (PyString_FromString(KEYDATA_KD(me)->u.p)); }
-static PyGetSetDef keydatastr_pygetset[] = {
+static const PyGetSetDef keydatastr_pygetset[] = {
#define GETSETNAME(op, name) kds##op##_##name
- GET (str, "KD.str -> STRING")
+ GET (str, "KD.str -> STRING")
#undef GETSETNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data for string keys.",
+ "KeyDataString(KEY, [flags = 0]): key data for string keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
- keydatastr_pygetset, /* @tp_getset@ */
+ PYGETSET(keydatastr), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
ec x = EC_INIT;
unsigned f = 0;
keydata_pyobj *me = 0;
- static char *kwlist[] = { "key", "flags", 0 };
+ static const char *const kwlist[] = { "key", "flags", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:new", KWLIST,
convecpt, &x, convflags, &f))
goto end;
me = (keydata_pyobj *)ty->tp_alloc(ty, 0);
return (ecpt_pywrapout(ecpt_pytype, &pt));
}
-static PyGetSetDef keydataec_pygetset[] = {
+static const PyGetSetDef keydataec_pygetset[] = {
#define GETSETNAME(op, name) kde##op##_##name
- GET (ecpt, "KD.ecpt -> ECPT")
+ GET (ecpt, "KD.ecpt -> ECPT")
#undef GETSETNAME
{ 0 }
};
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data for elliptic-curve keys.",
+ "KeyDataECPt(KEY, [flags = 0]): key data for elliptic-curve keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_iternext@ */
0, /* @tp_methods@ */
0, /* @tp_members@ */
- keydataec_pygetset, /* @tp_getset@ */
+ PYGETSET(keydataec), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Iterator for structured keys.",
+ "Iterator for structured keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
char *p;
keydata_pyobj *me = 0;
key_data *kd = 0;
- static char *kwlist[] = { "subkeys", 0 };
+ static const char *const kwlist[] = { "subkeys", 0 };
Py_XINCREF(arg); Py_XINCREF(kw);
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", kwlist, &sub))
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "|O:new", KWLIST, &sub))
goto end;
kd = key_newstruct();
if (sub) {
if ((tag = PyString_AsString(key)) == 0)
goto end;
if ((kd = key_structfind(KEYDATA_KD(me), tag)) == 0)
- INDEXERR(key);
+ MAPERR(key);
key_incref(kd);
rc = keydata_pywrap(kd);
end:
key_structset(KEYDATA_KD(me), tag, KEYDATA_KD(value));
} else {
if (!key_structfind(KEYDATA_KD(me), tag))
- INDEXERR(key);
+ MAPERR(key);
key_structset(KEYDATA_KD(me), tag, 0);
}
rc = 0;
return (rc);
}
-static PyMappingMethods keydatastruct_pymapping = {
+static const PyMappingMethods keydatastruct_pymapping = {
gmap_pysize, /* @mp_length@ */
keydatastruct_pylookup, /* @mp_subscript@ */
keydatastruct_pystore /* @mp_ass_subscript@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
0, /* @tp_as_sequence@ */
- &keydatastruct_pymapping, /* @tp_as_mapping@ */
+ PYMAPPING(keydatastruct), /* @tp_as_mapping@ */
0, /* @tp_hash@ */
0, /* @tp_call@ */
0, /* @tp_str@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key data for structured keys.",
+ "KeyDataStructured([subkeys = []]): key data for structured keys.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
subkeyiter_make, /* @tp_iter@ */
0, /* @tp_iternext@ */
- gmap_pymethods, /* @tp_methods@ */
+ PYMETHODS(gmap), /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
0, /* @tp_base@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Iterator for key attributes.",
+ "Iterator for key attributes.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
if ((attr = PyString_AsString(key)) == 0)
goto end;
if ((value = key_getattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr)) == 0)
- INDEXERR(key);
+ MAPERR(key);
rc = PyString_FromString(value);
end:
return (rc);
KEYERR(err);
} else {
if (!key_getattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr))
- INDEXERR(key);
+ MAPERR(key);
if ((err = key_putattr(KEYATTRS_KF(me), KEYATTRS_K(me), attr, 0)) != 0)
KEYERR(err);
}
FREEOBJ(me);
}
-static PyMappingMethods keyattrs_pymapping = {
+static const PyMappingMethods keyattrs_pymapping = {
gmap_pysize, /* @mp_length@ */
keyattrs_pylookup, /* @mp_subscript@ */
keyattrs_pystore /* @mp_ass_subscript@ */
0, /* @tp_compare@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
- &gmap_pysequence, /* @tp_as_sequence@ */
- &keyattrs_pymapping, /* @tp_as_mapping@ */
+ PYSEQUENCE(gmap), /* @tp_as_sequence@ */
+ PYMAPPING(keyattrs), /* @tp_as_mapping@ */
0, /* @tp_hash@ */
0, /* @tp_call@ */
0, /* @tp_str@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Proxy thing for talking about key attributes.",
+ "Proxy thing for talking about key attributes.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
keyattriter_make, /* @tp_iter@ */
0, /* @tp_iternext@ */
- gmap_pymethods, /* @tp_methods@ */
+ PYMETHODS(gmap), /* @tp_methods@ */
0, /* @tp_members@ */
0, /* @tp_getset@ */
0, /* @tp_base@ */
uint32 id;
char *type;
unsigned long exptime = KEXP_FOREVER;
- static char *kwlist[] = { "keyfile", "id", "type", "exptime", 0 };
+ static const char *const kwlist[] =
+ { "keyfile", "id", "type", "exptime", 0 };
key *k;
int err;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&s|O&:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!O&s|O&:new", KWLIST,
keyfile_pytype, &kfobj, convu32, &id,
&type, convulong, &exptime))
goto end;
PyObject *nameobj;
char *name;
FILE *fp;
- static char *kwlist[] = { "file", "filter", 0 };
+ static const char *const kwlist[] = { "file", "filter", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O&:extract", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O&:extract", KWLIST,
&PyFile_Type, &file,
convfilter, &f) ||
(fp = PyFile_AsFile(file)) == 0 ||
{
ghash *h;
key_filter f = { KF_NONSECRET, KF_NONSECRET };
- static char *kwlist[] = { "hash", "filter", 0 };
+ static const char *const kwlist[] = { "hash", "filter", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:fingerprint", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&|O&:fingerprint", KWLIST,
convghash, &h, convfilter, &f))
return (0);
return (getbool(key_fingerprint(KEY_K(me), h, &f)));
return (-1);
}
-static PyMethodDef key_pymethods[] = {
+static const PyMethodDef key_pymethods[] = {
#define METHNAME(func) kmeth_##func
METH (delete, "KEY.delete()")
METH (expire, "KEY.expire()")
{ 0 }
};
-static PyGetSetDef key_pygetset[] = {
+static const PyGetSetDef key_pygetset[] = {
#define GETSETNAME(op, name) k##op##_##name
GET (file, "KEY.file -> KF")
GET (id, "KEY.id -> ID")
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Key object.",
+ "Key(KF, ID, TYPE, [exptime = KEXP_FOREVER]): key object.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
0, /* @tp_iter@ */
0, /* @tp_iternext@ */
- key_pymethods, /* @tp_methods@ */
+ PYMETHODS(key), /* @tp_methods@ */
0, /* @tp_members@ */
- key_pygetset, /* @tp_getset@ */
+ PYGETSET(key), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Keyring iterator.",
+ "Keyring iterator.",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
char *file = 0;
unsigned how = KOPEN_READ;
keyfile_pyobj *rc = 0;
- static char *kwlist[] = { "file", "how", "report", 0 };
+ static const char *const kwlist[] = { "file", "how", "report", 0 };
Py_XINCREF(arg); Py_XINCREF(kw);
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|iO:new", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|iO:new", KWLIST,
&file, &how, &ri.func))
goto end;
if (ri.func && !PyCallable_Check(ri.func))
PyObject *x = 0;
FILE *fp = 0;
int rc;
- static char *kwlist[] = { "file", "report", 0 };
+ static const char *const kwlist[] = { "file", "report", 0 };
Py_XINCREF(arg); Py_XINCREF(kw);
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O:merge", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O!|O:merge", KWLIST,
&PyFile_Type, &x, &ri.func))
goto end;
if (ri.func && !PyCallable_Check(ri.func))
if (rc == Py_None) {
Py_DECREF(rc);
rc = 0;
- INDEXERR(key);
+ MAPERR(key);
}
end:
return (rc);
uint32 id;
char *type;
long exptime = KEXP_FOREVER;
- static char *kwlist[] = { "id", "type", "exptime", 0 };
+ static const char *const kwlist[] = { "id", "type", "exptime", 0 };
key *k;
int err;
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s|l:newkey", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "O&s|l:newkey", KWLIST,
convu32, &id, &type, &exptime))
goto end;
if ((err = key_new(KEYFILE_KF(me), id, type, exptime, &k)) != 0)
char *tag;
dstr d = DSTR_INIT;
PyObject *rc = 0;
- static char *kwlist[] = { "tag", "new", 0 };
+ static const char *const kwlist[] = { "tag", "new", 0 };
- if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O!:qtag", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(arg, kw, "s|O!:qtag", KWLIST,
&tag, keydata_pytype, &newkdobj))
goto end;
if (key_qtag(KEYFILE_KF(me), tag, &d, &k, &kd))
static PyObject *kfget_filep(PyObject *me, void *hunoz)
{ return (getbool(!!KEYFILE_KF(me)->fp)); }
-static PyMethodDef keyfile_pymethods[] = {
+static const PyMethodDef keyfile_pymethods[] = {
#define METHNAME(func) kfmeth_##func
METH (save, "KF.save()")
KWMETH(merge, "KF.merge(FILE, [report = <built-in-reporter>])")
- KWMETH(newkey, "KF.newkey(ID, TYPE, "
- "[exptime = KEXP_FOREVER]) -> KEY")
+ KWMETH(newkey, "KF.newkey(ID, TYPE, [exptime = KEXP_FOREVER]) "
+ "-> KEY")
METH (byid, "KF.byid(KEYID) -> KEY|None")
METH (bytype, "KF.bytype(TYPE) -> KEY|None")
METH (bytag, "KF.bytag(TAG) -> KEY|None")
{ 0 }
};
-static PyGetSetDef keyfile_pygetset[] = {
+static const PyGetSetDef keyfile_pygetset[] = {
#define GETSETNAME(op, name) kf##op##_##name
GET (name, "KF.name -> file name")
GET (modifiedp, "KF.modifiedp -> has keyring been modified?")
{ 0 }
};
-static PyMappingMethods keyfile_pymapping = {
+static const PyMappingMethods keyfile_pymapping = {
gmap_pysize,
keyfile_pylookup,
0
0, /* @tp_compare@ */
0, /* @tp_repr@ */
0, /* @tp_as_number@ */
- &gmap_pysequence, /* @tp_as_sequence@ */
- &keyfile_pymapping, /* @tp_as_mapping@ */
+ PYSEQUENCE(gmap), /* @tp_as_sequence@ */
+ PYMAPPING(keyfile), /* @tp_as_mapping@ */
0, /* @tp_hash@ */
0, /* @tp_call@ */
0, /* @tp_str@ */
Py_TPFLAGS_BASETYPE,
/* @tp_doc@ */
-"Keyring file.",
+ "KeyFile(FILE, [how = KOPEN_READ], [report = ?]): Keyring file.\n"
+ " calls REPORT(FILE, LINE, MSG) on problems",
0, /* @tp_traverse@ */
0, /* @tp_clear@ */
0, /* @tp_weaklistoffset@ */
keyiter_new, /* @tp_iter@ */
0, /* @tp_iternext@ */
- keyfile_pymethods, /* @tp_methods@ */
+ PYMETHODS(keyfile), /* @tp_methods@ */
0, /* @tp_members@ */
- keyfile_pygetset, /* @tp_getset@ */
+ PYGETSET(keyfile), /* @tp_getset@ */
0, /* @tp_base@ */
0, /* @tp_dict@ */
0, /* @tp_descr_get@ */
/*----- Global stuff ------------------------------------------------------*/
-static PyObject *meth_barf(PyObject *me, PyObject *arg)
-{
- int err;
-
- if (PyArg_ParseTuple(arg, "i:barf", &err))
- KEYERR(err);
-end:
- return (0);
-}
-
static PyMethodDef methods[] = {
#define METHNAME(func) meth_##func
- METH (_KeyData_readflags,
- "KeyData.readflags(STRING) -> (FLAGS, MASK, REST)")
- METH (_KeyData_writeflags, "KeyData.writeflags(FLAGS) -> STRING")
- METH (_KeyData_read, "KeyData.read(STRING) -> (KD, REST)")
- METH (_KeyData_decode, "KeyData.decode(BYTES) -> KD")
- METH (barf, "barf(ERR)")
+ METH (_KeyData_readflags, "KeyData.readflags(STRING) "
+ "-> (FLAGS, MASK, REST)")
+ METH (_KeyData_writeflags, "KeyData.writeflags(FLAGS) -> STRING")
+ METH (_KeyData_read, "KeyData.read(STRING) -> (KD, REST)")
+ METH (_KeyData_decode, "KeyData.decode(BYTES) -> KD")
#undef METHNAME
{ 0 }
};