return NULL;
}
- return hdr_Wrap(h);
+ return hdr_Wrap(subtype, h);
}
static void hdr_dealloc(hdrObject * s)
0, /* tp_is_gc */
};
-PyObject * hdr_Wrap(Header h)
+PyObject * hdr_Wrap(PyTypeObject *subtype, Header h)
{
- hdrObject * hdr = PyObject_New(hdrObject, &hdr_Type);
+ hdrObject * hdr = (hdrObject *)subtype->tp_alloc(subtype, 0);
if (hdr == NULL) return PyErr_NoMemory();
hdr->h = headerLink(h);
while (h) {
headerConvert(h, HEADERCONV_RETROFIT_V3);
- hdr = hdr_Wrap(h);
+ hdr = hdr_Wrap(&hdr_Type, h);
if (PyList_Append(list, (PyObject *) hdr)) {
Py_DECREF(list);
Py_DECREF(hdr);
tuple = PyTuple_New(2);
if (h && tuple) {
- PyTuple_SET_ITEM(tuple, 0, hdr_Wrap(h));
+ PyTuple_SET_ITEM(tuple, 0, hdr_Wrap(&hdr_Type, h));
PyTuple_SET_ITEM(tuple, 1, PyLong_FromLong(offset));
h = headerFree(h);
} else {
extern PyObject * pyrpmError;
-PyObject * hdr_Wrap(Header h);
+PyObject * hdr_Wrap(PyTypeObject *subtype, Header h);
Header hdrGetHeader(hdrObject * h);
rpmTag tagN = rpmdsTagN(s->ds);
rpmsenseFlags Flags = rpmdsFlags(s->ds);
- result = rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
+ result = rpmds_Wrap(s->ob_type, rpmdsSingle(tagN, N, EVR, Flags) );
} else
s->active = 0;
/* XXX check return code, permit arg (NULL uses system default). */
xx = rpmdsRpmlib(&ds, NULL);
- return rpmds_Wrap( ds );
+ return rpmds_Wrap(&rpmds_Type, ds);
}
ds = rpmdsNew(hdrGetHeader(ho), tagN, 0);
- return rpmds_Wrap(ds);
+ return rpmds_Wrap(subtype, ds);
}
static char rpmds_doc[] =
return s->ds;
}
-PyObject * rpmds_Wrap(rpmds ds)
+PyObject * rpmds_Wrap(PyTypeObject *subtype, rpmds ds)
{
- rpmdsObject * s = PyObject_New(rpmdsObject, &rpmds_Type);
+ rpmdsObject * s = (rpmdsObject *)subtype->tp_alloc(subtype, 0);
if (s == NULL) return PyErr_NoMemory();
s->ds = ds;
tagNumFromPyObject, &tagN, &N, &EVR, &Flags))
return NULL;
- return rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
+ return rpmds_Wrap(&rpmds_Type, rpmdsSingle(tagN, N, EVR, Flags));
}
PyObject * hdr_dsFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
rpmTag tagN = RPMTAG_PROVIDENAME;
rpmsenseFlags Flags = RPMSENSE_EQUAL;
- return rpmds_Wrap( rpmdsThis(hdrGetHeader(ho), tagN, Flags) );
+ return rpmds_Wrap(&rpmds_Type, rpmdsThis(hdrGetHeader(ho), tagN, Flags));
}
rpmds dsFromDs(rpmdsObject * ds);
-PyObject * rpmds_Wrap(rpmds ds);
+PyObject * rpmds_Wrap(PyTypeObject *subtype, rpmds ds);
PyObject * rpmds_Single(PyObject * s, PyObject * args, PyObject * kwds);
fi = rpmfiNew(NULL, hdrGetHeader(ho), tagN, flags);
- return rpmfi_Wrap(fi);
+ return rpmfi_Wrap(subtype, fi);
}
static char rpmfi_doc[] =
return s->fi;
}
-PyObject * rpmfi_Wrap(rpmfi fi)
+PyObject * rpmfi_Wrap(PyTypeObject *subtype, rpmfi fi)
{
- rpmfiObject *s = PyObject_New(rpmfiObject, &rpmfi_Type);
+ rpmfiObject *s = (rpmfiObject *)subtype->tp_alloc(subtype, 0);
if (s == NULL) return PyErr_NoMemory();
s->fi = fi;
rpmfi fiFromFi(rpmfiObject * fi);
-PyObject * rpmfi_Wrap(rpmfi fi);
+PyObject * rpmfi_Wrap(PyTypeObject *subtype, rpmfi fi);
#endif
s->mi = rpmdbFreeIterator(s->mi);
return NULL;
}
- return hdr_Wrap(h);
+ return hdr_Wrap(&hdr_Type, h);
}
static PyObject *
0, /* tp_is_gc */
};
-PyObject * rpmmi_Wrap(rpmdbMatchIterator mi, PyObject *s)
+PyObject * rpmmi_Wrap(PyTypeObject *subtype, rpmdbMatchIterator mi, PyObject *s)
{
- rpmmiObject * mio = PyObject_New(rpmmiObject, &rpmmi_Type);
+ rpmmiObject * mio = (rpmmiObject *)subtype->tp_alloc(subtype, 0);
if (mio == NULL) return PyErr_NoMemory();
mio->mi = mi;
#define rpmmiObject_Check(v) ((v)->ob_type == &rpmmi_Type)
-PyObject * rpmmi_Wrap(rpmdbMatchIterator mi, PyObject *s);
+PyObject * rpmmi_Wrap(PyTypeObject *subtype, rpmdbMatchIterator mi, PyObject *s);
#endif
static PyObject * rpmps_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
{
rpmps ps = rpmpsCreate();
- return rpmps_Wrap(ps);
+ return rpmps_Wrap(subtype, ps);
}
static char rpmps_doc[] =
return s->ps;
}
-PyObject * rpmps_Wrap(rpmps ps)
+PyObject * rpmps_Wrap(PyTypeObject *subtype, rpmps ps)
{
- rpmpsObject * s = PyObject_New(rpmpsObject, &rpmps_Type);
+ rpmpsObject * s = (rpmpsObject *)subtype->tp_alloc(subtype, 0);
if (s == NULL) return PyErr_NoMemory();
s->ps = ps; /* XXX refcounts? */
rpmps psFromPs(rpmpsObject * ps);
-PyObject * rpmps_Wrap(rpmps ps);
+PyObject * rpmps_Wrap(PyTypeObject *subtype, rpmps ps);
#endif
Py_RETURN_NONE;
#endif
}
- return rpmds_Wrap(rpmdsLink(ds, RPMDBG_M("rpmte_DS")));
+ return rpmds_Wrap(&rpmds_Type, rpmdsLink(ds, RPMDBG_M("rpmte_DS")));
}
static PyObject *
if (fi == NULL) {
Py_RETURN_NONE;
}
- return rpmfi_Wrap(rpmfiLink(fi, RPMDBG_M("rpmte_FI")));
+ return rpmfi_Wrap(&rpmfi_Type, rpmfiLink(fi, RPMDBG_M("rpmte_FI")));
}
static struct PyMethodDef rpmte_methods[] = {
0, /* tp_is_gc */
};
-PyObject * rpmte_Wrap(rpmte te)
+PyObject * rpmte_Wrap(PyTypeObject *subtype, rpmte te)
{
- rpmteObject *s = PyObject_New(rpmteObject, &rpmte_Type);
+ rpmteObject *s = (rpmteObject *)subtype->tp_alloc(subtype, 0);
if (s == NULL) return PyErr_NoMemory();
s->te = te;
#define rpmteObject_Check(v) ((v)->ob_type == &rpmte_Type)
-PyObject * rpmte_Wrap(rpmte te);
+PyObject * rpmte_Wrap(PyTypeObject *subtype, rpmte te);
#endif
switch (rpmrc) {
case RPMRC_OK:
if (h)
- result = Py_BuildValue("N", hdr_Wrap(h));
+ result = Py_BuildValue("N", hdr_Wrap(&hdr_Type, h));
h = headerFree(h); /* XXX ref held by result */
break;
static PyObject *
rpmts_Problems(rpmtsObject * s)
{
- return rpmps_Wrap( rpmtsProblems(s->ts) );
+ return rpmps_Wrap(&rpmps_Type, rpmtsProblems(s->ts));
}
static PyObject *
te = rpmtsiNext(s->tsi, s->tsiFilter);
if (te != NULL) {
- result = rpmte_Wrap(te);
+ result = rpmte_Wrap(&rpmte_Type, te);
} else {
s->tsi = rpmtsiFree(s->tsi);
s->tsiFilter = 0;
}
}
- return rpmmi_Wrap( rpmtsInitIterator(s->ts, tag, key, len), (PyObject*)s);
+ return rpmmi_Wrap(&rpmmi_Type, rpmtsInitIterator(s->ts, tag, key, len), (PyObject*)s);
}
static struct PyMethodDef rpmts_methods[] = {
* python objects */
(void) rpmtsSetVSFlags(ts, vsflags);
- return rpmts_Wrap(ts);
+ return rpmts_Wrap(subtype, ts);
}
static char rpmts_doc[] =
return PyObject_Call((PyObject *) &rpmts_Type, args, kwds);
}
-PyObject * rpmts_Wrap(rpmts ts)
+PyObject * rpmts_Wrap(PyTypeObject *subtype, rpmts ts)
{
- rpmtsObject * s = PyObject_New(rpmtsObject, &rpmts_Type);
+ rpmtsObject * s = (rpmtsObject *)subtype->tp_alloc(subtype, 0);
if (s == NULL) return PyErr_NoMemory();
s->ts = ts;
RPMDEP_SENSE_CONFLICTS /*!< conflict was found. */
};
-PyObject * rpmts_Wrap(rpmts ts);
+PyObject * rpmts_Wrap(PyTypeObject *subtype, rpmts ts);
PyObject * rpmts_Create(PyObject * s, PyObject * args, PyObject * kwds);
}
rpmtsFree(ts);
- return spec ? spec_Wrap(spec) : NULL;
+ return spec ? spec_Wrap(subtype, spec) : NULL;
}
PyTypeObject spec_Type = {
}
PyObject *
-spec_Wrap(rpmSpec spec)
+spec_Wrap(PyTypeObject *subtype, rpmSpec spec)
{
- specObject * s = PyObject_New(specObject, &spec_Type);
+ specObject * s = (specObject *)subtype->tp_alloc(subtype, 0);
if (s == NULL) return PyErr_NoMemory();
s->spec = spec;
rpmSpec specFromSpec(specObject * spec);
-PyObject * spec_Wrap(rpmSpec spec);
+PyObject * spec_Wrap(PyTypeObject *subtype, rpmSpec spec);
#endif /* RPMPYTHON_SPEC */