• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

python/rpmds-py.c

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

Generated on Fri Dec 3 2010 20:53:50 for rpm by  doxygen 1.7.2