python/rpmds-py.c

Go to the documentation of this file.
00001 
00005 #include "system.h"
00006 
00007 #include <rpmlib.h>
00008 
00009 #include "header-py.h"
00010 #include "rpmds-py.h"
00011 
00012 #include "debug.h"
00013 
00014 /*@access rpmds @*/
00015 
00023 static
00024 void rpmds_ParseEVR(char * evr,
00025                 /*@exposed@*/ /*@out@*/ const char ** ep,
00026                 /*@exposed@*/ /*@out@*/ const char ** vp,
00027                 /*@exposed@*/ /*@out@*/ const char ** rp)
00028         /*@modifies *ep, *vp, *rp @*/
00029         /*@requires maxSet(ep) >= 0 /\ maxSet(vp) >= 0 /\ maxSet(rp) >= 0 @*/
00030 {
00031     const char *epoch;
00032     const char *version;                /* assume only version is present */
00033     const char *release;
00034     char *s, *se;
00035 
00036     s = evr;
00037     while (*s && xisdigit(*s)) s++;     /* s points to epoch terminator */
00038     se = strrchr(s, '-');               /* se points to version terminator */
00039 
00040     if (*s == ':') {
00041         epoch = evr;
00042         *s++ = '\0';
00043         version = s;
00044         /*@-branchstate@*/
00045         if (*epoch == '\0') epoch = "0";
00046         /*@=branchstate@*/
00047     } else {
00048         epoch = NULL;   /* XXX disable epoch compare if missing */
00049         version = evr;
00050     }
00051     if (se) {
00052 /*@-boundswrite@*/
00053         *se++ = '\0';
00054 /*@=boundswrite@*/
00055         release = se;
00056     } else {
00057         release = NULL;
00058     }
00059 
00060     if (ep) *ep = epoch;
00061     if (vp) *vp = version;
00062     if (rp) *rp = release;
00063 }
00064 
00065 /*@null@*/
00066 static PyObject *
00067 rpmds_Debug(/*@unused@*/ rpmdsObject * s, PyObject * args, PyObject * kwds)
00068         /*@globals _Py_NoneStruct @*/
00069         /*@modifies _Py_NoneStruct @*/
00070 {
00071     char * kwlist[] = {"debugLevel", NULL};
00072 
00073     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmds_debug))
00074         return NULL;
00075 
00076     Py_INCREF(Py_None);
00077     return Py_None;
00078 }
00079 
00080 /*@null@*/
00081 static PyObject *
00082 rpmds_Count(rpmdsObject * s)
00083         /*@*/
00084 {
00085     return Py_BuildValue("i", rpmdsCount(s->ds));
00086 }
00087 
00088 /*@null@*/
00089 static PyObject *
00090 rpmds_Ix(rpmdsObject * s)
00091         /*@*/
00092 {
00093     return Py_BuildValue("i", rpmdsIx(s->ds));
00094 }
00095 
00096 /*@null@*/
00097 static PyObject *
00098 rpmds_DNEVR(rpmdsObject * s)
00099         /*@*/
00100 {
00101     return Py_BuildValue("s", rpmdsDNEVR(s->ds));
00102 }
00103 
00104 /*@null@*/
00105 static PyObject *
00106 rpmds_N(rpmdsObject * s)
00107         /*@*/
00108 {
00109     return Py_BuildValue("s", rpmdsN(s->ds));
00110 }
00111 
00112 /*@null@*/
00113 static PyObject *
00114 rpmds_EVR(rpmdsObject * s)
00115         /*@*/
00116 {
00117     return Py_BuildValue("s", rpmdsEVR(s->ds));
00118 }
00119 
00120 /*@null@*/
00121 static PyObject *
00122 rpmds_Flags(rpmdsObject * s)
00123         /*@*/
00124 {
00125     return Py_BuildValue("i", rpmdsFlags(s->ds));
00126 }
00127 
00128 /*@null@*/
00129 static PyObject *
00130 rpmds_BT(rpmdsObject * s)
00131         /*@*/
00132 {
00133     return Py_BuildValue("i", (int) rpmdsBT(s->ds));
00134 }
00135 
00136 /*@null@*/
00137 static PyObject *
00138 rpmds_TagN(rpmdsObject * s)
00139         /*@*/
00140 {
00141     return Py_BuildValue("i", rpmdsTagN(s->ds));
00142 }
00143 
00144 /*@null@*/
00145 static PyObject *
00146 rpmds_Color(rpmdsObject * s)
00147         /*@*/
00148 {
00149     return Py_BuildValue("i", rpmdsColor(s->ds));
00150 }
00151 
00152 /*@null@*/
00153 static PyObject *
00154 rpmds_Refs(rpmdsObject * s)
00155         /*@*/
00156 {
00157     return Py_BuildValue("i", rpmdsRefs(s->ds));
00158 }
00159 
00162 static int compare_values(const char *str1, const char *str2)
00163 {
00164     if (!str1 && !str2)
00165         return 0;
00166     else if (str1 && !str2)
00167         return 1;
00168     else if (!str1 && str2)
00169         return -1;
00170     return rpmvercmp(str1, str2);
00171 }
00172 
00173 static int
00174 rpmds_compare(rpmdsObject * a, rpmdsObject * b)
00175         /*@*/
00176 {
00177     char *aEVR = xstrdup(rpmdsEVR(a->ds));
00178     const char *aE, *aV, *aR;
00179     char *bEVR = xstrdup(rpmdsEVR(b->ds));
00180     const char *bE, *bV, *bR;
00181     int rc;
00182 
00183     /* XXX W2DO? should N be compared? */
00184     rpmds_ParseEVR(aEVR, &aE, &aV, &aR);
00185     rpmds_ParseEVR(bEVR, &bE, &bV, &bR);
00186 
00187     rc = compare_values(aE, bE);
00188     if (!rc) {
00189         rc = compare_values(aV, bV);
00190         if (!rc)
00191             rc = compare_values(aR, bR);
00192     }
00193 
00194     aEVR = _free(aEVR);
00195     bEVR = _free(bEVR);
00196 
00197     return rc;
00198 }
00199 
00200 static PyObject *
00201 rpmds_richcompare(rpmdsObject * a, rpmdsObject * b, int op)
00202         /*@*/
00203 {
00204     int rc;
00205 
00206     switch (op) {
00207     case Py_NE:
00208         /* XXX map ranges overlap boolean onto '!=' python syntax. */
00209         rc = rpmdsCompare(a->ds, b->ds);
00210         rc = (rc < 0 ? -1 : (rc == 0 ? 1 : 0));
00211         break;
00212     case Py_LT:
00213     case Py_LE:
00214     case Py_GT:
00215     case Py_GE:
00216     case Py_EQ:
00217         /*@fallthrough@*/
00218     default:
00219         rc = -1;
00220         break;
00221     }
00222     return Py_BuildValue("i", rc);
00223 }
00224 
00225 static PyObject *
00226 rpmds_iter(rpmdsObject * s)
00227         /*@*/
00228 {
00229     Py_INCREF(s);
00230     return (PyObject *)s;
00231 }
00232 
00233 /*@null@*/
00234 static PyObject *
00235 rpmds_iternext(rpmdsObject * s)
00236         /*@modifies s @*/
00237 {
00238     PyObject * result = NULL;
00239 
00240     /* Reset loop indices on 1st entry. */
00241     if (!s->active) {
00242         s->ds = rpmdsInit(s->ds);
00243         s->active = 1;
00244     }
00245 
00246     /* If more to do, return a (N, EVR, Flags) tuple. */
00247     if (rpmdsNext(s->ds) >= 0) {
00248         const char * N = rpmdsN(s->ds);
00249         const char * EVR = rpmdsEVR(s->ds);
00250         int tagN = rpmdsTagN(s->ds);
00251         int Flags = rpmdsFlags(s->ds);
00252 
00253 /*@-branchstate@*/
00254         if (N != NULL) N = xstrdup(N);
00255         if (EVR != NULL) EVR = xstrdup(EVR);
00256 /*@=branchstate@*/
00257         result = rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
00258     } else
00259         s->active = 0;
00260 
00261     return result;
00262 }
00263 
00264 /*@null@*/
00265 static PyObject *
00266 rpmds_Next(rpmdsObject * s)
00267         /*@globals _Py_NoneStruct @*/
00268         /*@modifies s, _Py_NoneStruct @*/
00269 {
00270     PyObject * result;
00271 
00272     result = rpmds_iternext(s);
00273 
00274     if (result == NULL) {
00275         Py_INCREF(Py_None);
00276         return Py_None;
00277     }
00278     return result;
00279 }
00280 
00281 /*@null@*/
00282 static PyObject *
00283 rpmds_SetNoPromote(rpmdsObject * s, PyObject * args, PyObject * kwds)
00284         /*@modifies s @*/
00285 {
00286     int nopromote;
00287     char * kwlist[] = {"noPromote", NULL};
00288 
00289     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:SetNoPromote", kwlist,
00290             &nopromote))
00291         return NULL;
00292 
00293     return Py_BuildValue("i", rpmdsSetNoPromote(s->ds, nopromote));
00294 }
00295 
00296 /*@null@*/
00297 static PyObject *
00298 rpmds_Notify(rpmdsObject * s, PyObject * args, PyObject * kwds)
00299         /*@globals _Py_NoneStruct @*/
00300         /*@modifies _Py_NoneStruct @*/
00301 {
00302     const char * where;
00303     int rc;
00304     char * kwlist[] = {"location", "returnCode", NULL};
00305 
00306     if (!PyArg_ParseTupleAndKeywords(args, kwds, "si:Notify", kwlist,
00307             &where, &rc))
00308         return NULL;
00309 
00310     rpmdsNotify(s->ds, where, rc);
00311     Py_INCREF(Py_None);
00312     return Py_None;
00313 }
00314 
00315 /* XXX rpmdsFind uses bsearch on s->ds, so a sort is needed. */
00316 /*@null@*/
00317 static PyObject *
00318 rpmds_Sort(rpmdsObject * s)
00319         /*@globals _Py_NoneStruct @*/
00320         /*@modifies _Py_NoneStruct @*/
00321 {
00322     /* XXX sort on (N,EVR,F) here. */
00323     Py_INCREF(Py_None);
00324     return Py_None;
00325 }
00326 
00327 /*@null@*/
00328 static PyObject *
00329 rpmds_Find(rpmdsObject * s, PyObject * args, PyObject * kwds)
00330         /*@modifies s @*/
00331 {
00332     PyObject * to = NULL;
00333     rpmdsObject * o;
00334     int rc;
00335     char * kwlist[] = {"element", NULL};
00336 
00337     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Find", kwlist, &to))
00338         return NULL;
00339 
00340     /* XXX ds type check needed. */
00341     o = (rpmdsObject *)to;
00342 
00343     /* XXX make sure ods index is valid, real fix in lib/rpmds.c. */
00344     if (rpmdsIx(o->ds) == -1)   rpmdsSetIx(o->ds, 0);
00345 
00346     rc = rpmdsFind(s->ds, o->ds);
00347     return Py_BuildValue("i", rc);
00348 }
00349 
00350 /*@null@*/
00351 static PyObject *
00352 rpmds_Merge(rpmdsObject * s, PyObject * args, PyObject * kwds)
00353         /*@modifies s @*/
00354 {
00355     PyObject * to = NULL;
00356     rpmdsObject * o;
00357     char * kwlist[] = {"element", NULL};
00358 
00359     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Merge", kwlist, &to))
00360         return NULL;
00361 
00362     /* XXX ds type check needed. */
00363     o = (rpmdsObject *)to;
00364     return Py_BuildValue("i", rpmdsMerge(&s->ds, o->ds));
00365 }
00366 
00367 #ifdef  NOTYET
00368 static PyObject *
00369 rpmds_Compare(rpmdsObject * s, PyObject * args, PyObject * kwds)
00370         /*@modifies s @*/
00371 {
00372     PyObject * to = NULL;
00373     rpmdsObject * o;
00374     char * kwlist[] = {"other", NULL};
00375 
00376     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Compare", kwlist, &to))
00377         return NULL;
00378 
00379     /* XXX ds type check needed. */
00380     o = (rpmdsObject *)to;
00381     return Py_BuildValue("i", rpmdsCompare(s->ds, o->ds));
00382 }
00383 
00384 /*@null@*/
00385 static PyObject *
00386 rpmds_Problem(rpmdsObject * s)
00387         /*@*/
00388 {
00389     if (!PyArg_ParseTuple(args, ":Problem"))
00390         return NULL;
00391     Py_INCREF(Py_None);
00392     return Py_None;
00393 }
00394 #endif
00395 
00396 /*@-fullinitblock@*/
00397 /*@unchecked@*/ /*@observer@*/
00398 static struct PyMethodDef rpmds_methods[] = {
00399  {"Debug",      (PyCFunction)rpmds_Debug,       METH_VARARGS|METH_KEYWORDS,
00400         NULL},
00401  {"Count",      (PyCFunction)rpmds_Count,       METH_NOARGS,
00402         "ds.Count -> Count      - Return no. of elements.\n" },
00403  {"Ix",         (PyCFunction)rpmds_Ix,          METH_NOARGS,
00404         "ds.Ix -> Ix            - Return current element index.\n" },
00405  {"DNEVR",      (PyCFunction)rpmds_DNEVR,       METH_NOARGS,
00406         "ds.DNEVR -> DNEVR      - Return current DNEVR.\n" },
00407  {"N",          (PyCFunction)rpmds_N,           METH_NOARGS,
00408         "ds.N -> N              - Return current N.\n" },
00409  {"EVR",        (PyCFunction)rpmds_EVR,         METH_NOARGS,
00410         "ds.EVR -> EVR          - Return current EVR.\n" },
00411  {"Flags",      (PyCFunction)rpmds_Flags,       METH_NOARGS,
00412         "ds.Flags -> Flags      - Return current Flags.\n" },
00413  {"BT",         (PyCFunction)rpmds_BT,          METH_NOARGS,
00414         "ds.BT -> BT    - Return build time.\n" },
00415  {"TagN",       (PyCFunction)rpmds_TagN,        METH_NOARGS,
00416         "ds.TagN -> TagN        - Return current TagN.\n" },
00417  {"Color",      (PyCFunction)rpmds_Color,       METH_NOARGS,
00418         "ds.Color -> Color      - Return current Color.\n" },
00419  {"Refs",       (PyCFunction)rpmds_Refs,        METH_NOARGS,
00420         "ds.Refs -> Refs        - Return current Refs.\n" },
00421  {"next",       (PyCFunction)rpmds_Next,        METH_NOARGS,
00422 "ds.next() -> (N, EVR, Flags)\n\
00423 - Retrieve next dependency triple.\n" },
00424  {"SetNoPromote",(PyCFunction)rpmds_SetNoPromote, METH_VARARGS|METH_KEYWORDS,
00425         NULL},
00426  {"Notify",     (PyCFunction)rpmds_Notify,      METH_VARARGS|METH_KEYWORDS,
00427         NULL},
00428  {"Sort",       (PyCFunction)rpmds_Sort,        METH_NOARGS,
00429         NULL},
00430  {"Find",       (PyCFunction)rpmds_Find,        METH_VARARGS|METH_KEYWORDS,
00431         NULL},
00432  {"Merge",      (PyCFunction)rpmds_Merge,       METH_VARARGS|METH_KEYWORDS,
00433         NULL},
00434 #ifdef  NOTYET
00435  {"Compare",    (PyCFunction)rpmds_Compare,     METH_VARARGS|METH_KEYWORDS,
00436         NULL},
00437  {"Problem",    (PyCFunction)rpmds_Problem,     METH_NOARGS,
00438         NULL},
00439 #endif
00440  {NULL,         NULL}           /* sentinel */
00441 };
00442 /*@=fullinitblock@*/
00443 
00444 /* ---------- */
00445 
00446 static void
00447 rpmds_dealloc(rpmdsObject * s)
00448         /*@modifies s @*/
00449 {
00450     if (s) {
00451         s->ds = rpmdsFree(s->ds);
00452         PyObject_Del(s);
00453     }
00454 }
00455 
00456 static int
00457 rpmds_print(rpmdsObject * s, FILE * fp, /*@unused@*/ int flags)
00458         /*@globals fileSystem @*/
00459         /*@modifies s, fp, fileSystem @*/
00460 {
00461     s->ds = rpmdsInit(s->ds);
00462     while (rpmdsNext(s->ds) >= 0)
00463         fprintf(fp, "%s\n", rpmdsDNEVR(s->ds));
00464     return 0;
00465 }
00466 
00467 static PyObject * rpmds_getattro(PyObject * o, PyObject * n)
00468         /*@*/
00469 {
00470     return PyObject_GenericGetAttr(o, n);
00471 }
00472 
00473 static int rpmds_setattro(PyObject * o, PyObject * n, PyObject * v)
00474         /*@*/
00475 {
00476     return PyObject_GenericSetAttr(o, n, v);
00477 }
00478 
00479 static int
00480 rpmds_length(rpmdsObject * s)
00481         /*@*/
00482 {
00483     return rpmdsCount(s->ds);
00484 }
00485 
00486 /*@null@*/
00487 static PyObject *
00488 rpmds_subscript(rpmdsObject * s, PyObject * key)
00489         /*@modifies s @*/
00490 {
00491     int ix;
00492 
00493     if (!PyInt_Check(key)) {
00494         PyErr_SetString(PyExc_TypeError, "integer expected");
00495         return NULL;
00496     }
00497 
00498     ix = (int) PyInt_AsLong(key);
00499     /* XXX make sure that DNEVR exists. */
00500     rpmdsSetIx(s->ds, ix-1);
00501     (void) rpmdsNext(s->ds);
00502     return Py_BuildValue("s", rpmdsDNEVR(s->ds));
00503 }
00504 
00505 static PyMappingMethods rpmds_as_mapping = {
00506         (inquiry) rpmds_length,         /* mp_length */
00507         (binaryfunc) rpmds_subscript,   /* mp_subscript */
00508         (objobjargproc)0,               /* mp_ass_subscript */
00509 };
00510 
00513 static int rpmds_init(rpmdsObject * s, PyObject *args, PyObject *kwds)
00514         /*@globals rpmGlobalMacroContext @*/
00515         /*@modifies s, rpmGlobalMacroContext @*/
00516 {
00517     hdrObject * ho = NULL;
00518     PyObject * to = NULL;
00519     int tagN = RPMTAG_REQUIRENAME;
00520     int flags = 0;
00521     char * kwlist[] = {"header", "tag", "flags", NULL};
00522 
00523 if (_rpmds_debug < 0)
00524 fprintf(stderr, "*** rpmds_init(%p,%p,%p)\n", s, args, kwds);
00525 
00526     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oi:rpmds_init", kwlist, 
00527             &hdr_Type, &ho, &to, &flags))
00528         return -1;
00529 
00530     if (to != NULL) {
00531         tagN = tagNumFromPyObject(to);
00532         if (tagN == -1) {
00533             PyErr_SetString(PyExc_KeyError, "unknown header tag");
00534             return -1;
00535         }
00536     }
00537     s->ds = rpmdsNew(hdrGetHeader(ho), tagN, flags);
00538     s->active = 0;
00539 
00540     return 0;
00541 }
00542 
00545 static void rpmds_free(/*@only@*/ rpmdsObject * s)
00546         /*@modifies s @*/
00547 {
00548 if (_rpmds_debug)
00549 fprintf(stderr, "%p -- ds %p\n", s, s->ds);
00550     s->ds = rpmdsFree(s->ds);
00551 
00552     PyObject_Del((PyObject *)s);
00553 }
00554 
00557 static PyObject * rpmds_alloc(PyTypeObject * subtype, int nitems)
00558         /*@*/
00559 {
00560     PyObject * s = PyType_GenericAlloc(subtype, nitems);
00561 
00562 if (_rpmds_debug < 0)
00563 fprintf(stderr, "*** rpmds_alloc(%p,%d) ret %p\n", subtype, nitems, s);
00564     return s;
00565 }
00566 
00569 /*@null@*/
00570 static PyObject * rpmds_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
00571         /*@globals rpmGlobalMacroContext @*/
00572         /*@modifies rpmGlobalMacroContext @*/
00573 {
00574     rpmdsObject * s = (void *) PyObject_New(rpmdsObject, subtype);
00575 
00576     /* Perform additional initialization. */
00577     if (rpmds_init(s, args, kwds) < 0) {
00578         rpmds_free(s);
00579         return NULL;
00580     }
00581 
00582 if (_rpmds_debug)
00583 fprintf(stderr, "%p ++ ds %p\n", s, s->ds);
00584 
00585     return (PyObject *)s;
00586 }
00587 
00590 /*@unchecked@*/ /*@observer@*/
00591 static char rpmds_doc[] =
00592 "";
00593 
00594 /*@-fullinitblock@*/
00595 PyTypeObject rpmds_Type = {
00596         PyObject_HEAD_INIT(&PyType_Type)
00597         0,                              /* ob_size */
00598         "rpm.ds",                       /* tp_name */
00599         sizeof(rpmdsObject),            /* tp_basicsize */
00600         0,                              /* tp_itemsize */
00601         /* methods */
00602         (destructor) rpmds_dealloc,     /* tp_dealloc */
00603         (printfunc) rpmds_print,        /* tp_print */
00604         (getattrfunc)0,                 /* tp_getattr */
00605         (setattrfunc)0,                 /* tp_setattr */
00606         (cmpfunc) rpmds_compare,        /* tp_compare */
00607         (reprfunc)0,                    /* tp_repr */
00608         0,                              /* tp_as_number */
00609         0,                              /* tp_as_sequence */
00610         &rpmds_as_mapping,              /* tp_as_mapping */
00611         (hashfunc)0,                    /* tp_hash */
00612         (ternaryfunc)0,                 /* tp_call */
00613         (reprfunc)0,                    /* tp_str */
00614         (getattrofunc) rpmds_getattro,  /* tp_getattro */
00615         (setattrofunc) rpmds_setattro,  /* tp_setattro */
00616         0,                              /* tp_as_buffer */
00617         Py_TPFLAGS_DEFAULT |            /* tp_flags */
00618             Py_TPFLAGS_HAVE_RICHCOMPARE,
00619         rpmds_doc,                      /* tp_doc */
00620 #if Py_TPFLAGS_HAVE_ITER
00621         0,                              /* tp_traverse */
00622         0,                              /* tp_clear */
00623         (richcmpfunc) rpmds_richcompare,/* tp_richcompare */
00624         0,                              /* tp_weaklistoffset */
00625         (getiterfunc) rpmds_iter,       /* tp_iter */
00626         (iternextfunc) rpmds_iternext,  /* tp_iternext */
00627         rpmds_methods,                  /* tp_methods */
00628         0,                              /* tp_members */
00629         0,                              /* tp_getset */
00630         0,                              /* tp_base */
00631         0,                              /* tp_dict */
00632         0,                              /* tp_descr_get */
00633         0,                              /* tp_descr_set */
00634         0,                              /* tp_dictoffset */
00635         (initproc) rpmds_init,          /* tp_init */
00636         (allocfunc) rpmds_alloc,        /* tp_alloc */
00637         (newfunc) rpmds_new,            /* tp_new */
00638         rpmds_free,                     /* tp_free */
00639         0,                              /* tp_is_gc */
00640 #endif
00641 };
00642 /*@=fullinitblock@*/
00643 
00644 /* ---------- */
00645 
00646 rpmds dsFromDs(rpmdsObject * s)
00647 {
00648     return s->ds;
00649 }
00650 
00651 rpmdsObject *
00652 rpmds_Wrap(rpmds ds)
00653 {
00654     rpmdsObject * s = PyObject_New(rpmdsObject, &rpmds_Type);
00655 
00656     if (s == NULL)
00657         return NULL;
00658     s->ds = ds;
00659     s->active = 0;
00660     return s;
00661 }
00662 
00663 rpmdsObject *
00664 rpmds_Single(/*@unused@*/ PyObject * s, PyObject * args, PyObject * kwds)
00665 {
00666     PyObject * to = NULL;
00667     int tagN = RPMTAG_PROVIDENAME;
00668     const char * N;
00669     const char * EVR = NULL;
00670     int Flags = 0;
00671     char * kwlist[] = {"to", "name", "evr", "flags", NULL};
00672 
00673     if (!PyArg_ParseTupleAndKeywords(args, kwds, "Os|si:Single", kwlist,
00674             &to, &N, &EVR, &Flags))
00675         return NULL;
00676 
00677     if (to != NULL) {
00678         tagN = tagNumFromPyObject(to);
00679         if (tagN == -1) {
00680             PyErr_SetString(PyExc_KeyError, "unknown header tag");
00681             return NULL;
00682         }
00683     }
00684     if (N != NULL) N = xstrdup(N);
00685     if (EVR != NULL) EVR = xstrdup(EVR);
00686     return rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
00687 }
00688 
00689 rpmdsObject *
00690 hdr_dsFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
00691 {
00692     hdrObject * ho = (hdrObject *)s;
00693     PyObject * to = NULL;
00694     rpmTag tagN = RPMTAG_REQUIRENAME;
00695     int flags = 0;
00696     char * kwlist[] = {"to", "flags", NULL};
00697 
00698     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:dsFromHeader", kwlist,
00699             &to, &flags))
00700         return NULL;
00701 
00702     if (to != NULL) {
00703         tagN = tagNumFromPyObject(to);
00704         if (tagN == -1) {
00705             PyErr_SetString(PyExc_KeyError, "unknown header tag");
00706             return NULL;
00707         }
00708     }
00709     return rpmds_Wrap( rpmdsNew(hdrGetHeader(ho), tagN, flags) );
00710 }
00711 
00712 rpmdsObject *
00713 hdr_dsOfHeader(PyObject * s)
00714 {
00715     hdrObject * ho = (hdrObject *)s;
00716     int tagN = RPMTAG_PROVIDENAME;
00717     int Flags = RPMSENSE_EQUAL;
00718 
00719     return rpmds_Wrap( rpmdsThis(hdrGetHeader(ho), tagN, Flags) );
00720 }

Generated on 9 Jan 2013 for rpm by  doxygen 1.4.7