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