00001
00005 #include "system.h"
00006
00007 #include "Python.h"
00008 #ifdef __LCLINT__
00009 #undef PyObject_HEAD
00010 #define PyObject_HEAD int _PyObjectHead;
00011 #endif
00012
00013 #include <rpmlib.h>
00014
00015 #include "header-py.h"
00016 #include "rpmds-py.h"
00017
00018 #include "debug.h"
00019
00020
00021
00022 static PyObject *
00023 rpmds_Debug( rpmdsObject * s, PyObject * args)
00024
00025
00026 {
00027 if (!PyArg_ParseTuple(args, "i", &_rpmds_debug)) return NULL;
00028 Py_INCREF(Py_None);
00029 return Py_None;
00030 }
00031
00032 static PyObject *
00033 rpmds_Count(rpmdsObject * s, PyObject * args)
00034
00035 {
00036 if (!PyArg_ParseTuple(args, ":Count")) return NULL;
00037 return Py_BuildValue("i", rpmdsCount(s->ds));
00038 }
00039
00040 static PyObject *
00041 rpmds_Ix(rpmdsObject * s, PyObject * args)
00042
00043 {
00044 if (!PyArg_ParseTuple(args, ":Ix")) return NULL;
00045 return Py_BuildValue("i", rpmdsIx(s->ds));
00046 }
00047
00048 static PyObject *
00049 rpmds_DNEVR(rpmdsObject * s, PyObject * args)
00050
00051 {
00052 if (!PyArg_ParseTuple(args, ":DNEVR")) return NULL;
00053 return Py_BuildValue("s", rpmdsDNEVR(s->ds));
00054 }
00055
00056 static PyObject *
00057 rpmds_N(rpmdsObject * s, PyObject * args)
00058
00059 {
00060 if (!PyArg_ParseTuple(args, ":N")) return NULL;
00061 return Py_BuildValue("s", rpmdsN(s->ds));
00062 }
00063
00064 static PyObject *
00065 rpmds_EVR(rpmdsObject * s, PyObject * args)
00066
00067 {
00068 if (!PyArg_ParseTuple(args, ":EVR")) return NULL;
00069 return Py_BuildValue("s", rpmdsEVR(s->ds));
00070 }
00071
00072 static PyObject *
00073 rpmds_Flags(rpmdsObject * s, PyObject * args)
00074
00075 {
00076 if (!PyArg_ParseTuple(args, ":Flags")) return NULL;
00077 return Py_BuildValue("i", rpmdsFlags(s->ds));
00078 }
00079
00080 static PyObject *
00081 rpmds_TagN(rpmdsObject * s, PyObject * args)
00082
00083 {
00084 if (!PyArg_ParseTuple(args, ":TagN")) return NULL;
00085 return Py_BuildValue("i", rpmdsTagN(s->ds));
00086 }
00087
00088 static int
00089 rpmds_compare(rpmdsObject * a, rpmdsObject * b)
00090
00091 {
00092 return rpmdsCompare(a->ds, b->ds);
00093 }
00094
00095 static PyObject *
00096 rpmds_iter(rpmdsObject * s)
00097
00098 {
00099 Py_INCREF(s);
00100 return (PyObject *)s;
00101 }
00102
00103 static PyObject *
00104 rpmds_iternext(rpmdsObject * s)
00105
00106
00107 {
00108 PyObject * result = NULL;
00109
00110
00111 if (!s->active) {
00112 rpmdsInit(s->ds);
00113 s->active = 1;
00114 }
00115
00116
00117 if (rpmdsNext(s->ds) >= 0) {
00118 const char * N = rpmdsN(s->ds);
00119 const char * EVR = rpmdsEVR(s->ds);
00120 int Flags = rpmdsFlags(s->ds);
00121
00122 result = PyTuple_New(3);
00123 PyTuple_SET_ITEM(result, 0, Py_BuildValue("s", N));
00124 if (EVR == NULL) {
00125 Py_INCREF(Py_None);
00126 PyTuple_SET_ITEM(result, 1, Py_None);
00127 Py_INCREF(Py_None);
00128 PyTuple_SET_ITEM(result, 2, Py_None);
00129 } else {
00130 PyTuple_SET_ITEM(result, 1, Py_BuildValue("s", EVR));
00131 PyTuple_SET_ITEM(result, 2, PyInt_FromLong(Flags));
00132 }
00133
00134 } else
00135 s->active = 0;
00136
00137 return result;
00138 }
00139
00140 static PyObject *
00141 rpmds_Next(rpmdsObject * s, PyObject *args)
00142
00143
00144 {
00145 PyObject * result;
00146
00147 if (!PyArg_ParseTuple(args, ":Next"))
00148 return NULL;
00149
00150 result = rpmds_iternext(s);
00151
00152 if (result == NULL) {
00153 Py_INCREF(Py_None);
00154 return Py_None;
00155 }
00156 return result;
00157 }
00158
00159 #ifdef NOTYET
00160 static PyObject *
00161 rpmds_Notify(rpmdsObject * s, PyObject * args)
00162
00163 {
00164 if (!PyArg_ParseTuple(args, ":Notify"))
00165 return NULL;
00166 Py_INCREF(Py_None);
00167 return Py_None;
00168 }
00169
00170 static PyObject *
00171 rpmds_Problem(rpmdsObject * s, PyObject * args)
00172
00173 {
00174 if (!PyArg_ParseTuple(args, ":Problem"))
00175 return NULL;
00176 Py_INCREF(Py_None);
00177 return Py_None;
00178 }
00179 #endif
00180
00181
00182
00183 static struct PyMethodDef rpmds_methods[] = {
00184 {"Debug", (PyCFunction)rpmds_Debug, METH_VARARGS,
00185 NULL},
00186 {"Count", (PyCFunction)rpmds_Count, METH_VARARGS,
00187 "ds.Count -> Count - Return no. of elements.\n" },
00188 {"Ix", (PyCFunction)rpmds_Ix, METH_VARARGS,
00189 "ds.Ix -> Ix - Return current element index.\n" },
00190 {"DNEVR", (PyCFunction)rpmds_DNEVR, METH_VARARGS,
00191 "ds.DNEVR -> DNEVR - Return current DNEVR.\n" },
00192 {"N", (PyCFunction)rpmds_N, METH_VARARGS,
00193 "ds.N -> N - Return current N.\n" },
00194 {"EVR", (PyCFunction)rpmds_EVR, METH_VARARGS,
00195 "ds.EVR -> EVR - Return current EVR.\n" },
00196 {"Flags", (PyCFunction)rpmds_Flags, METH_VARARGS,
00197 "ds.Flags -> Flags - Return current Flags.\n" },
00198 {"TagN", (PyCFunction)rpmds_TagN, METH_VARARGS,
00199 "ds.TagN -> TagN - Return current TagN.\n" },
00200 {"next", (PyCFunction)rpmds_Next, METH_VARARGS,
00201 "ds.next() -> (N, EVR, Flags)\n\
00202 - Retrieve next dependency triple.\n" },
00203 #ifdef NOTYET
00204 {"Notify", (PyCFunction)rpmds_Notify, METH_VARARGS,
00205 NULL},
00206 {"Problem", (PyCFunction)rpmds_Problem, METH_VARARGS,
00207 NULL},
00208 #endif
00209 {NULL, NULL}
00210 };
00211
00212
00213
00214
00215 static void
00216 rpmds_dealloc(rpmdsObject * s)
00217
00218 {
00219 if (s) {
00220 s->ds = rpmdsFree(s->ds);
00221 PyMem_DEL(s);
00222 }
00223 }
00224
00225 static int
00226 rpmds_print(rpmdsObject * s, FILE * fp, int flags)
00227
00228
00229 {
00230 if (!(s && s->ds))
00231 return -1;
00232
00233 rpmdsInit(s->ds);
00234 while (rpmdsNext(s->ds) >= 0)
00235 fprintf(fp, "%s\n", rpmdsDNEVR(s->ds));
00236 return 0;
00237 }
00238
00239 static PyObject *
00240 rpmds_getattr(rpmdsObject * s, char * name)
00241
00242 {
00243 return Py_FindMethod(rpmds_methods, (PyObject *)s, name);
00244 }
00245
00246 static int
00247 rpmds_length(rpmdsObject * s)
00248
00249 {
00250 return rpmdsCount(s->ds);
00251 }
00252
00253 static PyObject *
00254 rpmds_subscript(rpmdsObject * s, PyObject * key)
00255
00256 {
00257 int ix;
00258
00259 if (!PyInt_Check(key)) {
00260 PyErr_SetString(PyExc_TypeError, "integer expected");
00261 return NULL;
00262 }
00263
00264 ix = (int) PyInt_AsLong(key);
00265 rpmdsSetIx(s->ds, ix);
00266 return Py_BuildValue("s", rpmdsDNEVR(s->ds));
00267 }
00268
00269 static PyMappingMethods rpmds_as_mapping = {
00270 (inquiry) rpmds_length,
00271 (binaryfunc) rpmds_subscript,
00272 (objobjargproc)0,
00273 };
00274
00277
00278 static char rpmds_doc[] =
00279 "";
00280
00281
00282 PyTypeObject rpmds_Type = {
00283 PyObject_HEAD_INIT(&PyType_Type)
00284 0,
00285 "rpm.ds",
00286 sizeof(rpmdsObject),
00287 0,
00288
00289 (destructor) rpmds_dealloc,
00290 (printfunc) rpmds_print,
00291 (getattrfunc) rpmds_getattr,
00292 (setattrfunc) 0,
00293 (cmpfunc) rpmds_compare,
00294 (reprfunc) 0,
00295 0,
00296 0,
00297 &rpmds_as_mapping,
00298 (hashfunc) 0,
00299 (ternaryfunc) 0,
00300 (reprfunc) 0,
00301 0,
00302 0,
00303 0,
00304 Py_TPFLAGS_DEFAULT,
00305 rpmds_doc,
00306 #if Py_TPFLAGS_HAVE_ITER
00307 0,
00308 0,
00309 0,
00310 0,
00311 (getiterfunc) rpmds_iter,
00312 (iternextfunc) rpmds_iternext,
00313 rpmds_methods,
00314 0,
00315 0,
00316 0,
00317 0,
00318 0,
00319 0,
00320 0,
00321 0,
00322 0,
00323 0,
00324 0,
00325 0,
00326 #endif
00327 };
00328
00329
00330
00331
00332 rpmds dsFromDs(rpmdsObject * s)
00333 {
00334 return s->ds;
00335 }
00336
00337 rpmdsObject *
00338 rpmds_Wrap(rpmds ds)
00339 {
00340 rpmdsObject * s = PyObject_NEW(rpmdsObject, &rpmds_Type);
00341
00342 if (s == NULL)
00343 return NULL;
00344 s->ds = ds;
00345 s->active = 0;
00346 return s;
00347 }
00348
00349 rpmdsObject *
00350 rpmds_Single( PyObject * s, PyObject * args)
00351 {
00352 PyObject * to = NULL;
00353 int tagN = RPMTAG_PROVIDENAME;
00354 const char * N;
00355 const char * EVR = NULL;
00356 int Flags = 0;
00357
00358 if (!PyArg_ParseTuple(args, "Os|si:Single", &to, &N, &EVR, &Flags))
00359 return NULL;
00360 if (to != NULL) {
00361 tagN = tagNumFromPyObject(to);
00362 if (tagN == -1) {
00363 PyErr_SetString(PyExc_KeyError, "unknown header tag");
00364 return NULL;
00365 }
00366 }
00367 return rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
00368 }
00369
00370 rpmdsObject *
00371 hdr_dsFromHeader(PyObject * s, PyObject * args)
00372 {
00373 hdrObject * ho = (hdrObject *)s;
00374 PyObject * to = NULL;
00375 rpmTag tagN = RPMTAG_REQUIRENAME;
00376 int scareMem = 0;
00377
00378 if (!PyArg_ParseTuple(args, "|O:dsFromHeader", &to))
00379 return NULL;
00380 if (to != NULL) {
00381 tagN = tagNumFromPyObject(to);
00382 if (tagN == -1) {
00383 PyErr_SetString(PyExc_KeyError, "unknown header tag");
00384 return NULL;
00385 }
00386 }
00387 return rpmds_Wrap( rpmdsNew(hdrGetHeader(ho), tagN, scareMem) );
00388 }
00389
00390 rpmdsObject *
00391 hdr_dsOfHeader(PyObject * s, PyObject * args)
00392 {
00393 hdrObject * ho = (hdrObject *)s;
00394 int tagN = RPMTAG_PROVIDENAME;
00395 int Flags = RPMSENSE_EQUAL;
00396
00397 if (!PyArg_ParseTuple(args, ":dsOfHeader"))
00398 return NULL;
00399 return rpmds_Wrap( rpmdsThis(hdrGetHeader(ho), tagN, Flags) );
00400 }