_decimal.c

/*
 * Copyright (c) 2008-2012 Stefan Krah. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */


#include<Python.h>
#include"longintrepr.h"
#include"pythread.h"
#include"structmember.h"
#include"complexobject.h"
#include"mpdecimal.h"

#include<stdlib.h>

#include"docstrings.h"


#if !defined(MPD_VERSION_HEX) ||MPD_VERSION_HEX<0x02040100
#error "libmpdec version >= 2.4.1 required"
#endif


/*
 * Type sizes with assertions in mpdecimal.h and pyport.h:
 * sizeof(size_t) == sizeof(Py_ssize_t)
 * sizeof(size_t) == sizeof(mpd_uint_t) == sizeof(mpd_ssize_t)
 */

#ifdefTEST_COVERAGE
#undef Py_LOCAL_INLINE
#definePy_LOCAL_INLINE Py_LOCAL
#endif

#defineMPD_Float_operation MPD_Not_implemented

#defineBOUNDS_CHECK(x, MIN, MAX) x = (x < MIN || MAX < x) ? MAX : x


/* _Py_DEC_MINALLOC >= MPD_MINALLOC */
#define_Py_DEC_MINALLOC 4

typedefstruct {
PyObject_HEAD
Py_hash_thash;
mpd_tdec;
mpd_uint_tdata[_Py_DEC_MINALLOC];
} PyDecObject;

typedefstruct {
PyObject_HEAD
uint32_t*flags;
} PyDecSignalDictObject;

typedefstruct {
PyObject_HEAD
mpd_context_tctx;
PyObject*traps;
PyObject*flags;
intcapitals;
PyThreadState*tstate;
} PyDecContextObject;

typedefstruct {
PyObject_HEAD
PyObject*local;
PyObject*global;
} PyDecContextManagerObject;


#undef MPD
#undef CTX
staticPyTypeObjectPyDec_Type;
staticPyTypeObject*PyDecSignalDict_Type;
staticPyTypeObjectPyDecContext_Type;
staticPyTypeObjectPyDecContextManager_Type;
#definePyDec_CheckExact(v) (Py_TYPE(v) == &PyDec_Type)
#definePyDec_Check(v) PyObject_TypeCheck(v, &PyDec_Type)
#definePyDecSignalDict_Check(v) (Py_TYPE(v) == PyDecSignalDict_Type)
#definePyDecContext_Check(v) PyObject_TypeCheck(v, &PyDecContext_Type)
#defineMPD(v) (&((PyDecObject *)v)->dec)
#defineSdFlagAddr(v) (((PyDecSignalDictObject *)v)->flags)
#defineSdFlags(v) (*((PyDecSignalDictObject *)v)->flags)
#defineCTX(v) (&((PyDecContextObject *)v)->ctx)
#defineCtxCaps(v) (((PyDecContextObject *)v)->capitals)


Py_LOCAL_INLINE(PyObject*)
incr_true(void)
{
Py_INCREF(Py_True);
returnPy_True;
}

Py_LOCAL_INLINE(PyObject*)
incr_false(void)
{
Py_INCREF(Py_False);
returnPy_False;
}


#ifndefWITH_DECIMAL_CONTEXTVAR
/* Key for thread state dictionary */
staticPyObject*tls_context_key=NULL;
/* Invariant: NULL or the most recently accessed thread local context */
staticPyDecContextObject*cached_context=NULL;
#else
staticPyObject*current_context_var=NULL;
#endif

/* Template for creating new thread contexts, calling Context() without
 * arguments and initializing the module_context on first access. */
staticPyObject*default_context_template=NULL;
/* Basic and extended context templates */
staticPyObject*basic_context_template=NULL;
staticPyObject*extended_context_template=NULL;


/* Error codes for functions that return signals or conditions */
#defineDEC_INVALID_SIGNALS (MPD_Max_status+1U)
#defineDEC_ERR_OCCURRED (DEC_INVALID_SIGNALS<<1)
#defineDEC_ERRORS (DEC_INVALID_SIGNALS|DEC_ERR_OCCURRED)

typedefstruct {
constchar*name; /* condition or signal name */
constchar*fqname; /* fully qualified name */
uint32_tflag; /* libmpdec flag */
PyObject*ex; /* corresponding exception */
} DecCondMap;

/* Top level Exception; inherits from ArithmeticError */
staticPyObject*DecimalException=NULL;

/* Exceptions that correspond to IEEE signals */
#defineSUBNORMAL 5
#defineINEXACT 6
#defineROUNDED 7
#defineSIGNAL_MAP_LEN 9
staticDecCondMapsignal_map[] = {
 {"InvalidOperation", "decimal.InvalidOperation", MPD_IEEE_Invalid_operation, NULL},
 {"FloatOperation", "decimal.FloatOperation", MPD_Float_operation, NULL},
 {"DivisionByZero", "decimal.DivisionByZero", MPD_Division_by_zero, NULL},
 {"Overflow", "decimal.Overflow", MPD_Overflow, NULL},
 {"Underflow", "decimal.Underflow", MPD_Underflow, NULL},
 {"Subnormal", "decimal.Subnormal", MPD_Subnormal, NULL},
 {"Inexact", "decimal.Inexact", MPD_Inexact, NULL},
 {"Rounded", "decimal.Rounded", MPD_Rounded, NULL},
 {"Clamped", "decimal.Clamped", MPD_Clamped, NULL},
 {NULL}
};

/* Exceptions that inherit from InvalidOperation */
staticDecCondMapcond_map[] = {
 {"InvalidOperation", "decimal.InvalidOperation", MPD_Invalid_operation, NULL},
 {"ConversionSyntax", "decimal.ConversionSyntax", MPD_Conversion_syntax, NULL},
 {"DivisionImpossible", "decimal.DivisionImpossible", MPD_Division_impossible, NULL},
 {"DivisionUndefined", "decimal.DivisionUndefined", MPD_Division_undefined, NULL},
 {"InvalidContext", "decimal.InvalidContext", MPD_Invalid_context, NULL},
#ifdefEXTRA_FUNCTIONALITY
 {"MallocError", "decimal.MallocError", MPD_Malloc_error, NULL},
#endif
 {NULL}
};

staticconstchar*dec_signal_string[MPD_NUM_FLAGS] = {
"Clamped",
"InvalidOperation",
"DivisionByZero",
"InvalidOperation",
"InvalidOperation",
"InvalidOperation",
"Inexact",
"InvalidOperation",
"InvalidOperation",
"InvalidOperation",
"FloatOperation",
"Overflow",
"Rounded",
"Subnormal",
"Underflow",
};

#ifdefEXTRA_FUNCTIONALITY
#define_PY_DEC_ROUND_GUARD MPD_ROUND_GUARD
#else
#define_PY_DEC_ROUND_GUARD (MPD_ROUND_GUARD-1)
#endif
staticPyObject*round_map[_PY_DEC_ROUND_GUARD];

staticconstchar*invalid_rounding_err=
"valid values for rounding are:\n\
 [ROUND_CEILING, ROUND_FLOOR, ROUND_UP, ROUND_DOWN,\n\
 ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN,\n\
 ROUND_05UP]";

staticconstchar*invalid_signals_err=
"valid values for signals are:\n\
 [InvalidOperation, FloatOperation, DivisionByZero,\n\
 Overflow, Underflow, Subnormal, Inexact, Rounded,\n\
 Clamped]";

#ifdefEXTRA_FUNCTIONALITY
staticconstchar*invalid_flags_err=
"valid values for _flags or _traps are:\n\
 signals:\n\
 [DecIEEEInvalidOperation, DecFloatOperation, DecDivisionByZero,\n\
 DecOverflow, DecUnderflow, DecSubnormal, DecInexact, DecRounded,\n\
 DecClamped]\n\
 conditions which trigger DecIEEEInvalidOperation:\n\
 [DecInvalidOperation, DecConversionSyntax, DecDivisionImpossible,\n\
 DecDivisionUndefined, DecFpuError, DecInvalidContext, DecMallocError]";
#endif

staticint
value_error_int(constchar*mesg)
{
PyErr_SetString(PyExc_ValueError, mesg);
return-1;
}

#ifdefCONFIG_32
staticPyObject*
value_error_ptr(constchar*mesg)
{
PyErr_SetString(PyExc_ValueError, mesg);
returnNULL;
}
#endif

staticint
type_error_int(constchar*mesg)
{
PyErr_SetString(PyExc_TypeError, mesg);
return-1;
}

staticint
runtime_error_int(constchar*mesg)
{
PyErr_SetString(PyExc_RuntimeError, mesg);
return-1;
}
#defineINTERNAL_ERROR_INT(funcname) \
 return runtime_error_int("internal error in " funcname)

staticPyObject*
runtime_error_ptr(constchar*mesg)
{
PyErr_SetString(PyExc_RuntimeError, mesg);
returnNULL;
}
#defineINTERNAL_ERROR_PTR(funcname) \
 return runtime_error_ptr("internal error in " funcname)

staticvoid
dec_traphandler(mpd_context_t*ctxUNUSED) /* GCOV_NOT_REACHED */
{ /* GCOV_NOT_REACHED */
return; /* GCOV_NOT_REACHED */
}

staticPyObject*
flags_as_exception(uint32_tflags)
{
DecCondMap*cm;

for (cm=signal_map; cm->name!=NULL; cm++) {
if (flags&cm->flag) {
returncm->ex;
 }
 }

INTERNAL_ERROR_PTR("flags_as_exception"); /* GCOV_NOT_REACHED */
}

Py_LOCAL_INLINE(uint32_t)
exception_as_flag(PyObject*ex)
{
DecCondMap*cm;

for (cm=signal_map; cm->name!=NULL; cm++) {
if (cm->ex==ex) {
returncm->flag;
 }
 }

PyErr_SetString(PyExc_KeyError, invalid_signals_err);
returnDEC_INVALID_SIGNALS;
}

staticPyObject*
flags_as_list(uint32_tflags)
{
PyObject*list;
DecCondMap*cm;

list=PyList_New(0);
if (list==NULL) {
returnNULL;
 }

for (cm=cond_map; cm->name!=NULL; cm++) {
if (flags&cm->flag) {
if (PyList_Append(list, cm->ex) <0) {
 goto error;
 }
 }
 }
for (cm=signal_map+1; cm->name!=NULL; cm++) {
if (flags&cm->flag) {
if (PyList_Append(list, cm->ex) <0) {
 goto error;
 }
 }
 }

returnlist;

error:
Py_DECREF(list);
returnNULL;
}

staticPyObject*
signals_as_list(uint32_tflags)
{
PyObject*list;
DecCondMap*cm;

list=PyList_New(0);
if (list==NULL) {
returnNULL;
 }

for (cm=signal_map; cm->name!=NULL; cm++) {
if (flags&cm->flag) {
if (PyList_Append(list, cm->ex) <0) {
Py_DECREF(list);
returnNULL;
 }
 }
 }

returnlist;
}

staticuint32_t
list_as_flags(PyObject*list)
{
PyObject*item;
uint32_tflags, x;
Py_ssize_tn, j;

assert(PyList_Check(list));

n=PyList_Size(list);
flags=0;
for (j=0; j<n; j++) {
item=PyList_GetItem(list, j);
x=exception_as_flag(item);
if (x&DEC_ERRORS) {
returnx;
 }
flags |= x;
 }

returnflags;
}

staticPyObject*
flags_as_dict(uint32_tflags)
{
DecCondMap*cm;
PyObject*dict;

dict=PyDict_New();
if (dict==NULL) {
returnNULL;
 }

for (cm=signal_map; cm->name!=NULL; cm++) {
PyObject*b=flags&cm->flag ? Py_True : Py_False;
if (PyDict_SetItem(dict, cm->ex, b) <0) {
Py_DECREF(dict);
returnNULL;
 }
 }

returndict;
}

staticuint32_t
dict_as_flags(PyObject*val)
{
PyObject*b;
DecCondMap*cm;
uint32_tflags=0;
intx;

if (!PyDict_Check(val)) {
PyErr_SetString(PyExc_TypeError,
"argument must be a signal dict");
returnDEC_INVALID_SIGNALS;
 }

if (PyDict_Size(val) !=SIGNAL_MAP_LEN) {
PyErr_SetString(PyExc_KeyError,
"invalid signal dict");
returnDEC_INVALID_SIGNALS;
 }

for (cm=signal_map; cm->name!=NULL; cm++) {
b=PyDict_GetItemWithError(val, cm->ex);
if (b==NULL) {
if (PyErr_Occurred()) {
returnDEC_ERR_OCCURRED;
 }
PyErr_SetString(PyExc_KeyError,
"invalid signal dict");
returnDEC_INVALID_SIGNALS;
 }

x=PyObject_IsTrue(b);
if (x<0) {
returnDEC_ERR_OCCURRED;
 }
if (x==1) {
flags |= cm->flag;
 }
 }

returnflags;
}

#ifdefEXTRA_FUNCTIONALITY
staticuint32_t
long_as_flags(PyObject*v)
{
longx;

x=PyLong_AsLong(v);
if (x==-1&&PyErr_Occurred()) {
returnDEC_ERR_OCCURRED;
 }
if (x<0||x> (long)MPD_Max_status) {
PyErr_SetString(PyExc_TypeError, invalid_flags_err);
returnDEC_INVALID_SIGNALS;
 }

returnx;
}
#endif

staticint
dec_addstatus(PyObject*context, uint32_tstatus)
{
mpd_context_t*ctx=CTX(context);

ctx->status |= status;
if (status& (ctx->traps|MPD_Malloc_error)) {
PyObject*ex, *siglist;

if (status&MPD_Malloc_error) {
PyErr_NoMemory();
return1;
 }

ex=flags_as_exception(ctx->traps&status);
if (ex==NULL) {
return1; /* GCOV_NOT_REACHED */
 }
siglist=flags_as_list(ctx->traps&status);
if (siglist==NULL) {
return1;
 }

PyErr_SetObject(ex, siglist);
Py_DECREF(siglist);
return1;
 }
return0;
}

staticint
getround(PyObject*v)
{
inti;

if (PyUnicode_Check(v)) {
for (i=0; i<_PY_DEC_ROUND_GUARD; i++) {
if (v==round_map[i]) {
returni;
 }
 }
for (i=0; i<_PY_DEC_ROUND_GUARD; i++) {
if (PyUnicode_Compare(v, round_map[i]) ==0) {
returni;
 }
 }
 }

returntype_error_int(invalid_rounding_err);
}


/******************************************************************************/
/* SignalDict Object */
/******************************************************************************/

/* The SignalDict is a MutableMapping that provides access to the
 mpd_context_t flags, which reside in the context object. When a
 new context is created, context.traps and context.flags are
 initialized to new SignalDicts. Once a SignalDict is tied to
 a context, it cannot be deleted. */

staticint
signaldict_init(PyObject*self, PyObject*argsUNUSED, PyObject*kwdsUNUSED)
{
SdFlagAddr(self) =NULL;
return0;
}

staticPy_ssize_t
signaldict_len(PyObject*selfUNUSED)
{
returnSIGNAL_MAP_LEN;
}

staticPyObject*SignalTuple;
staticPyObject*
signaldict_iter(PyObject*selfUNUSED)
{
returnPyTuple_Type.tp_iter(SignalTuple);
}

staticPyObject*
signaldict_getitem(PyObject*self, PyObject*key)
{
uint32_tflag;

flag=exception_as_flag(key);
if (flag&DEC_ERRORS) {
returnNULL;
 }

returnSdFlags(self)&flag ? incr_true() : incr_false();
}

staticint
signaldict_setitem(PyObject*self, PyObject*key, PyObject*value)
{
uint32_tflag;
intx;

if (value==NULL) {
returnvalue_error_int("signal keys cannot be deleted");
 }

flag=exception_as_flag(key);
if (flag&DEC_ERRORS) {
return-1;
 }

x=PyObject_IsTrue(value);
if (x<0) {
return-1;
 }

if (x==1) {
SdFlags(self) |= flag;
 }
else {
SdFlags(self) &= ~flag;
 }

return0;
}

staticPyObject*
signaldict_repr(PyObject*self)
{
DecCondMap*cm;
constchar*n[SIGNAL_MAP_LEN]; /* name */
constchar*b[SIGNAL_MAP_LEN]; /* bool */
inti;

assert(SIGNAL_MAP_LEN==9);

for (cm=signal_map, i=0; cm->name!=NULL; cm++, i++) {
n[i] =cm->fqname;
b[i] =SdFlags(self)&cm->flag ? "True" : "False";
 }
returnPyUnicode_FromFormat(
"{<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s, "
"<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s, "
"<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s}",
n[0], b[0], n[1], b[1], n[2], b[2],
n[3], b[3], n[4], b[4], n[5], b[5],
n[6], b[6], n[7], b[7], n[8], b[8]);
}

staticPyObject*
signaldict_richcompare(PyObject*v, PyObject*w, intop)
{
PyObject*res=Py_NotImplemented;

assert(PyDecSignalDict_Check(v));

if (op==Py_EQ||op==Py_NE) {
if (PyDecSignalDict_Check(w)) {
res= (SdFlags(v)==SdFlags(w)) ^ (op==Py_NE) ? Py_True : Py_False;
 }
elseif (PyDict_Check(w)) {
uint32_tflags=dict_as_flags(w);
if (flags&DEC_ERRORS) {
if (flags&DEC_INVALID_SIGNALS) {
/* non-comparable: Py_NotImplemented */
PyErr_Clear();
 }
else {
returnNULL;
 }
 }
else {
res= (SdFlags(v)==flags) ^ (op==Py_NE) ? Py_True : Py_False;
 }
 }
 }

Py_INCREF(res);
returnres;
}

staticPyObject*
signaldict_copy(PyObject*self, PyObject*argsUNUSED)
{
returnflags_as_dict(SdFlags(self));
}


staticPyMappingMethodssignaldict_as_mapping= {
 (lenfunc)signaldict_len, /* mp_length */
 (binaryfunc)signaldict_getitem, /* mp_subscript */
 (objobjargproc)signaldict_setitem/* mp_ass_subscript */
};

staticPyMethodDefsignaldict_methods[] = {
 { "copy", (PyCFunction)signaldict_copy, METH_NOARGS, NULL},
 {NULL, NULL}
};


staticPyTypeObjectPyDecSignalDictMixin_Type=
{
PyVarObject_HEAD_INIT(0, 0)
"decimal.SignalDictMixin", /* tp_name */
sizeof(PyDecSignalDictObject), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
0, /* tp_print */
 (getattrfunc) 0, /* tp_getattr */
 (setattrfunc) 0, /* tp_setattr */
0, /* tp_reserved */
 (reprfunc) signaldict_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
&signaldict_as_mapping, /* tp_as_mapping */
PyObject_HashNotImplemented, /* tp_hash */
0, /* tp_call */
 (reprfunc) 0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
 (setattrofunc) 0, /* tp_setattro */
 (PyBufferProcs*) 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|
Py_TPFLAGS_HAVE_GC, /* tp_flags */
0, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
signaldict_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
 (getiterfunc)signaldict_iter, /* tp_iter */
0, /* tp_iternext */
signaldict_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
 (initproc)signaldict_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};


/******************************************************************************/
/* Context Object, Part 1 */
/******************************************************************************/

#defineDec_CONTEXT_GET_SSIZE(mem) \
static PyObject * \
context_get##mem(PyObject *self, void *closure UNUSED) \
{ \
 return PyLong_FromSsize_t(mpd_get##mem(CTX(self))); \
}

#defineDec_CONTEXT_GET_ULONG(mem) \
static PyObject * \
context_get##mem(PyObject *self, void *closure UNUSED) \
{ \
 return PyLong_FromUnsignedLong(mpd_get##mem(CTX(self))); \
}

Dec_CONTEXT_GET_SSIZE(prec)
Dec_CONTEXT_GET_SSIZE(emax)
Dec_CONTEXT_GET_SSIZE(emin)
Dec_CONTEXT_GET_SSIZE(clamp)

#ifdefEXTRA_FUNCTIONALITY
Dec_CONTEXT_GET_ULONG(traps)
Dec_CONTEXT_GET_ULONG(status)
#endif

staticPyObject*
context_getround(PyObject*self, void*closureUNUSED)
{
inti=mpd_getround(CTX(self));

Py_INCREF(round_map[i]);
returnround_map[i];
}

staticPyObject*
context_getcapitals(PyObject*self, void*closureUNUSED)
{
returnPyLong_FromLong(CtxCaps(self));
}

#ifdefEXTRA_FUNCTIONALITY
staticPyObject*
context_getallcr(PyObject*self, void*closureUNUSED)
{
returnPyLong_FromLong(mpd_getcr(CTX(self)));
}
#endif

staticPyObject*
context_getetiny(PyObject*self, PyObject*dummyUNUSED)
{
returnPyLong_FromSsize_t(mpd_etiny(CTX(self)));
}

staticPyObject*
context_getetop(PyObject*self, PyObject*dummyUNUSED)
{
returnPyLong_FromSsize_t(mpd_etop(CTX(self)));
}

staticint
context_setprec(PyObject*self, PyObject*value, void*closureUNUSED)
{
mpd_context_t*ctx;
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
return-1;
 }

ctx=CTX(self);
if (!mpd_qsetprec(ctx, x)) {
returnvalue_error_int(
"valid range for prec is [1, MAX_PREC]");
 }

return0;
}

staticint
context_setemin(PyObject*self, PyObject*value, void*closureUNUSED)
{
mpd_context_t*ctx;
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
return-1;
 }

ctx=CTX(self);
if (!mpd_qsetemin(ctx, x)) {
returnvalue_error_int(
"valid range for Emin is [MIN_EMIN, 0]");
 }

return0;
}

staticint
context_setemax(PyObject*self, PyObject*value, void*closureUNUSED)
{
mpd_context_t*ctx;
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
return-1;
 }

ctx=CTX(self);
if (!mpd_qsetemax(ctx, x)) {
returnvalue_error_int(
"valid range for Emax is [0, MAX_EMAX]");
 }

return0;
}

#ifdefCONFIG_32
staticPyObject*
context_unsafe_setprec(PyObject*self, PyObject*value)
{
mpd_context_t*ctx=CTX(self);
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
returnNULL;
 }

if (x<1||x>1070000000L) {
returnvalue_error_ptr(
"valid range for unsafe prec is [1, 1070000000]");
 }

ctx->prec=x;
Py_RETURN_NONE;
}

staticPyObject*
context_unsafe_setemin(PyObject*self, PyObject*value)
{
mpd_context_t*ctx=CTX(self);
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
returnNULL;
 }

if (x<-1070000000L||x>0) {
returnvalue_error_ptr(
"valid range for unsafe emin is [-1070000000, 0]");
 }

ctx->emin=x;
Py_RETURN_NONE;
}

staticPyObject*
context_unsafe_setemax(PyObject*self, PyObject*value)
{
mpd_context_t*ctx=CTX(self);
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
returnNULL;
 }

if (x<0||x>1070000000L) {
returnvalue_error_ptr(
"valid range for unsafe emax is [0, 1070000000]");
 }

ctx->emax=x;
Py_RETURN_NONE;
}
#endif

staticint
context_setround(PyObject*self, PyObject*value, void*closureUNUSED)
{
mpd_context_t*ctx;
intx;

x=getround(value);
if (x==-1) {
return-1;
 }

ctx=CTX(self);
if (!mpd_qsetround(ctx, x)) {
INTERNAL_ERROR_INT("context_setround"); /* GCOV_NOT_REACHED */
 }

return0;
}

staticint
context_setcapitals(PyObject*self, PyObject*value, void*closureUNUSED)
{
mpd_ssize_tx;

x=PyLong_AsSsize_t(value);
if (x==-1&&PyErr_Occurred()) {
return-1;
 }

if (x!=0&&x!=1) {
returnvalue_error_int(
"valid values for capitals are 0 or 1");
 }
CtxCaps(self) = (int)x;

return0;
}

#ifdefEXTRA_FUNCTIONALITY
staticint
context_settraps(PyObject*self, PyObject*value, void*closureUNUSED)
{
mpd_context_t*ctx;
uint32_tflags;

flags=long_as_flags(value);
if (flags&DEC_ERRORS) {
return-1;
 }

ctx=CTX(self);
if (!mpd_qsettraps(ctx, flags)) {
INTERNAL_ERROR_INT("context_settraps");
 }

return0;
}
#endif

staticint
context_settraps_list(PyObject*self, PyObject*value)
{
mpd_context_t*ctx;
uint32_tflags;

flags=list_as_flags(value);
if (flags&DEC_ERRORS) {
return-1;
 }

ctx=CTX(self);
if (!mpd_qsettraps(ctx, flags)) {
INTERNAL_ERROR_INT("context_settraps_list");
 }

return0;
}

staticint
context_settraps_dict(PyObject*self, PyObject*value)
{
mpd_context_t*ctx;
uint32_tflags;

if (PyDecSignalDict_Check(value)) {
flags=SdFlags(value);
 }
else {
flags=dict_as_flags(value);
if (flags&DEC_ERRORS) {
return-1;
 }
 }

ctx=CTX(self);
if (!mpd_qsettraps(ctx, flags)) {
INTERNAL_ERROR_INT("context_settraps_dict");