自学教程：C++ CHECK_CONTEXT函数代码示例

static PyObject *GMPy_Real_Div_2exp(PyObject *x, PyObject *y, CTXT_Object *context){    MPFR_Object *result, *tempx;    unsigned long exp = 0;    CHECK_CONTEXT(context);    exp = c_ulong_From_Integer(y);    if (exp == (unsigned long)(-1) && PyErr_Occurred()) {        return NULL;    }        result = GMPy_MPFR_New(0, context);    tempx = GMPy_MPFR_From_Real(x, 1, context);    if (!result || !tempx) {        Py_XDECREF((PyObject*)result);        Py_XDECREF((PyObject*)tempx);        return NULL;    }    mpfr_clear_flags();    result->rc = mpfr_div_2ui(result->f, tempx->f, exp, GET_MPFR_ROUND(context));    Py_DECREF((PyObject*)tempx);    GMPY_MPFR_CLEANUP(result, context, "div_2exp()");    return (PyObject*)result;}

static PyObject *GMPy_Complex_Is_NAN(PyObject *x, CTXT_Object *context){    MPC_Object *tempx;    int res;    if (MPC_Check(x)) {        res = MPC_IS_NAN_P(x);    }    else {        CHECK_CONTEXT(context);        if (!(tempx = GMPy_MPC_From_Complex(x, 1, 1, context))) {            return NULL;        }        res = MPC_IS_NAN_P(tempx);        Py_DECREF((PyObject*)tempx);    }    if (res) {        Py_RETURN_TRUE;    }    else {        Py_RETURN_FALSE;    }}

static PyObject *GMPy_Complex_Mul_2exp(PyObject *x, PyObject *y, CTXT_Object *context){    MPC_Object *result, *tempx;    unsigned long exp = 0;    CHECK_CONTEXT(context);    exp = c_ulong_From_Integer(y);    if (exp == (unsigned long)(-1) && PyErr_Occurred()) {        return NULL;    }        result = GMPy_MPC_New(0, 0, context);    tempx = GMPy_MPC_From_Complex(x, 1, 1, context);    if (!result || !tempx) {        Py_XDECREF((PyObject*)result);        Py_XDECREF((PyObject*)tempx);        return NULL;    }    result->rc = mpc_mul_2ui(result->c, tempx->c, exp, GET_MPC_ROUND(context));    Py_DECREF((PyObject*)tempx);    GMPY_MPC_CLEANUP(result, context, "mul_2exp()");    return (PyObject*)result;}

static PyObject *GMPy_Real_Is_Integer(PyObject *x, CTXT_Object *context){    MPFR_Object *tempx;    int res;    if (MPFR_Check(x)) {        res = mpfr_integer_p(MPFR(x));    }    else {        CHECK_CONTEXT(context);        if (!(tempx = GMPy_MPFR_From_Real(x, 1, context))) {            return NULL;        }        res = mpfr_integer_p(tempx->f);        Py_DECREF((PyObject*)tempx);    }    if (res) {        Py_RETURN_TRUE;    }    else {        Py_RETURN_FALSE;    }}

static PyObject *GMPy_XMPZ_Function_XbitMask(PyObject *self, PyObject *other){    Py_ssize_t i = 0;    XMPZ_Object* result;    CTXT_Object *context = NULL;    CHECK_CONTEXT(context);    i = ssize_t_From_Integer(other);    if (i == -1 && PyErr_Occurred()) {        TYPE_ERROR("xbit_mask() requires 'int' argument");        return NULL;    }    if (i < 0) {        VALUE_ERROR("mask length must be >= 0");        return NULL;    }    if (!(result = GMPy_XMPZ_New(context))) {        return NULL;    }    mpz_set_ui(result->z, 1);    mpz_mul_2exp(result->z, result->z, i);    mpz_sub_ui(result->z, result->z, 1);    return (PyObject*)result;}

static PyObject *GMPy_Context_Radians(PyObject *self, PyObject *other){    MPFR_Object *result, *tempx, *temp;    CTXT_Object *context = NULL;    if (self && CTXT_Check(self)) {        context = (CTXT_Object*)self;    }    else {        CHECK_CONTEXT(context);    }    result = GMPy_MPFR_New(0, context);    temp = GMPy_MPFR_New(context->ctx.mpfr_prec + 100, context);    tempx = GMPy_MPFR_From_Real(other, 1, context);    if (!result || !temp || !tempx) {        Py_XDECREF((PyObject*)temp);        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)result);        return NULL;    }    mpfr_const_pi(temp->f, MPFR_RNDN);    mpfr_div_ui(temp->f, temp->f, 180, MPFR_RNDN);    mpfr_mul(result->f, MPFR(self), temp->f, MPFR_RNDN);    Py_DECREF((PyObject*)temp);    Py_DECREF((PyObject*)tempx);    _GMPy_MPFR_Cleanup(&result, context);    return (PyObject*)result;}

static PyObject *GMPy_Rational_FloorDiv(PyObject *x, PyObject *y, CTXT_Object *context){    MPZ_Object *result;    MPQ_Object *tempq;    CHECK_CONTEXT(context);    result = GMPy_MPZ_New(context);    tempq = GMPy_MPQ_New(context);    if (!result || !tempq) {        Py_XDECREF((PyObject*)result);        Py_XDECREF((PyObject*)tempq);        return NULL;    }    if (MPQ_Check(x) && MPQ_Check(y)) {        if (mpq_sgn(MPQ(y)) == 0) {            ZERO_ERROR("division or modulo by zero");            goto error;        }        mpq_div(tempq->q, MPQ(x), MPQ(y));        mpz_fdiv_q(result->z, mpq_numref(tempq->q), mpq_denref(tempq->q));        Py_DECREF((PyObject*)tempq);        return (PyObject*)result;    }    if (IS_RATIONAL(x) && IS_RATIONAL(y)) {        MPQ_Object *tempx, *tempy;        tempx = GMPy_MPQ_From_Number(x, context);        tempy = GMPy_MPQ_From_Number(y, context);        if (!tempx || !tempy) {            Py_XDECREF((PyObject*)tempx);            Py_XDECREF((PyObject*)tempy);            goto error;        }        if (mpq_sgn(tempy->q) == 0) {            ZERO_ERROR("division or modulo by zero");            Py_DECREF((PyObject*)tempx);            Py_DECREF((PyObject*)tempy);            goto error;        }        mpq_div(tempq->q, tempx->q, tempy->q);        mpz_fdiv_q(result->z, mpq_numref(tempq->q), mpq_denref(tempq->q));        Py_DECREF((PyObject*)tempx);        Py_DECREF((PyObject*)tempy);        Py_DECREF((PyObject*)tempq);        return (PyObject*)result;    }    Py_DECREF((PyObject*)result);    Py_RETURN_NOTIMPLEMENTED;  error:    Py_DECREF((PyObject*)result);    Py_DECREF((PyObject*)tempq);    return NULL;}

static PyObject *GMPy_Real_RemQuo(PyObject *x, PyObject *y, CTXT_Object *context){    PyObject *result;    MPFR_Object *value, *tempx, *tempy;    long quobits = 0;    CHECK_CONTEXT(context);    value = GMPy_MPFR_New(0, context);    tempx = GMPy_MPFR_From_Real(x, 1, context);    tempy = GMPy_MPFR_From_Real(y, 1, context);    result = PyTuple_New(2);    if (!value || !tempx || !tempx || !result) {        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)tempy);        Py_XDECREF((PyObject*)value);        Py_XDECREF(result);        return NULL;    }    mpfr_clear_flags();    value->rc = mpfr_remquo(value->f, &quobits, tempx->f, tempy->f, GET_MPFR_ROUND(context));    Py_DECREF((PyObject*)tempx);    Py_DECREF((PyObject*)tempy);    _GMPy_MPFR_Cleanup(&value, context);    PyTuple_SET_ITEM(result, 0, (PyObject*)value);    PyTuple_SET_ITEM(result, 1, PyIntOrLong_FromLong(quobits));    return result;}

rc_ReturnCode_t PointerList_PushLast(PointerList* list, void* pointer){  CHECK_CONTEXT(list);  // Check if we need to grow the buffer  if (list->nbOfElements == list->allocatedSize-1)  {    // Allocate the new buffer    void** buffer = malloc(list->allocatedSize*2*sizeof(*list->buffer));    if (!buffer)      return RC_NO_MEMORY;    // Copy the data from the previous buffer    if (list->readIdx < list->writeIdx)      memcpy(buffer, list->buffer + list->readIdx, (list->writeIdx - list->readIdx)*sizeof(*list->buffer));    else    {      memcpy(buffer, list->buffer + list->readIdx, (list->allocatedSize - list->readIdx)*sizeof(*list->buffer));      memcpy(buffer+(list->allocatedSize - list->readIdx), list->buffer, list->writeIdx*sizeof(*list->buffer));    }    free(list->buffer);    list->readIdx = 0;    list->writeIdx = list->nbOfElements;    list->buffer = buffer;    list->allocatedSize *= 2;  }  list->buffer[list->writeIdx] = pointer;  list->writeIdx = (list->writeIdx+1) % list->allocatedSize;  list->nbOfElements++;  return RC_OK;}

rc_ReturnCode_t PointerList_Remove(PointerList* list, unsigned int index, void** pointer){  CHECK_CONTEXT(list);  if (index >= list->nbOfElements)  {    *pointer = NULL;    return RC_OUT_OF_RANGE;  }  unsigned int i = (index+list->readIdx) % list->allocatedSize;  *pointer = list->buffer[i];  list->nbOfElements--;  unsigned int n;  for (n = list->nbOfElements - index; n>0; n--, i++)  {    if (i == list->allocatedSize-1)    {      list->buffer[i] = list->buffer[0];      i = 0;    }    else      list->buffer[i] = list->buffer[i+1];  }  list->writeIdx = (list->writeIdx - 1 + list->allocatedSize) % list->allocatedSize;  return RC_OK;}

static PyObject *GMPy_Real_Frexp(PyObject *x, CTXT_Object *context){    PyObject *result;    MPFR_Object *value, *tempx;    mpfr_exp_t exp = 0;    CHECK_CONTEXT(context);    value = GMPy_MPFR_New(0, context);    tempx = GMPy_MPFR_From_Real(x, 1, context);    result = PyTuple_New(2);    if (!value || !result || !tempx) {        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)value);        Py_XDECREF(result);        return NULL;    }    mpfr_clear_flags();    value->rc = mpfr_frexp(&exp, value->f, tempx->f, GET_MPFR_ROUND(context));    Py_DECREF((PyObject*)tempx);    _GMPy_MPFR_Cleanup(&value, context);    PyTuple_SET_ITEM(result, 0, PyIntOrLong_FromSsize_t((Py_ssize_t)exp));    PyTuple_SET_ITEM(result, 1, (PyObject*)value);    return result;}

static PyObject *GMPy_Real_Lgamma(PyObject *x, CTXT_Object *context){    PyObject *result;    MPFR_Object *value, *tempx;    int signp = 0;    CHECK_CONTEXT(context)    tempx = GMPy_MPFR_From_Real(x, 1, context);    value = GMPy_MPFR_New(0, context);    result = PyTuple_New(2);    if (!tempx || !value || !result) {        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)value);        Py_XDECREF(result);        return NULL;    }    mpfr_clear_flags();    value->rc = mpfr_lgamma(value->f, &signp, tempx->f, GET_MPFR_ROUND(context));    Py_DECREF((PyObject*)tempx);    _GMPy_MPFR_Cleanup(&value, context);    if (!value) {        Py_DECREF(result);        return NULL;    }    PyTuple_SET_ITEM(result, 0, (PyObject*)value);    PyTuple_SET_ITEM(result, 1, PyIntOrLong_FromLong((long)signp));    return result;}

static PyObject *GMPy_Context_NextBelow(PyObject *self, PyObject *other){    MPFR_Object *result, *tempx;    CTXT_Object *context = NULL;    mpfr_rnd_t temp_round;    if (self && CTXT_Check(self)) {        context = (CTXT_Object*)self;    }    else {        CHECK_CONTEXT(context);    }    if (!(tempx = GMPy_MPFR_From_Real(other, 1, context))) {        TYPE_ERROR("next_below() argument type not supported");        return NULL;    }    if (!(result = GMPy_MPFR_New(mpfr_get_prec(tempx->f), context))) {        Py_DECREF((PyObject*)tempx);        return NULL;    }    mpfr_clear_flags();    mpfr_set(result->f, tempx->f, GET_MPFR_ROUND(context));    Py_DECREF((PyObject*)tempx);    mpfr_nextbelow(result->f);    result->rc = 0;    temp_round = GET_MPFR_ROUND(context);    context->ctx.mpfr_round = MPFR_RNDD;    _GMPy_MPFR_Cleanup(&result, context);    context->ctx.mpfr_round = temp_round;    return (PyObject*)result;}

static PyObject *GMPy_Complex_Rect(PyObject *x, PyObject *y, CTXT_Object *context){    MPFR_Object *tempx, *tempy;    MPC_Object *result;    CHECK_CONTEXT(context);    tempx = GMPy_MPFR_From_Real(x, 1, context);    tempy = GMPy_MPFR_From_Real(y, 1, context);    result = GMPy_MPC_New(0, 0, context);    if (!tempx || !tempy || !result) {        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)tempy);        Py_XDECREF((PyObject*)result);        return NULL;    }    mpfr_cos(mpc_realref(result->c), tempy->f, GET_REAL_ROUND(context));    mpfr_mul(mpc_realref(result->c), mpc_realref(result->c), tempx->f, GET_REAL_ROUND(context));    mpfr_sin(mpc_imagref(result->c), tempy->f, GET_IMAG_ROUND(context));    mpfr_mul(mpc_imagref(result->c), mpc_imagref(result->c), tempx->f, GET_IMAG_ROUND(context));    Py_DECREF((PyObject*)tempx);    Py_DECREF((PyObject*)tempy);    GMPY_MPC_CLEANUP(result, context, "rect()");    return (PyObject*)result;}

static PyObject *GMPy_Context_Factorial(PyObject *self, PyObject *other){    MPFR_Object *result;    long n;    CTXT_Object *context = NULL;    if (self && CTXT_Check(self)) {        context = (CTXT_Object*)self;    }    else {        CHECK_CONTEXT(context);    }    n = PyLong_AsLong(other);    if ((n == -1) && PyErr_Occurred()) {        TYPE_ERROR("factorial() requires 'int' argument");        return NULL;    }    if (n < 0) {        VALUE_ERROR("factorial() of negative number");        return NULL;    }    if (!(result = GMPy_MPFR_New(0, context))) {        return NULL;    }    mpfr_clear_flags();    mpfr_fac_ui(result->f, n, GET_MPFR_ROUND(context));    _GMPy_MPFR_Cleanup(&result, context);    return (PyObject*)result;}

static MPC_Object *GMPy_MPC_From_PyComplex(PyObject *obj, mpfr_prec_t rprec, mpfr_prec_t iprec,                        CTXT_Object *context){    MPC_Object *result;    assert(PyComplex_Check(obj));    CHECK_CONTEXT(context);    if (rprec == 0)        rprec = GET_REAL_PREC(context);    else if (rprec == 1)        rprec = DBL_MANT_DIG;    if (iprec == 0)        iprec = GET_IMAG_PREC(context);    else if (iprec == 1)        rprec = DBL_MANT_DIG;    if ((result = GMPy_MPC_New(rprec, iprec, context))) {        result->rc = mpc_set_d_d(result->c, PyComplex_RealAsDouble(obj),                                 PyComplex_ImagAsDouble(obj), GET_MPC_ROUND(context));        if (rprec != 1 || iprec != 1) {            GMPY_MPC_CHECK_RANGE(result, context);        }        GMPY_MPC_SUBNORMALIZE(result, context);        GMPY_MPC_EXCEPTIONS(result, context);    }    return result;}

static PyObject *GMPy_Complex_Polar(PyObject *x, CTXT_Object *context){    PyObject *tempx, *abs, *phase, *result;    CHECK_CONTEXT(context);    if (!(tempx = (PyObject*)GMPy_MPC_From_Complex(x, 1, 1, context))) {        return NULL;    }    abs = GMPy_Complex_Abs(tempx, context);    phase = GMPy_Complex_Phase(tempx, context);    Py_DECREF(tempx);    result = PyTuple_New(2);    if (!abs || !phase || !result) {        Py_XDECREF(abs);        Py_XDECREF(phase);        Py_XDECREF(result);        return NULL;    }    PyTuple_SET_ITEM(result, 0, abs);    PyTuple_SET_ITEM(result, 1, phase);    return result;}

static PyObject *GMPy_PyStr_From_MPC(MPC_Object *self, int base, int digits, CTXT_Object *context){    PyObject *tempreal = 0, *tempimag = 0, *result;    CHECK_CONTEXT(context);    if (!((base >= 2) && (base <= 62))) {        VALUE_ERROR("base must be in the interval [2,62]");        return NULL;    }    if ((digits < 0) || (digits == 1)) {        VALUE_ERROR("digits must be 0 or >= 2");        return NULL;    }    tempreal = mpfr_ascii(mpc_realref(self->c), base, digits,                          MPC_RND_RE(GET_MPC_ROUND(context)));    tempimag = mpfr_ascii(mpc_imagref(self->c), base, digits,                          MPC_RND_IM(GET_MPC_ROUND(context)));    if (!tempreal || !tempimag) {        Py_XDECREF(tempreal);        Py_XDECREF(tempimag);        return NULL;    }    result = Py_BuildValue("(NN)", tempreal, tempimag);    if (!result) {        Py_DECREF(tempreal);        Py_DECREF(tempimag);    }    return result;}

static MPC_Object *GMPy_MPC_From_MPQ(MPQ_Object *obj, mpfr_prec_t rprec, mpfr_prec_t iprec,                  CTXT_Object *context){    MPC_Object *result = NULL;    assert(MPQ_Check(obj));    CHECK_CONTEXT(context);    if (rprec == 0 || rprec == 1)        rprec = GET_REAL_PREC(context) + rprec * GET_GUARD_BITS(context);    if (iprec == 0 || iprec == 1)        iprec = GET_IMAG_PREC(context) + iprec * GET_GUARD_BITS(context);    if ((result = GMPy_MPC_New(rprec, iprec, context))) {        result->rc = mpc_set_q(result->c, obj->q, GET_MPC_ROUND(context));        if (rprec != 1) {            GMPY_MPC_CHECK_RANGE(result, context);        }        GMPY_MPC_SUBNORMALIZE(result, context);        GMPY_MPC_EXCEPTIONS(result, context);    }    return result;}

static MPC_Object *GMPy_MPC_From_MPFR(MPFR_Object *obj, mpfr_prec_t rprec, mpfr_prec_t iprec,                   CTXT_Object *context){    MPC_Object *result;    assert(MPFR_Check(obj));    CHECK_CONTEXT(context);    if (rprec == 0)        rprec = GET_REAL_PREC(context);    else if (rprec == 1)        rprec = mpfr_get_prec(obj->f);    if (iprec == 0)        iprec = GET_IMAG_PREC(context);    else if (iprec == 1)        rprec = mpfr_get_prec(obj->f);    if ((result = GMPy_MPC_New(rprec, iprec, context))) {        result->rc = mpc_set_fr(result->c, obj->f, GET_MPC_ROUND(context));        if (rprec != 1) {            GMPY_MPC_CHECK_RANGE(result, context);        }        GMPY_MPC_SUBNORMALIZE(result, context);        GMPY_MPC_EXCEPTIONS(result, context);    }    return result;}

static PyObject *GMPy_Real_Round2(PyObject *x, PyObject *y, CTXT_Object *context){    MPFR_Object *result, *tempx;    long n = 0;    CHECK_CONTEXT(context);    if (y) {        n = PyIntOrLong_AsLong(y);        if ( (n == -1 && PyErr_Occurred()) || n < MPFR_PREC_MIN || n > MPFR_PREC_MAX) {            VALUE_ERROR("invalid precision");            return NULL;        }    }    if (!(tempx = GMPy_MPFR_From_Real(x, 1, context))) {        return NULL;    }    if (!(result = GMPy_MPFR_New(mpfr_get_prec(tempx->f), context))) {        Py_DECREF((PyObject*)tempx);        return NULL;    }    mpfr_set(result->f, tempx->f, GET_MPFR_ROUND(context));    Py_DECREF((PyObject*)tempx);    mpfr_clear_flags();    result->rc = mpfr_prec_round(result->f, n, GET_MPFR_ROUND(context));    _GMPy_MPFR_Cleanup(&result, context);    return (PyObject*)result;}

static PyObject *GMPy_Complex_Abs(PyObject *x, CTXT_Object *context){    MPFR_Object *result = NULL;    MPC_Object *tempx = NULL;    CHECK_CONTEXT(context);    if (!(tempx = GMPy_MPC_From_Complex(x, 1, 1, context)) ||        !(result = GMPy_MPFR_New(0, context))) {        /* LCOV_EXCL_START */        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)result);        return NULL;        /* LCOV_EXCL_STOP */    }    mpfr_clear_flags();    SET_MPC_WAS_NAN(context, tempx);    result->rc = mpc_abs(result->f, tempx->c, GET_MPC_ROUND(context));    Py_DECREF((PyObject*)tempx);    _GMPy_MPFR_Cleanup(&result, context);    return (PyObject*)result;}

static PyObject *GMPy_Real_RelDiff(PyObject *x, PyObject *y, CTXT_Object *context){    MPFR_Object *tempx, *tempy, *result;    CHECK_CONTEXT(context);    result = GMPy_MPFR_New(0, context);    tempx = GMPy_MPFR_From_Real(x, 1, context);    tempy = GMPy_MPFR_From_Real(y, 1, context);    if (!result || !tempx || !tempy) {        Py_XDECREF((PyObject*)result);        Py_XDECREF((PyObject*)tempx);        Py_XDECREF((PyObject*)tempy);        return NULL;    }    mpfr_clear_flags();    mpfr_reldiff(result->f, tempx->f, tempy->f, GET_MPFR_ROUND(context));    result->rc = 0;    _GMPy_MPFR_Cleanup(&result, context);    Py_DECREF((PyObject*)tempx);    Py_DECREF((PyObject*)tempy);    return (PyObject*)result;}

static PyObject *GMPy_MPFR_Add_Slot(PyObject *x, PyObject *y){    if (MPFR_Check(x) && MPFR_Check(y)) {        MPFR_Object *result;        CTXT_Object *context = NULL;        CHECK_CONTEXT(context);        if ((result = GMPy_MPFR_New(0, context))) {            mpfr_clear_flags();            SET_MPFR_MPFR_WAS_NAN(context, x, y);            result->rc = mpfr_add(result->f, MPFR(x), MPFR(y), GET_MPFR_ROUND(context));            _GMPy_MPFR_Cleanup(&result, context);        }        return (PyObject*)result;    }    if (IS_REAL(x) && IS_REAL(y))        return GMPy_Real_Add(x, y, NULL);    if (IS_COMPLEX(x) && IS_COMPLEX(y))        return GMPy_Complex_Add(x, y, NULL);    Py_RETURN_NOTIMPLEMENTED;}

rc_ReturnCode_t PointerList_Destroy(PointerList* list){  CHECK_CONTEXT(list);  list->magic = ~list->magic;  free(list->buffer);  free(list);  return RC_OK;}

static PyObject *GMPy_MPZ_Factory(PyObject *self, PyObject *args, PyObject *keywds){    MPZ_Object *result = NULL;    PyObject *n;    int base = 0;    Py_ssize_t argc;    static char *kwlist[] = {"s", "base", NULL };    CTXT_Object *context = NULL;    CHECK_CONTEXT(context)        /* Optimize the most common use cases first; either 0 or 1 argument */        argc = PyTuple_GET_SIZE(args);        if (argc == 0) {        if ((result = GMPy_MPZ_New(context))) {            mpz_set_ui(result->z, 0);        }        return (PyObject*)result;    }    if (argc == 1 && !keywds) {        n = PyTuple_GET_ITEM(args, 0);        if (IS_REAL(n)) {            result = GMPy_MPZ_From_Number(n, context);        }        else if (PyStrOrUnicode_Check(n)) {            result = GMPy_MPZ_From_PyStr(n, base, context);        }        else {            TYPE_ERROR("mpz() requires numeric or string argument");        }        return (PyObject*)result;    }    if (!PyArg_ParseTupleAndKeywords(args, keywds, "O|i", kwlist, &n, &base)) {        return NULL;    }    if ((base != 0) && ((base < 2)|| (base > 62))) {        VALUE_ERROR("base for mpz() must be 0 or in the interval [2, 62]");        return NULL;    }    if (PyStrOrUnicode_Check(n)) {        result = GMPy_MPZ_From_PyStr(n, base, context);    }    else if (IS_REAL(n)) {        TYPE_ERROR("mpz() with number argument only takes 1 argument");    }    else {        TYPE_ERROR("mpz() requires numeric or string (and optional base) arguments");    }    return (PyObject*)result;}

static PyObject *GMPy_XMPZ_Method_Copy(PyObject *self, PyObject *other){    CTXT_Object *context = NULL;    CHECK_CONTEXT(context);    return (PyObject*)GMPy_XMPZ_From_XMPZ((XMPZ_Object*)self, context);}

/* hex/oct formatting (mpz-only) */static PyObject *GMPy_XMPZ_Oct_Slot(XMPZ_Object *self){    CTXT_Object *context = NULL;    CHECK_CONTEXT(context);    return GMPy_PyStr_From_XMPZ(self, 8, 0, context);}

static PyObject *GMPy_Real_DivMod(PyObject *x, PyObject *y, CTXT_Object *context){    CHECK_CONTEXT(context);    if (GET_DIVMOD_EXACT(context))        return GMPy_Real_DivMod_2(x, y, context);    else        return GMPy_Real_DivMod_1(x, y, context);}

rc_ReturnCode_t PointerList_GetSize(PointerList* list, unsigned int* nbOfElements, unsigned int* allocatedSize){  CHECK_CONTEXT(list);  if (nbOfElements)    *nbOfElements = list->nbOfElements;  if (allocatedSize)    *allocatedSize = list->allocatedSize;  return RC_OK;}