1 #include "rpmsystem-py.h"
3 #include <rpm/rpmtypes.h>
4 #include <rpm/rpmstring.h>
5 #include <rpm/rpmlib.h> /* rpmvercmp */
12 struct rpmdsObject_s {
14 PyObject *md_dict; /*!< to look like PyModuleObject */
21 * Split EVR into epoch, version, and release components.
22 * @param evr [epoch:]version[-release] string
23 * @retval *ep pointer to epoch
24 * @retval *vp pointer to version
25 * @retval *rp pointer to release
28 void rpmds_ParseEVR(char * evr,
34 const char *version; /* assume only version is present */
39 while (*s && risdigit(*s)) s++; /* s points to epoch terminator */
40 se = strrchr(s, '-'); /* se points to version terminator */
46 if (*epoch == '\0') epoch = "0";
48 epoch = NULL; /* XXX disable epoch compare if missing */
59 if (vp) *vp = version;
60 if (rp) *rp = release;
64 rpmds_Count(rpmdsObject * s)
66 return Py_BuildValue("i", rpmdsCount(s->ds));
70 rpmds_Ix(rpmdsObject * s)
72 return Py_BuildValue("i", rpmdsIx(s->ds));
76 rpmds_DNEVR(rpmdsObject * s)
78 return Py_BuildValue("s", rpmdsDNEVR(s->ds));
82 rpmds_N(rpmdsObject * s)
84 return Py_BuildValue("s", rpmdsN(s->ds));
88 rpmds_EVR(rpmdsObject * s)
90 return Py_BuildValue("s", rpmdsEVR(s->ds));
94 rpmds_Flags(rpmdsObject * s)
96 return Py_BuildValue("i", rpmdsFlags(s->ds));
100 rpmds_BT(rpmdsObject * s)
102 return Py_BuildValue("i", (int) rpmdsBT(s->ds));
106 rpmds_TagN(rpmdsObject * s)
108 return Py_BuildValue("i", rpmdsTagN(s->ds));
112 rpmds_Color(rpmdsObject * s)
114 return Py_BuildValue("i", rpmdsColor(s->ds));
118 rpmds_Refs(rpmdsObject * s)
120 return Py_BuildValue("i", rpmdsRefs(s->ds));
123 static int compare_values(const char *str1, const char *str2)
127 else if (str1 && !str2)
129 else if (!str1 && str2)
131 return rpmvercmp(str1, str2);
135 rpmds_compare(rpmdsObject * a, rpmdsObject * b)
137 char *aEVR = xstrdup(rpmdsEVR(a->ds));
138 const char *aE, *aV, *aR;
139 char *bEVR = xstrdup(rpmdsEVR(b->ds));
140 const char *bE, *bV, *bR;
143 /* XXX W2DO? should N be compared? */
144 rpmds_ParseEVR(aEVR, &aE, &aV, &aR);
145 rpmds_ParseEVR(bEVR, &bE, &bV, &bR);
147 rc = compare_values(aE, bE);
149 rc = compare_values(aV, bV);
151 rc = compare_values(aR, bR);
161 rpmds_richcompare(rpmdsObject * a, rpmdsObject * b, int op)
167 /* XXX map ranges overlap boolean onto '!=' python syntax. */
168 rc = rpmdsCompare(a->ds, b->ds);
169 rc = (rc < 0 ? -1 : (rc == 0 ? 1 : 0));
180 return Py_BuildValue("i", rc);
184 rpmds_iternext(rpmdsObject * s)
186 PyObject * result = NULL;
188 /* Reset loop indices on 1st entry. */
190 s->ds = rpmdsInit(s->ds);
194 /* If more to do, return a (N, EVR, Flags) tuple. */
195 if (rpmdsNext(s->ds) >= 0) {
196 const char * N = rpmdsN(s->ds);
197 const char * EVR = rpmdsEVR(s->ds);
198 rpmTag tagN = rpmdsTagN(s->ds);
199 rpmsenseFlags Flags = rpmdsFlags(s->ds);
201 result = rpmds_Wrap(s->ob_type, rpmdsSingle(tagN, N, EVR, Flags) );
209 rpmds_SetNoPromote(rpmdsObject * s, PyObject * args, PyObject * kwds)
212 char * kwlist[] = {"noPromote", NULL};
214 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:SetNoPromote", kwlist,
218 return Py_BuildValue("i", rpmdsSetNoPromote(s->ds, nopromote));
222 rpmds_Notify(rpmdsObject * s, PyObject * args, PyObject * kwds)
226 char * kwlist[] = {"location", "returnCode", NULL};
228 if (!PyArg_ParseTupleAndKeywords(args, kwds, "si:Notify", kwlist,
232 rpmdsNotify(s->ds, where, rc);
236 /* XXX rpmdsFind uses bsearch on s->ds, so a sort is needed. */
238 rpmds_Sort(rpmdsObject * s)
240 /* XXX sort on (N,EVR,F) here. */
245 rpmds_Find(rpmdsObject * s, PyObject * args, PyObject * kwds)
247 PyObject * to = NULL;
250 char * kwlist[] = {"element", NULL};
252 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Find", kwlist, &to))
255 /* XXX ds type check needed. */
256 o = (rpmdsObject *)to;
258 /* XXX make sure ods index is valid, real fix in lib/rpmds.c. */
259 if (rpmdsIx(o->ds) == -1) rpmdsSetIx(o->ds, 0);
261 rc = rpmdsFind(s->ds, o->ds);
262 return Py_BuildValue("i", rc);
266 rpmds_Merge(rpmdsObject * s, PyObject * args, PyObject * kwds)
268 PyObject * to = NULL;
270 char * kwlist[] = {"element", NULL};
272 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Merge", kwlist, &to))
275 /* XXX ds type check needed. */
276 o = (rpmdsObject *)to;
277 return Py_BuildValue("i", rpmdsMerge(&s->ds, o->ds));
280 rpmds_Search(rpmdsObject * s, PyObject * args, PyObject * kwds)
282 PyObject * to = NULL;
284 char * kwlist[] = {"element", NULL};
286 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Merge", kwlist, &to))
289 /* XXX ds type check needed. */
290 o = (rpmdsObject *)to;
291 return Py_BuildValue("i", rpmdsSearch(s->ds, o->ds));
294 static PyObject * rpmds_Rpmlib(rpmdsObject * s)
299 /* XXX check return code, permit arg (NULL uses system default). */
300 xx = rpmdsRpmlib(&ds, NULL);
302 return rpmds_Wrap(&rpmds_Type, ds);
308 rpmds_Compare(rpmdsObject * s, PyObject * args, PyObject * kwds)
310 PyObject * to = NULL;
312 char * kwlist[] = {"other", NULL};
314 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Compare", kwlist, &to))
317 /* XXX ds type check needed. */
318 o = (rpmdsObject *)to;
319 return Py_BuildValue("i", rpmdsCompare(s->ds, o->ds));
323 rpmds_Problem(rpmdsObject * s)
325 if (!PyArg_ParseTuple(args, ":Problem"))
331 static struct PyMethodDef rpmds_methods[] = {
332 {"Count", (PyCFunction)rpmds_Count, METH_NOARGS,
333 "ds.Count -> Count - Return no. of elements.\n" },
334 {"Ix", (PyCFunction)rpmds_Ix, METH_NOARGS,
335 "ds.Ix -> Ix - Return current element index.\n" },
336 {"DNEVR", (PyCFunction)rpmds_DNEVR, METH_NOARGS,
337 "ds.DNEVR -> DNEVR - Return current DNEVR.\n" },
338 {"N", (PyCFunction)rpmds_N, METH_NOARGS,
339 "ds.N -> N - Return current N.\n" },
340 {"EVR", (PyCFunction)rpmds_EVR, METH_NOARGS,
341 "ds.EVR -> EVR - Return current EVR.\n" },
342 {"Flags", (PyCFunction)rpmds_Flags, METH_NOARGS,
343 "ds.Flags -> Flags - Return current Flags.\n" },
344 {"BT", (PyCFunction)rpmds_BT, METH_NOARGS,
345 "ds.BT -> BT - Return build time.\n" },
346 {"TagN", (PyCFunction)rpmds_TagN, METH_NOARGS,
347 "ds.TagN -> TagN - Return current TagN.\n" },
348 {"Color", (PyCFunction)rpmds_Color, METH_NOARGS,
349 "ds.Color -> Color - Return current Color.\n" },
350 {"Refs", (PyCFunction)rpmds_Refs, METH_NOARGS,
351 "ds.Refs -> Refs - Return current Refs.\n" },
352 {"SetNoPromote",(PyCFunction)rpmds_SetNoPromote, METH_VARARGS|METH_KEYWORDS,
354 {"Notify", (PyCFunction)rpmds_Notify, METH_VARARGS|METH_KEYWORDS,
356 {"Sort", (PyCFunction)rpmds_Sort, METH_NOARGS,
358 {"Find", (PyCFunction)rpmds_Find, METH_VARARGS|METH_KEYWORDS,
360 {"Merge", (PyCFunction)rpmds_Merge, METH_VARARGS|METH_KEYWORDS,
362 {"Search", (PyCFunction)rpmds_Search, METH_VARARGS|METH_KEYWORDS,
363 "ds.Search(element) -> matching ds index (-1 on failure)\n\
364 - Check that element dependency range overlaps some member of ds.\n\
365 The current index in ds is positioned at overlapping member upon success.\n" },
366 {"Rpmlib", (PyCFunction)rpmds_Rpmlib, METH_NOARGS|METH_STATIC,
367 "ds.Rpmlib -> nds - Return internal rpmlib dependency set.\n"},
369 {"Compare", (PyCFunction)rpmds_Compare, METH_VARARGS|METH_KEYWORDS,
371 {"Problem", (PyCFunction)rpmds_Problem, METH_NOARGS,
374 {NULL, NULL} /* sentinel */
380 rpmds_dealloc(rpmdsObject * s)
382 s->ds = rpmdsFree(s->ds);
383 s->ob_type->tp_free((PyObject *)s);
387 rpmds_length(rpmdsObject * s)
389 return rpmdsCount(s->ds);
393 rpmds_subscript(rpmdsObject * s, PyObject * key)
397 if (!PyInt_Check(key)) {
398 PyErr_SetString(PyExc_TypeError, "integer expected");
402 ix = (int) PyInt_AsLong(key);
403 rpmdsSetIx(s->ds, ix);
404 return Py_BuildValue("s", rpmdsDNEVR(s->ds));
407 static PyMappingMethods rpmds_as_mapping = {
408 (lenfunc) rpmds_length, /* mp_length */
409 (binaryfunc) rpmds_subscript, /* mp_subscript */
410 (objobjargproc)0, /* mp_ass_subscript */
413 static int rpmds_init(rpmdsObject * s, PyObject *args, PyObject *kwds)
419 static void rpmds_free(rpmdsObject * s)
421 s->ds = rpmdsFree(s->ds);
423 PyObject_Del((PyObject *)s);
426 static PyObject * rpmds_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
428 hdrObject * ho = NULL;
429 rpmTag tagN = RPMTAG_REQUIRENAME;
430 rpmsenseFlags flags = 0;
432 char * kwlist[] = {"header", "tag", "flags", NULL};
434 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O&i:rpmds_new", kwlist,
435 &hdr_Type, &ho, tagNumFromPyObject, &tagN, &flags))
438 ds = rpmdsNew(hdrGetHeader(ho), tagN, 0);
440 return rpmds_Wrap(subtype, ds);
443 static char rpmds_doc[] =
446 PyTypeObject rpmds_Type = {
447 PyObject_HEAD_INIT(&PyType_Type)
449 "rpm.ds", /* tp_name */
450 sizeof(rpmdsObject), /* tp_basicsize */
453 (destructor) rpmds_dealloc, /* tp_dealloc */
455 (getattrfunc)0, /* tp_getattr */
456 (setattrfunc)0, /* tp_setattr */
457 (cmpfunc) rpmds_compare, /* tp_compare */
458 (reprfunc)0, /* tp_repr */
459 0, /* tp_as_number */
460 0, /* tp_as_sequence */
461 &rpmds_as_mapping, /* tp_as_mapping */
462 (hashfunc)0, /* tp_hash */
463 (ternaryfunc)0, /* tp_call */
464 (reprfunc)0, /* tp_str */
465 PyObject_GenericGetAttr, /* tp_getattro */
466 PyObject_GenericSetAttr, /* tp_setattro */
467 0, /* tp_as_buffer */
468 Py_TPFLAGS_DEFAULT | /* tp_flags */
469 Py_TPFLAGS_HAVE_RICHCOMPARE,
470 rpmds_doc, /* tp_doc */
473 (richcmpfunc) rpmds_richcompare,/* tp_richcompare */
474 0, /* tp_weaklistoffset */
475 PyObject_SelfIter, /* tp_iter */
476 (iternextfunc) rpmds_iternext, /* tp_iternext */
477 rpmds_methods, /* tp_methods */
482 0, /* tp_descr_get */
483 0, /* tp_descr_set */
484 0, /* tp_dictoffset */
485 (initproc) rpmds_init, /* tp_init */
487 (newfunc) rpmds_new, /* tp_new */
488 (freefunc) rpmds_free, /* tp_free */
494 rpmds dsFromDs(rpmdsObject * s)
499 PyObject * rpmds_Wrap(PyTypeObject *subtype, rpmds ds)
501 rpmdsObject * s = (rpmdsObject *)subtype->tp_alloc(subtype, 0);
502 if (s == NULL) return PyErr_NoMemory();
506 return (PyObject *) s;
509 PyObject * rpmds_Single(PyObject * s, PyObject * args, PyObject * kwds)
511 rpmTag tagN = RPMTAG_PROVIDENAME;
513 const char * EVR = NULL;
514 rpmsenseFlags Flags = 0;
515 char * kwlist[] = {"to", "name", "evr", "flags", NULL};
517 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&s|si:Single", kwlist,
518 tagNumFromPyObject, &tagN, &N, &EVR, &Flags))
521 return rpmds_Wrap(&rpmds_Type, rpmdsSingle(tagN, N, EVR, Flags));
524 PyObject * hdr_dsFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
526 return PyObject_Call((PyObject *) &rpmds_Type,
527 Py_BuildValue("(O)", s), kwds);
530 PyObject * hdr_dsOfHeader(PyObject * s)
532 hdrObject * ho = (hdrObject *)s;
533 rpmTag tagN = RPMTAG_PROVIDENAME;
534 rpmsenseFlags Flags = RPMSENSE_EQUAL;
536 return rpmds_Wrap(&rpmds_Type, rpmdsThis(hdrGetHeader(ho), tagN, Flags));