#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include <Python.h>

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_typeobject.h"

#include "complexobject.h"

#include <mpdecimal.h>

#if defined(MPD_CONFIG_64)

#ifndef CONFIG_64

#define CONFIG_64 MPD_CONFIG_64

#endif

#elif defined(MPD_CONFIG_32)

#ifndef CONFIG_32

#define CONFIG_32 MPD_CONFIG_32

#endif

#include <ctype.h> // isascii()

#include <stdlib.h>

#include "docstrings.h"

#ifdef EXTRA_FUNCTIONALITY

#define _PY_DEC_ROUND_GUARD MPD_ROUND_GUARD

#define _PY_DEC_ROUND_GUARD (MPD_ROUND_GUARD-1)

struct PyDecContextObject;

struct DecCondMap;

typedef struct {

PyTypeObject *PyDecContextManager_Type;

PyTypeObject *PyDecContext_Type;

PyTypeObject *PyDecSignalDictMixin_Type;

PyTypeObject *PyDec_Type;

PyTypeObject *PyDecSignalDict_Type;

PyTypeObject *DecimalTuple;

/* Top level Exception; inherits from ArithmeticError */

PyObject *DecimalException;

#ifndef WITH_DECIMAL_CONTEXTVAR

/* Key for thread state dictionary */

PyObject *tls_context_key;

/* Invariant: NULL or a strong reference to the most recently accessed

struct PyDecContextObject *cached_context; /* Not borrowed */

PyObject *current_context_var;

/* Template for creating new thread contexts, calling Context() without

PyObject *default_context_template;

/* Basic and extended context templates */

PyObject *basic_context_template;

PyObject *extended_context_template;

PyObject *round_map[_PY_DEC_ROUND_GUARD];

/* Convert rationals for comparison */

PyObject *Rational;

/* Invariant: NULL or pointer to _pydecimal.Decimal */

PyObject *PyDecimal;

PyObject *SignalTuple;

struct DecCondMap *signal_map;

struct DecCondMap *cond_map;

/* External C-API functions */

binaryfunc _py_long_multiply;

binaryfunc _py_long_floor_divide;

ternaryfunc _py_long_power;

unaryfunc _py_float_abs;

PyCFunction _py_long_bit_length;

PyCFunction _py_float_as_integer_ratio;

} decimal_state;

static inline decimal_state *

get_module_state(PyObject *mod)

{

decimal_state *state = _PyModule_GetState(mod);

assert(state != NULL);

return state;

}

static struct PyModuleDef _decimal_module;

static PyType_Spec dec_spec;

static PyType_Spec context_spec;

static inline decimal_state *

get_module_state_by_def(PyTypeObject *tp)

{

PyObject *mod = PyType_GetModuleByDef(tp, &_decimal_module);

assert(mod != NULL);

return get_module_state(mod);

}

static inline decimal_state *

find_state_left_or_right(PyObject *left, PyObject *right)

{

PyTypeObject *base;

if (PyType_GetBaseByToken(Py_TYPE(left), &dec_spec, &base) != 1) {

assert(!PyErr_Occurred());

PyType_GetBaseByToken(Py_TYPE(right), &dec_spec, &base);

}

assert(base != NULL);

void *state = _PyType_GetModuleState(base);

assert(state != NULL);

Py_DECREF(base);

return (decimal_state *)state;

}

#if !defined(MPD_VERSION_HEX) || MPD_VERSION_HEX < 0x02050000

#error "libmpdec version >= 2.5.0 required"

#ifdef TEST_COVERAGE

#undef Py_LOCAL_INLINE

#define Py_LOCAL_INLINE Py_LOCAL

#define MPD_Float_operation MPD_Not_implemented

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

#define _Py_DEC_MINALLOC 4

typedef struct {

PyObject_HEAD

Py_hash_t hash;

mpd_t dec;

mpd_uint_t data[_Py_DEC_MINALLOC];

} PyDecObject;

typedef struct {

PyObject_HEAD

uint32_t *flags;

} PyDecSignalDictObject;

typedef struct PyDecContextObject {

} PyDecContextObject;

typedef struct {

PyObject_HEAD

PyObject *local;

PyObject *global;

} PyDecContextManagerObject;

#undef MPD

#undef CTX

#define PyDec_CheckExact(st, v) Py_IS_TYPE(v, (st)->PyDec_Type)

#define PyDec_Check(st, v) PyObject_TypeCheck(v, (st)->PyDec_Type)

#define PyDecSignalDict_Check(st, v) Py_IS_TYPE(v, (st)->PyDecSignalDict_Type)

#define PyDecContext_Check(st, v) PyObject_TypeCheck(v, (st)->PyDecContext_Type)

#define MPD(v) (&((PyDecObject *)v)->dec)

#define SdFlagAddr(v) (((PyDecSignalDictObject *)v)->flags)

#define SdFlags(v) (*((PyDecSignalDictObject *)v)->flags)

#define CTX(v) (&((PyDecContextObject *)v)->ctx)

#define CtxCaps(v) (((PyDecContextObject *)v)->capitals)

static inline decimal_state *

get_module_state_from_ctx(PyObject *v)

{

assert(PyType_GetBaseByToken(Py_TYPE(v), &context_spec, NULL) == 1);

decimal_state *state = ((PyDecContextObject *)v)->modstate;

assert(state != NULL);

return state;

}

Py_LOCAL_INLINE(PyObject *)

incr_true(void)

{

return Py_NewRef(Py_True);

}

Py_LOCAL_INLINE(PyObject *)

incr_false(void)

{

return Py_NewRef(Py_False);

}

#define DEC_INVALID_SIGNALS (MPD_Max_status+1U)

#define DEC_ERR_OCCURRED (DEC_INVALID_SIGNALS<<1)

#define DEC_ERRORS (DEC_INVALID_SIGNALS|DEC_ERR_OCCURRED)

typedef struct DecCondMap {

} DecCondMap;

#define SUBNORMAL 5

#define INEXACT 6

#define ROUNDED 7

#define SIGNAL_MAP_LEN 9

static DecCondMap signal_map_template[] = {

{"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}

};

static DecCondMap cond_map_template[] = {

{"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},

#ifdef EXTRA_FUNCTIONALITY

{"MallocError", "decimal.MallocError", MPD_Malloc_error, NULL},

{NULL}

};

static inline DecCondMap *

dec_cond_map_init(DecCondMap *template, Py_ssize_t size)

{

DecCondMap *cm;

cm = PyMem_Malloc(size);

if (cm == NULL) {

PyErr_NoMemory();

return NULL;

}

memcpy(cm, template, size);

return cm;

}

static const char *dec_signal_string[MPD_NUM_FLAGS] = {

"Clamped",

"InvalidOperation",

"DivisionByZero",

"InvalidOperation",

"InvalidOperation",

"InvalidOperation",

"Inexact",

"InvalidOperation",

"InvalidOperation",

"InvalidOperation",

"FloatOperation",

"Overflow",

"Rounded",

"Subnormal",

"Underflow",

};

static const char *invalid_rounding_err =

ROUND_05UP]";

static const char *invalid_signals_err =

Clamped]";

#ifdef EXTRA_FUNCTIONALITY

static const char *invalid_flags_err =

DecDivisionUndefined, DecFpuError, DecInvalidContext, DecMallocError]";

static int

value_error_int(const char *mesg)

{

PyErr_SetString(PyExc_ValueError, mesg);

return -1;

}

static PyObject *

value_error_ptr(const char *mesg)

{

PyErr_SetString(PyExc_ValueError, mesg);

return NULL;

}

static int

type_error_int(const char *mesg)

{

PyErr_SetString(PyExc_TypeError, mesg);

return -1;

}

static int

runtime_error_int(const char *mesg)

{

PyErr_SetString(PyExc_RuntimeError, mesg);

return -1;

}

#define INTERNAL_ERROR_INT(funcname) \

return runtime_error_int("internal error in " funcname)

static PyObject *

runtime_error_ptr(const char *mesg)

{

PyErr_SetString(PyExc_RuntimeError, mesg);

return NULL;

}

#define INTERNAL_ERROR_PTR(funcname) \

return runtime_error_ptr("internal error in " funcname)

static void

dec_traphandler(mpd_context_t *Py_UNUSED(ctx)) /* GCOV_NOT_REACHED */

{ /* GCOV_NOT_REACHED */

return; /* GCOV_NOT_REACHED */

}

static PyObject *

flags_as_exception(decimal_state *state, uint32_t flags)

{

DecCondMap *cm;

for (cm = state->signal_map; cm->name != NULL; cm++) {

if (flags&cm->flag) {

return cm->ex;

}

}

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

}

Py_LOCAL_INLINE(uint32_t)

exception_as_flag(decimal_state *state, PyObject *ex)

{

DecCondMap *cm;

for (cm = state->signal_map; cm->name != NULL; cm++) {

if (cm->ex == ex) {

return cm->flag;

}

}

PyErr_SetString(PyExc_KeyError, invalid_signals_err);

return DEC_INVALID_SIGNALS;

}

static PyObject *

flags_as_list(decimal_state *state, uint32_t flags)

{

PyObject *list;

DecCondMap *cm;

list = PyList_New(0);

if (list == NULL) {

return NULL;

}

for (cm = state->cond_map; cm->name != NULL; cm++) {

if (flags&cm->flag) {

if (PyList_Append(list, cm->ex) < 0) {

goto error;

}

}

}

for (cm = state->signal_map+1; cm->name != NULL; cm++) {

if (flags&cm->flag) {

if (PyList_Append(list, cm->ex) < 0) {

goto error;

}

}

}

return list;

error:

Py_DECREF(list);

return NULL;

}

static PyObject *

signals_as_list(decimal_state *state, uint32_t flags)

{

PyObject *list;

DecCondMap *cm;

list = PyList_New(0);

if (list == NULL) {

return NULL;

}

for (cm = state->signal_map; cm->name != NULL; cm++) {

if (flags&cm->flag) {

if (PyList_Append(list, cm->ex) < 0) {

Py_DECREF(list);

return NULL;

}

}

}

return list;

}

static uint32_t

list_as_flags(decimal_state *state, PyObject *list)

{

PyObject *item;

uint32_t flags, x;

Py_ssize_t n, 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(state, item);

if (x & DEC_ERRORS) {

return x;

}

flags |= x;

}

return flags;

}

static PyObject *

flags_as_dict(decimal_state *state, uint32_t flags)

{

DecCondMap *cm;

PyObject *dict;

dict = PyDict_New();

if (dict == NULL) {

return NULL;

}

for (cm = state->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);

return NULL;

}

}

return dict;

}

static uint32_t

dict_as_flags(decimal_state *state, PyObject *val)

{

PyObject *b;

DecCondMap *cm;

uint32_t flags = 0;

int x;

if (!PyDict_Check(val)) {

PyErr_SetString(PyExc_TypeError,

"argument must be a signal dict");

return DEC_INVALID_SIGNALS;

}

if (PyDict_Size(val) != SIGNAL_MAP_LEN) {

PyErr_SetString(PyExc_KeyError,

"invalid signal dict");

return DEC_INVALID_SIGNALS;

}

for (cm = state->signal_map; cm->name != NULL; cm++) {

b = PyDict_GetItemWithError(val, cm->ex);

if (b == NULL) {

if (PyErr_Occurred()) {

return DEC_ERR_OCCURRED;

}

PyErr_SetString(PyExc_KeyError,

"invalid signal dict");

return DEC_INVALID_SIGNALS;

}

x = PyObject_IsTrue(b);

if (x < 0) {

return DEC_ERR_OCCURRED;

}

if (x == 1) {

flags |= cm->flag;

}

}

return flags;

}

#ifdef EXTRA_FUNCTIONALITY

static uint32_t

long_as_flags(PyObject *v)

{

long x;

x = PyLong_AsLong(v);

if (x == -1 && PyErr_Occurred()) {

return DEC_ERR_OCCURRED;

}

if (x < 0 || x > (long)MPD_Max_status) {

PyErr_SetString(PyExc_TypeError, invalid_flags_err);

return DEC_INVALID_SIGNALS;

}

return x;

}

static int

dec_addstatus(PyObject *context, uint32_t status)

{

mpd_context_t *ctx = CTX(context);

decimal_state *state = get_module_state_from_ctx(context);

ctx->status |= status;

if (status & (ctx->traps|MPD_Malloc_error)) {

PyObject *ex, *siglist;

if (status & MPD_Malloc_error) {

PyErr_NoMemory();

return 1;

}

ex = flags_as_exception(state, ctx->traps&status);

if (ex == NULL) {

return 1; /* GCOV_NOT_REACHED */

}

siglist = flags_as_list(state, ctx->traps&status);

if (siglist == NULL) {

return 1;

}

PyErr_SetObject(ex, siglist);

Py_DECREF(siglist);

return 1;

}

return 0;

}

static int

getround(decimal_state *state, PyObject *v)

{

int i;

if (PyUnicode_Check(v)) {

for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {

if (v == state->round_map[i]) {

return i;

}

}

for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {

if (PyUnicode_Compare(v, state->round_map[i]) == 0) {

return i;

}

}

}

return type_error_int(invalid_rounding_err);

}

static const char *INVALID_SIGNALDICT_ERROR_MSG = "invalid signal dict";

static int

signaldict_init(PyObject *self,

PyObject *Py_UNUSED(args), PyObject *Py_UNUSED(kwds))

{

SdFlagAddr(self) = NULL;

return 0;

}

static Py_ssize_t

signaldict_len(PyObject *self)

{

if (SdFlagAddr(self) == NULL) {

return value_error_int(INVALID_SIGNALDICT_ERROR_MSG);

}

return SIGNAL_MAP_LEN;

}

static PyObject *

signaldict_iter(PyObject *self)

{

if (SdFlagAddr(self) == NULL) {

return value_error_ptr(INVALID_SIGNALDICT_ERROR_MSG);

}

decimal_state *state = get_module_state_by_def(Py_TYPE(self));

return PyTuple_Type.tp_iter(state->SignalTuple);

}

static PyObject *

signaldict_getitem(PyObject *self, PyObject *key)

{

uint32_t flag;

if (SdFlagAddr(self) == NULL) {

return value_error_ptr(INVALID_SIGNALDICT_ERROR_MSG);

}

decimal_state *state = get_module_state_by_def(Py_TYPE(self));

flag = exception_as_flag(state, key);

if (flag & DEC_ERRORS) {

return NULL;

}

return SdFlags(self)&flag ? incr_true() : incr_false();

}

static int

signaldict_setitem(PyObject *self, PyObject *key, PyObject *value)

{

uint32_t flag;

int x;

if (SdFlagAddr(self) == NULL) {

return value_error_int(INVALID_SIGNALDICT_ERROR_MSG);

}

if (value == NULL) {

return value_error_int("signal keys cannot be deleted");

}

decimal_state *state = get_module_state_by_def(Py_TYPE(self));

flag = exception_as_flag(state, 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;

}

return 0;

}

static int

signaldict_traverse(PyObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

signaldict_dealloc(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(self);

tp->tp_free(self);

Py_DECREF(tp);

}

static PyObject *

signaldict_repr(PyObject *self)

{

DecCondMap *cm;

const char *n[SIGNAL_MAP_LEN]; /* name */

const char *b[SIGNAL_MAP_LEN]; /* bool */

int i;

if (SdFlagAddr(self) == NULL) {

return value_error_ptr(INVALID_SIGNALDICT_ERROR_MSG);

}

assert(SIGNAL_MAP_LEN == 9);

decimal_state *state = get_module_state_by_def(Py_TYPE(self));

for (cm=state->signal_map, i=0; cm->name != NULL; cm++, i++) {

n[i] = cm->fqname;

b[i] = SdFlags(self)&cm->flag ? "True" : "False";

}

return PyUnicode_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]);

}

static PyObject *

signaldict_richcompare(PyObject *v, PyObject *w, int op)

{

PyObject *res = Py_NotImplemented;

decimal_state *state = get_module_state_by_def(Py_TYPE(v));

assert(PyDecSignalDict_Check(state, v));

if ((SdFlagAddr(v) == NULL) || (SdFlagAddr(w) == NULL)) {

return value_error_ptr(INVALID_SIGNALDICT_ERROR_MSG);

}

if (op == Py_EQ || op == Py_NE) {

if (PyDecSignalDict_Check(state, w)) {

res = (SdFlags(v)==SdFlags(w)) ^ (op==Py_NE) ? Py_True : Py_False;

}

else if (PyDict_Check(w)) {

uint32_t flags = dict_as_flags(state, w);

if (flags & DEC_ERRORS) {

if (flags & DEC_INVALID_SIGNALS) {

/* non-comparable: Py_NotImplemented */

PyErr_Clear();

}

else {

return NULL;

}

}

else {

res = (SdFlags(v)==flags) ^ (op==Py_NE) ? Py_True : Py_False;

}

}

}

return Py_NewRef(res);

}

static PyObject *

signaldict_copy(PyObject *self, PyObject *Py_UNUSED(dummy))

{

if (SdFlagAddr(self) == NULL) {

return value_error_ptr(INVALID_SIGNALDICT_ERROR_MSG);

}

decimal_state *state = get_module_state_by_def(Py_TYPE(self));

return flags_as_dict(state, SdFlags(self));

}

static PyMethodDef signaldict_methods[] = {

{ "copy", signaldict_copy, METH_NOARGS, NULL},

{NULL, NULL}

};

static PyType_Slot signaldict_slots[] = {

{Py_tp_dealloc, signaldict_dealloc},

{Py_tp_traverse, signaldict_traverse},

{Py_tp_repr, signaldict_repr},

{Py_tp_hash, PyObject_HashNotImplemented},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_richcompare, signaldict_richcompare},

{Py_tp_iter, signaldict_iter},

{Py_tp_methods, signaldict_methods},

{Py_tp_init, signaldict_init},

// Mapping protocol

{Py_mp_length, signaldict_len},

{Py_mp_subscript, signaldict_getitem},

{Py_mp_ass_subscript, signaldict_setitem},

{0, NULL},

};

static PyType_Spec signaldict_spec = {

.name = "decimal.SignalDictMixin",

.basicsize = sizeof(PyDecSignalDictObject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),

.slots = signaldict_slots,

};

#define Dec_CONTEXT_GET_SSIZE(mem) \

static PyObject * \

context_get##mem(PyObject *self, void *Py_UNUSED(closure)) \

{ \

return PyLong_FromSsize_t(mpd_get##mem(CTX(self))); \

}

#define Dec_CONTEXT_GET_ULONG(mem) \

static PyObject * \

context_get##mem(PyObject *self, void *Py_UNUSED(closure)) \

{ \

return PyLong_FromUnsignedLong(mpd_get##mem(CTX(self))); \

}

Dec_CONTEXT_GET_SSIZE(prec)

Dec_CONTEXT_GET_SSIZE(emax)

Dec_CONTEXT_GET_ULONG(status)

static PyObject *

context_getround(PyObject *self, void *Py_UNUSED(closure))

{

int i = mpd_getround(CTX(self));

decimal_state *state = get_module_state_from_ctx(self);

return Py_NewRef(state->round_map[i]);

}

static PyObject *

context_getcapitals(PyObject *self, void *Py_UNUSED(closure))

{

return PyLong_FromLong(CtxCaps(self));

}

#ifdef EXTRA_FUNCTIONALITY

static PyObject *

context_getallcr(PyObject *self, void *Py_UNUSED(closure))

{

return PyLong_FromLong(mpd_getcr(CTX(self)));

}

static PyObject *

context_getetiny(PyObject *self, PyObject *Py_UNUSED(dummy))

{

return PyLong_FromSsize_t(mpd_etiny(CTX(self)));

}

static PyObject *

context_getetop(PyObject *self, PyObject *Py_UNUSED(dummy))

{

return PyLong_FromSsize_t(mpd_etop(CTX(self)));

}

static int

context_setprec(PyObject *self, PyObject *value, void *Py_UNUSED(closure))

{

mpd_context_t *ctx;

mpd_ssize_t x;

x = PyLong_AsSsize_t(value);

if (x == -1 && PyErr_Occurred()) {

return -1;

}

ctx = CTX(self);

if (!mpd_qsetprec(ctx, x)) {

return value_error_int(

"valid range for prec is [1, MAX_PREC]");

}

return 0;

}

static int

context_setemin(PyObject *self, PyObject *value, void *Py_UNUSED(closure))

{

mpd_context_t *ctx;

mpd_ssize_t x;

x = PyLong_AsSsize_t(value);

if (x == -1 && PyErr_Occurred()) {

return -1;

}

ctx = CTX(self);

if (!mpd_qsetemin(ctx, x)) {

return value_error_int(

"valid range for Emin is [MIN_EMIN, 0]");

}

return 0;

}

static int

context_setemax(PyObject *self, PyObject *value, void *Py_UNUSED(closure))

{

mpd_context_t *ctx;

mpd_ssize_t x;

x = PyLong_AsSsize_t(value);

if (x == -1 && PyErr_Occurred()) {

return -1;

}

ctx = CTX(self);

if (!mpd_qsetemax(ctx, x)) {

return value_error_int(

"valid range for Emax is [0, MAX_EMAX]");

}

return 0;

}

#ifdef CONFIG_32

static PyObject *

context_unsafe_setprec(PyObject *self, PyObject *value)

{

mpd_context_t *ctx = CTX(self);

mpd_ssize_t x;

x = PyLong_AsSsize_t(value);

if (x == -1 && PyErr_Occurred()) {

return NULL;

}

if (x < 1 || x > 1070000000L) {

return value_error_ptr(

"valid range for unsafe prec is [1, 1070000000]");

}

ctx->prec = x;

Py_RETURN_NONE;

}

static PyObject *

context_unsafe_setemin(PyObject *self, PyObject *value)

{

mpd_context_t *ctx = CTX(self);

mpd_ssize_t x;

x = PyLong_AsSsize_t(value);

if (x == -1 && PyErr_Occurred()) {

return NULL;

}

if (x < -1070000000L || x > 0) {

return value_error_ptr(

"valid range for unsafe emin is [-1070000000, 0]");

}

ctx->emin = x;