static void gcipher_pydealloc(PyObject *me)
{
GC_DESTROY(GCIPHER_C(me));
- Py_DECREF(me->ob_type);
+ Py_DECREF(Py_TYPE(me));
FREEOBJ(me);
}
}
static void gaeadkey_pydealloc(PyObject *me)
- { GAEAD_DESTROY(GAEADKEY_K(me)); Py_DECREF(me->ob_type); FREEOBJ(me); }
+ { GAEAD_DESTROY(GAEADKEY_K(me)); Py_DECREF(Py_TYPE(me)); FREEOBJ(me); }
static PyObject *gcaeget_name(PyObject *me, void *hunoz)
{ return (PyString_FromString(GCAEAD_AEC(me)->name)); }
if (k->ops->c->f&AEADF_AADNDEP)
VALERR("aad must be associated with enc/dec op");
- rc = gaeadaad_pywrap((PyObject *)GCAEAD_AAD(me->ob_type),
+ rc = gaeadaad_pywrap((PyObject *)GCAEAD_AAD(Py_TYPE(me)),
GAEAD_AAD(k), 0, 0);
end:
return (rc);
goto end;
e = GAEAD_ENC(GAEADKEY_K(me), n, nsz, hsz, msz, tsz);
if (!e) VALERR("bad aead parameter combination");
- rc = gaeadenc_pywrap((PyObject *)GCAEAD_ENC(me->ob_type),
+ rc = gaeadenc_pywrap((PyObject *)GCAEAD_ENC(Py_TYPE(me)),
e, f, hsz, msz, tsz);
end:
return (rc);
goto end;
d = GAEAD_DEC(GAEADKEY_K(me), n, nsz, hsz, csz, tsz);
if (!d) VALERR("bad aead parameter combination");
- rc = gaeaddec_pywrap((PyObject *)GCAEAD_DEC(me->ob_type),
+ rc = gaeaddec_pywrap((PyObject *)GCAEAD_DEC(Py_TYPE(me)),
d, f, hsz, csz, tsz);
end:
return (rc);
gaeadaad_pyobj *ga = (gaeadaad_pyobj *)me;
if (ga->a) GAEAD_DESTROY(ga->a);
- Py_DECREF(me->ob_type); FREEOBJ(me);
+ Py_DECREF(Py_TYPE(me)); FREEOBJ(me);
}
static int gaea_check(PyObject *me)
if (gaea_check(me)) goto end;
if (GAEADAAD_F(me)&AEADF_AADNDEP)
VALERR("can't duplicate nonce-dependent aad");
- rc = gaeadaad_pywrap((PyObject *)me->ob_type,
+ rc = gaeadaad_pywrap((PyObject *)Py_TYPE(me),
GAEAD_DUP(GAEADAAD_A(me)), 0, 0);
GAEADAAD_HLEN(rc) = GAEADAAD_HLEN(me);
end:
gaeadenc_pyobj *ge = (gaeadenc_pyobj *)me;
gaea_sever(&ge->aad); GAEAD_DESTROY(ge->e);
- Py_DECREF(me->ob_type); FREEOBJ(me);
+ Py_DECREF(Py_TYPE(me)); FREEOBJ(me);
}
static PyObject *gaeeget_hsz(PyObject *me, void *hunoz)
PyObject *rc = 0;
if (!(ge->f&AEADF_AADNDEP))
- rc = gaeadaad_pywrap((PyObject *)GCAEADENC_KEY(ge->ob_type)->aad,
+ rc = gaeadaad_pywrap((PyObject *)GCAEADENC_KEY(Py_TYPE(ge))->aad,
GAEAD_AAD(ge->e), 0, 0);
else {
if ((ge->f&AEADF_AADFIRST) && ge->mlen)
VALERR("too late for aad");
if (!ge->aad)
ge->aad = (gaeadaad_pyobj *)
- gaeadaad_pywrap((PyObject *)GCAEADENC_KEY(ge->ob_type)->aad,
+ gaeadaad_pywrap((PyObject *)GCAEADENC_KEY(Py_TYPE(ge))->aad,
GAEAD_AAD(ge->e), ge->f&(AEADF_PCHSZ | AEADF_NOAAD),
ge->hsz);
Py_INCREF(ge->aad);
if (tszobj != Py_None && !convszt(tszobj, &tsz)) goto end;
if (aad != Py_None &&
!PyObject_TypeCheck(aad,
- (PyTypeObject *)GCAEADENC_KEY(me->ob_type)->aad))
+ (PyTypeObject *)GCAEADENC_KEY(Py_TYPE(me))->aad))
TYERR("wanted aad");
if ((ge->f&AEADF_AADNDEP) && aad != Py_None && aad != (PyObject *)ge->aad)
VALERR("mismatched aad");
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
gaea_sever(&gd->aad); GAEAD_DESTROY(GAEADDEC_D(me));
- Py_DECREF(me->ob_type); FREEOBJ(me);
+ Py_DECREF(Py_TYPE(me)); FREEOBJ(me);
}
static PyObject *gaedget_hsz(PyObject *me, void *hunoz)
gaeaddec_pyobj *gd = (gaeaddec_pyobj *)me;
if (!(gd->f&AEADF_AADNDEP))
- return (gaeadaad_pywrap((PyObject *)GCAEADDEC_KEY(gd->ob_type)->aad,
+ return (gaeadaad_pywrap((PyObject *)GCAEADDEC_KEY(Py_TYPE(gd))->aad,
GAEAD_AAD(gd->d), 0, 0));
else {
if (!gd->aad)
gd->aad = (gaeadaad_pyobj *)
- gaeadaad_pywrap((PyObject *)GCAEADENC_KEY(gd->ob_type)->aad,
+ gaeadaad_pywrap((PyObject *)GCAEADENC_KEY(Py_TYPE(gd))->aad,
GAEAD_AAD(gd->d), gd->f&(AEADF_PCHSZ | AEADF_NOAAD),
gd->hsz);
Py_INCREF(gd->aad);
goto end;
if (aad != Py_None &&
!PyObject_TypeCheck(aad,
- (PyTypeObject *)GCAEADENC_KEY(me->ob_type)->aad))
+ (PyTypeObject *)GCAEADENC_KEY(Py_TYPE(me))->aad))
TYERR("wanted aad");
if ((gd->f&AEADF_AADNDEP) && aad != Py_None && aad != (PyObject *)gd->aad)
VALERR("mismatched aad");
static void ghash_pydealloc(PyObject *me)
{
GH_DESTROY(GHASH_H(me));
- Py_DECREF(me->ob_type);
+ Py_DECREF(Py_TYPE(me));
FREEOBJ(me);
}
{ return (PyInt_FromLong(GCHASH_CH(me)->bufsz)); }
static PyObject *ghmeth_copy(PyObject *me)
- { return (ghash_pywrap((PyObject *)me->ob_type, GH_COPY(GHASH_H(me)))); }
+ { return (ghash_pywrap((PyObject *)Py_TYPE(me), GH_COPY(GHASH_H(me)))); }
static PyObject *ghmeth_hash(PyObject *me, PyObject *arg)
{
static void gmac_pydealloc(PyObject *me)
{
GM_DESTROY(GMAC_M(me));
- Py_DECREF(me->ob_type);
+ Py_DECREF(Py_TYPE(me));
PyType_Type.tp_dealloc(me);
}
static PyObject *polymeth_copy(PyObject *me)
{
poly1305hash_pyobj *ph;
- ph = PyObject_NEW(poly1305hash_pyobj, me->ob_type);
+ ph = PyObject_NEW(poly1305hash_pyobj, Py_TYPE(me));
poly1305_copy(&ph->ctx, P1305_CTX(me));
- Py_INCREF(me->ob_type);
+ Py_INCREF(Py_TYPE(me));
return ((PyObject *)ph);
}
if (!PyObject_TypeCheck(pre, poly1305hash_pytype) ||
!PyObject_TypeCheck(suff, poly1305hash_pytype))
TYERR("wanted a poly1305hash");
- if (me->ob_type != pre->ob_type || me->ob_type != suff->ob_type)
+ if (Py_TYPE(me) != Py_TYPE(pre) || Py_TYPE(me) != Py_TYPE(suff))
TYERR("key mismatch");
if (P1305_CTX(pre)->nbuf) VALERR("prefix is not block-aligned");
poly1305_concat(P1305_CTX(me), P1305_CTX(pre), P1305_CTX(suff));
static PyObject *kxvikmeth_copy(PyObject *me)
{
kxvik_pyobj *k = (kxvik_pyobj *)me, *rc = 0;
- rc = (kxvik_pyobj *)k->ob_type->tp_alloc(k->ob_type, 0);
+ rc = (kxvik_pyobj *)Py_TYPE(k)->tp_alloc(Py_TYPE(k), 0);
rc->s = k->s; rc->n = k->n;
return ((PyObject *)rc);
}
{
shake_pyobj *rc = 0;
- rc = PyObject_NEW(shake_pyobj, me->ob_type);
+ rc = PyObject_NEW(shake_pyobj, Py_TYPE(me));
rc->h = *SHAKE_H(me);
rc->st = SHAKE_ST(me);
return ((PyObject *)rc);
}
static void gprp_pydealloc(PyObject *me)
- { Py_DECREF(me->ob_type); FREEOBJ(me); }
+ { Py_DECREF(Py_TYPE(me)); FREEOBJ(me); }
static PyObject *gcprp_pywrap(const prpinfo *prp)
{
extern PyTypeObject *fe_pytype;
#define FE_PYCHECK(o) PyObject_TypeCheck((o), fe_pytype)
#define FE_F(o) (((fe_pyobj *)(o))->f)
-#define FE_FOBJ(o) ((PyObject *)(o)->ob_type)
+#define FE_FOBJ(o) ((PyObject *)Py_TYPE(o))
#define FE_X(o) (((fe_pyobj *)(o))->x)
extern PyObject *fe_pywrap(PyObject *, mp *);
#define ECPT_PYCHECK(o) PyObject_TypeCheck((o), ecpt_pytype)
#define ECPTCURVE_PYCHECK(o) PyObject_TypeCheck((o), ecptcurve_pytype)
#define ECPT_C(o) (((ecpt_pyobj *)(o))->c)
-#define ECPT_COBJ(o) ((PyObject *)(o)->ob_type)
+#define ECPT_COBJ(o) ((PyObject *)Py_TYPE(o))
#define ECPT_FOBJ(o) ECCURVE_FOBJ(ECPT_COBJ((o)))
#define ECPT_P(o) (&((ecpt_pyobj *)(o))->p)
extern PyObject *ecpt_pywrap(PyObject *, ec *);
#define GE_PYCHECK(o) PyObject_TypeCheck((o), ge_pytype)
#define GE_X(o) (((ge_pyobj *)(o))->x)
#define GE_G(o) (((ge_pyobj *)(o))->g)
-#define GE_GOBJ(o) ((PyObject *)(group_pyobj *)(o)->ob_type)
+#define GE_GOBJ(o) (PyObject *)(Py_TYPE(o))
extern PyObject *ge_pywrap(PyObject *, ge *);
typedef struct group_pyobj {
mp *x;
mpw *p;
- sz = l->ob_size;
+ sz = Py_SIZE(l);
if (sz < 0) sz = -sz;
assert(MPW_BITS >= SHIFT);
bits = (unsigned long)sz * SHIFT;
w = (bits + MPW_BITS - 1)/MPW_BITS;
- x = mp_new(w, l->ob_size < 0 ? MP_NEG : 0);
+ x = mp_new(w, Py_SIZE(l) < 0 ? MP_NEG : 0);
p = x->v;
for (i = 0; i < sz; i++) {
r |= (mpd)l->ob_digit[i] << b;
l->ob_digit[i++] = r & MASK;
r >>= SHIFT;
}
- l->ob_size = (x->f & MP_NEG) ? -sz : sz;
+ Py_SIZE(l) = (x->f & MP_NEG) ? -sz : sz;
return ((PyObject *)l);
}
if (!o) return (0);
if ((x = tomp(o)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to mp",
- o->ob_type->tp_name);
+ Py_TYPE(o)->tp_name);
}
return (x);
}
if (!o) return (0);
if ((x = tomp(o)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to gf",
- o->ob_type->tp_name);
+ Py_TYPE(o)->tp_name);
}
return (x);
}
if (!good_radix_p(radix, 1)) VALERR("bad radix");
if ((z = mp_frompyobject(x, radix)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to mp",
- x->ob_type->tp_name);
+ Py_TYPE(x)->tp_name);
goto end;
}
zz = (mp_pyobj *)ty->tp_alloc(ty, 0);
if (!good_radix_p(radix, 1)) VALERR("radix out of range");
if ((z = mp_frompyobject(x, radix)) == 0) {
PyErr_Format(PyExc_TypeError, "can't convert %.100s to gf",
- x->ob_type->tp_name);
+ Py_TYPE(x)->tp_name);
goto end;
}
if (MP_NEGP(z)) {