Google Git
Sign in
mingw / mingw-w64 / 00c812f1a1422e89791932d6c814acbe51c31226 / . / mingw-w64-crt / math / DFP / mpdecimal-2.3 / cdecimal2.c
blob: 080c2807a54e6fac3b4bf738b893fdfb56c7bd76 [file] [log] [blame]
/*
* Copyright (c) 2008-2010 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"
#if PY_VERSION_HEX >= 0x02080000
#include "complexobject.h"
#endif
#include mpdecimal_header
#include <stdlib.h>
#include "docstrings.h"
#include "memory.h"
#include "mptypes.h"
#if PY_VERSION_HEX < 0x02050000
#error "Python versions < 2.5 not supported."
#endif
#if defined(_MSC_VER)
#define ALWAYS_INLINE __forceinline
#elif defined(LEGACY_COMPILER)
#define ALWAYS_INLINE
#undef inline
#define inline
#else
#ifdef TEST_COVERAGE
#define ALWAYS_INLINE
#else
#define ALWAYS_INLINE inline __attribute__ ((always_inline))
#endif
#endif
#if defined(_MSC_VER) && defined (CONFIG_64)
#define _PyLong_AsMpdSsize PyLong_AsLongLong
#define _PyInt_AsMpdSsize PyInt_AsSsize_t
#define _PyInt_FromMpdSsize PyInt_FromSsize_t
#define _PyLong_FromMpdSsize PyLong_FromSsize_t
#else
#define _PyLong_AsMpdSsize PyLong_AsLong
#define _PyInt_AsMpdSsize PyInt_AsLong
#define _PyInt_FromMpdSsize PyInt_FromLong
#define _PyLong_FromMpdSsize PyLong_FromLong
#endif
#ifndef Py_TYPE
#define Py_TYPE(ob) (((PyObject *)(ob))->ob_type)
#endif
#ifndef Py_SIZE
#define Py_SIZE(ob) (((PyVarObject *)(ob))->ob_size)
#endif
#ifndef PyLong_BASE
#define PyLong_BASE (1<<15)
#endif
#ifndef PYLONG_BITS_IN_DIGIT
#define PYLONG_BITS_IN_DIGIT 15
#endif
#define Dec_INCREF_TRUE (Py_INCREF(Py_True), Py_True)
#define Dec_INCREF_FALSE (Py_INCREF(Py_False), Py_False)
#define MPD_Float_operation MPD_Not_implemented
#define BOUNDS_CHECK(x, MIN, MAX) x = (x < MIN || MAX < x) ? MAX : x
typedef struct {
PyObject_HEAD
mpd_t *dec;
} PyDecObject;
typedef struct {
PyDictObject dict;
uint32_t *flags;
} PyDecSignalDictObject;
typedef struct {
PyObject_HEAD
mpd_context_t ctx;
PyObject *traps;
PyObject *flags;
int capitals;
} PyDecContextObject;
typedef struct {
PyObject_HEAD
PyObject *local;
PyObject *global;
} PyDecContextManagerObject;
#undef MPD
#undef CTX
static PyTypeObject PyDec_Type;
static PyTypeObject PyDecSignalDict_Type;
static PyTypeObject PyDecContext_Type;
static PyTypeObject PyDecContextManager_Type;
#define PyDec_CheckExact(v) (Py_TYPE(v) == &PyDec_Type)
#define PyDec_Check(v) PyObject_TypeCheck(v, &PyDec_Type)
#define PyDecSignalDict_Check(v) (Py_TYPE(v) == &PyDecSignalDict_Type)
#define PyDecContext_Check(v) (Py_TYPE(v) == &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)
#ifdef WITHOUT_THREADS
/* Default module context */
static PyObject *module_context = NULL;
#else
/* Key for thread state dictionary */
static PyObject *tls_context_key = NULL;
#endif
/* Template for creating new thread contexts, calling Context() without
* arguments and initializing the module_context on first access. */
static PyObject *default_context_template = NULL;
/* Basic and extended context templates */
static PyObject *basic_context_template = NULL;
static PyObject *extended_context_template = NULL;
typedef struct {
const char *name;
const char *fqname;
uint32_t mpd_cond;
PyObject *dec_cond;
} DecCondMap;
/* Top level Exception; inherits from ArithmeticError */
static PyObject *DecimalException = NULL;
/* Exceptions that correspond to IEEE signals; inherit from DecimalException */
static DecCondMap signal_map[] = {
{"InvalidOperation", "cdecimal.InvalidOperation", MPD_IEEE_Invalid_operation, NULL},
{"FloatOperation", "cdecimal.FloatOperation", MPD_Float_operation, NULL},
{"DivisionByZero", "cdecimal.DivisionByZero", MPD_Division_by_zero, NULL},
{"Overflow", "cdecimal.Overflow", MPD_Overflow, NULL},
{"Underflow", "cdecimal.Underflow", MPD_Underflow, NULL},
{"Subnormal", "cdecimal.Subnormal", MPD_Subnormal, NULL},
{"Inexact", "cdecimal.Inexact", MPD_Inexact, NULL},
{"Rounded", "cdecimal.Rounded", MPD_Rounded, NULL},
{"Clamped", "cdecimal.Clamped", MPD_Clamped, NULL},
{NULL}
};
/* Exceptions that inherit from InvalidOperation */
static DecCondMap cond_map[] = {
{"InvalidOperation", "cdecimal.InvalidOperation", MPD_Invalid_operation, NULL},
{"ConversionSyntax", "cdecimal.ConversionSyntax", MPD_Conversion_syntax, NULL},
{"DivisionImpossible", "cdecimal.DivisionImpossible", MPD_Division_impossible, NULL},
{"DivisionUndefined", "cdecimal.DivisionUndefined", MPD_Division_undefined, NULL},
{"FpuError", "cdecimal.FpuError", MPD_Fpu_error, NULL},
{"InvalidContext", "cdecimal.InvalidContext", MPD_Invalid_context, NULL},
{"MallocError", "cdecimal.MallocError", MPD_Malloc_error, NULL},
{NULL}
};
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 =
"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].";
static const char *invalid_signals_err =
"valid values for signals are:\n\
[InvalidOperation, FloatOperation, DivisionByZero,\n\
Overflow, Underflow, Subnormal, Inexact, Rounded,\n\
Clamped].";
static const char *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]";
static int
value_error_int(const char *mesg)
{
PyErr_SetString(PyExc_ValueError, mesg);
return -1;
}
static int
type_error_int(const char *mesg)
{
PyErr_SetString(PyExc_TypeError, mesg);
return -1;
}
static PyObject *
type_error_ptr(const char *mesg)
{
PyErr_SetString(PyExc_TypeError, mesg);
return NULL;
}
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 *ctx UNUSED) /* GCOV_NOT_REACHED */
{ /* GCOV_NOT_REACHED */
return; /* GCOV_NOT_REACHED */
}
static PyObject *
flags_as_exception(uint32_t flags)
{
DecCondMap *cm;
for (cm = signal_map; cm->name != NULL; cm++) {
if (flags&cm->mpd_cond) {
return cm->dec_cond;
}
}
INTERNAL_ERROR_PTR("flags_as_exception"); /* GCOV_NOT_REACHED */
}
static uint32_t
exception_as_flags(PyObject *ex)
{
DecCondMap *cm;
for (cm = signal_map; cm->name != NULL; cm++) {
if (cm->dec_cond == ex) {
return cm->mpd_cond;
}
}
PyErr_SetString(PyExc_TypeError, invalid_signals_err);
return UINT32_MAX;
}
static PyObject *
flags_as_list(uint32_t flags)
{
PyObject *list;
DecCondMap *cm;
if ((list = PyList_New(0)) == NULL) {
return NULL;
}
for (cm = cond_map; cm->name != NULL; cm++) {
if (flags&cm->mpd_cond) {
if (PyList_Append(list, cm->dec_cond) < 0) {
goto error;
}
}
}
for (cm = signal_map+1; cm->name != NULL; cm++) {
if (flags&cm->mpd_cond) {
if (PyList_Append(list, cm->dec_cond) < 0) {
goto error;
}
}
}
return list;
error:
Py_DECREF(list);
return NULL;
}
static PyObject *
signals_as_list(uint32_t flags)
{
PyObject *list;
DecCondMap *cm;
if ((list = PyList_New(0)) == NULL) {
return NULL;
}
for (cm = signal_map; cm->name != NULL; cm++) {
if (flags&cm->mpd_cond) {
if (PyList_Append(list, cm->dec_cond) < 0) {
goto error;
}
}
}
return list;
error:
Py_DECREF(list);
return NULL;
}
static uint32_t
list_as_flags(PyObject *list)
{
PyObject *item;
uint32_t flags, x;
ssize_t n, j;
if (!PyList_Check(list)) {
PyErr_SetString(PyExc_TypeError,
"argument must be a list of signals.");
return UINT32_MAX;
}
n = PyList_Size(list);
flags = 0;
for (j = 0; j < n; j++) {
item = PyList_GetItem(list, j);
if ((x = exception_as_flags(item)) == UINT32_MAX) {
return UINT32_MAX;
}
flags |= x;
}
return flags;
}
static int
dict_as_flags(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 -1;
}
for (cm = signal_map; cm->name != NULL; cm++) {
if ((b = PyDict_GetItem(val, cm->dec_cond)) == NULL) {
PyErr_SetString(PyExc_TypeError,
"incomplete signal dict.");
return UINT32_MAX;
}
if ((x = PyObject_IsTrue(b)) < 0) {
return UINT32_MAX;
}
if (x == 1) {
flags |= cm->mpd_cond;
}
}
return flags;
}
static uint32_t
long_as_flags(PyObject *v)
{
long x;
if (PyInt_Check(v)) {
x = PyInt_AsLong(v);
}
else if (PyLong_Check(v)) {
x = PyLong_AsLong(v);
}
else {
PyErr_SetString(PyExc_TypeError,
"integer argument required.");
return UINT32_MAX;
}
if (PyErr_Occurred()) {
return UINT32_MAX;
}
if (x < 0 || x > (long)MPD_Max_status) {
PyErr_SetString(PyExc_TypeError, invalid_flags_err);
return UINT32_MAX;
}
return x;
}
static mpd_ssize_t
long_as_mpd_ssize(PyObject *v)
{
mpd_ssize_t x;
if (PyInt_Check(v)) {
x = PyInt_AsLong(v);
}
else if (PyLong_Check(v)) {
x = _PyLong_AsMpdSsize(v);
}
else {
PyErr_SetString(PyExc_TypeError,
"integer argument required.");
return MPD_SSIZE_MAX;
}
if (PyErr_Occurred()) {
return MPD_SSIZE_MAX;
}
return x;
}
static int
dec_addstatus(PyObject *context, uint32_t status)
{
mpd_context_t *ctx = CTX(context);
ctx->status |= status;
if (ctx->traps&status) {
PyObject *ex, *siglist;
ex = flags_as_exception(ctx->traps&status);
if (ex == NULL) {
return 1; /* GCOV_NOT_REACHED */
}
siglist = flags_as_list(ctx->traps&status);
if (siglist == NULL) {
return 1;
}
PyErr_SetObject(ex, siglist);
Py_DECREF(siglist);
return 1;
}
return 0;
}
/******************************************************************************/
/* SignalDict Object */
/******************************************************************************/
static int
signaldict_init(PyObject *self, PyObject *args, PyObject *kwds)
{
if (PyDict_Type.tp_init(self, args, kwds) < 0) {
return -1;
}
SdFlagAddr(self) = NULL;
return 0;
}
/* sync flags and dictionary, using the flags as the master */
static int
signaldict_update(PyObject *self)
{
PyObject *b;
DecCondMap *cm;
uint32_t flags;
flags = SdFlags(self);
for (cm = signal_map; cm->name != NULL; cm++) {
b = (flags&cm->mpd_cond) ? Py_True : Py_False;
if (PyDict_SetItem(self, cm->dec_cond, b) < 0) {
return -1;
}
}
return 0;
}
/* set all flags to false */
static int
signaldict_clear_all(PyObject *self)
{
DecCondMap *cm;
SdFlags(self) = 0;
for (cm = signal_map; cm->name != NULL; cm++) {
if (PyDict_SetItem(self, cm->dec_cond, Py_False) < 0) {
return -1;
}
}
return 0;
}
static int
signaldict_setitem(PyObject *self, PyObject *key, PyObject *value)
{
uint32_t flag;
int x;
if ((flag = exception_as_flags(key)) == UINT_MAX) {
return -1;
}
if ((x = PyObject_IsTrue(value)) < 0) {
return -1;
}
if (x == 1) {
SdFlags(self) |= flag;
if (PyDict_SetItem(self, key, Py_True) < 0) {
return -1;
}
return 0;
}
else {
SdFlags(self) &= ~flag;
if (PyDict_SetItem(self, key, Py_False) < 0) {
return -1;
}
return 0;
}
}
static PyObject *
signaldict_call_unary(PyObject *self, char *name)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyObject_CallMethod((PyObject *)&PyDict_Type, name, "O", self);
}
static int
signaldict_compare(PyObject *a, PyObject *b)
{
if (PyDecSignalDict_Check(a)) {
if (signaldict_update(a) < 0) {
return -1;
}
}
if (PyDecSignalDict_Check(b)) {
if (signaldict_update(b) < 0) {
return -1;
}
}
return PyDict_Type.tp_compare(a, b);
}
static int
signaldict_contains(PyObject *self, PyObject *key)
{
if (signaldict_update(self) < 0) {
return -1;
}
return PyDict_Contains(self, key);
}
static PyObject *
signaldict_copy(PyObject *self)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Copy(self);
}
static PyObject *
signaldict_get(PyObject *self, PyObject *args)
{
PyObject *key = NULL, *failobj = NULL;
if (!PyArg_ParseTuple(args, "O|O", &key, &failobj)) {
return NULL; /* GCOV_NOT_REACHED (why?) */
}
if (signaldict_update(self) < 0) {
return NULL;
}
if (failobj) {
return PyObject_CallMethod((PyObject *)&PyDict_Type, "get",
"OOO", self, key, failobj);
}
return PyObject_CallMethod((PyObject *)&PyDict_Type, "get",
"OO", self, key);
}
static PyObject *
signaldict_has_key(PyObject *self, PyObject *key)
{
int ret;
if (signaldict_update(self) < 0) {
return NULL;
}
ret = PyDict_Contains(self, key);
return ret < 0 ? NULL : PyBool_FromLong(ret);
}
static PyObject *
signaldict_items(PyObject *self)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Items(self);
}
static PyObject *
signaldict_iter(PyObject *self)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Type.tp_iter(self);
}
static PyObject *
signaldict_iterkeys(PyObject *self)
{
return signaldict_call_unary(self, "iterkeys");
}
static PyObject *
signaldict_itervalues(PyObject *self)
{
return signaldict_call_unary(self, "itervalues");
}
static PyObject *
signaldict_iteritems(PyObject *self)
{
return signaldict_call_unary(self, "iteritems");
}
static PyObject *
signaldict_keys(PyObject *self)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Keys(self);
}
static Py_ssize_t
signaldict_length(PyObject *self)
{
if (signaldict_update(self) < 0) {
return -1;
}
return PyDict_Type.tp_as_mapping->mp_length(self);
}
static int
signaldict_print(PyObject *self, FILE *fp, int flags) /* GCOV_NOT_REACHED */
{
if (signaldict_update(self) < 0) { /* GCOV_NOT_REACHED */
return -1; /* GCOV_NOT_REACHED */
}
return PyDict_Type.tp_print(self, fp, flags); /* GCOV_NOT_REACHED */
}
static PyObject *
signaldict_repr(PyObject *self)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Type.tp_repr(self);
}
static PyObject *
signaldict_sizeof(PyObject *self)
{
return signaldict_call_unary(self, "__sizeof__");
}
static int
signaldict_ass_sub(PyObject *self, PyObject *v, PyObject *w)
{
if (w == NULL) {
return value_error_int("signal keys cannot be deleted.");
}
else {
return signaldict_setitem(self, v, w);
}
}
static PyObject *
signaldict_subscript(PyObject *self, PyObject *key)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Type.tp_as_mapping->mp_subscript(self, key);
}
static PyObject *
signaldict_values(PyObject *self)
{
if (signaldict_update(self) < 0) {
return NULL;
}
return PyDict_Values(self);
}
static PyMappingMethods signaldict_as_mapping = {
(lenfunc)signaldict_length, /*mp_length*/
(binaryfunc)signaldict_subscript, /*mp_subscript*/
(objobjargproc)signaldict_ass_sub /*mp_ass_subscript*/
};
static PySequenceMethods signaldict_as_sequence = {
0, /* sq_length */
0, /* sq_concat */
0, /* sq_repeat */
0, /* sq_item */
0, /* sq_slice */
0, /* sq_ass_item */
0, /* sq_ass_slice */
signaldict_contains, /* sq_contains */
0, /* sq_inplace_concat */
0, /* sq_inplace_repeat */
};
static PyMethodDef mapp_methods[] = {
{"__contains__", (PyCFunction)signaldict_contains, METH_O|METH_COEXIST, NULL},
{"__getitem__", (PyCFunction)signaldict_subscript, METH_O|METH_COEXIST, NULL},
{"__sizeof__", (PyCFunction)signaldict_sizeof, METH_NOARGS, NULL},
{"has_key", (PyCFunction)signaldict_has_key, METH_O, NULL},
{"get", (PyCFunction)signaldict_get, METH_VARARGS, NULL},
{"keys", (PyCFunction)signaldict_keys, METH_NOARGS, NULL},
{"items", (PyCFunction)signaldict_items, METH_NOARGS, NULL},
{"values", (PyCFunction)signaldict_values, METH_NOARGS, NULL},
{"copy", (PyCFunction)signaldict_copy, METH_NOARGS, NULL},
{"iterkeys", (PyCFunction)signaldict_iterkeys, METH_NOARGS, NULL},
{"itervalues", (PyCFunction)signaldict_itervalues, METH_NOARGS, NULL},
{"iteritems", (PyCFunction)signaldict_iteritems, METH_NOARGS, NULL},
{NULL, NULL}
};
static PyTypeObject PyDecSignalDict_Type =
{
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"cdecimal.SignalDict", /* tp_name */
sizeof(PyDecSignalDictObject), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
(printfunc)signaldict_print, /* tp_print */
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
(cmpfunc)signaldict_compare, /* tp_compare */
(reprfunc) signaldict_repr, /* tp_repr */
0, /* tp_as_number */
&signaldict_as_sequence, /* tp_as_sequence */
&signaldict_as_mapping, /* tp_as_mapping */
#if PY_VERSION_HEX >= 0x02060000
(hashfunc) PyObject_HashNotImplemented, /* tp_hash */
#else
(hashfunc) 0, /* tp_hash */
#endif
0, /* tp_call */
(reprfunc) 0, /* tp_str */
(getattrofunc) PyObject_GenericGetAttr, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
(PyBufferProcs *) 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
0, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
(getiterfunc)signaldict_iter, /* tp_iter */
0, /* tp_iternext */
mapp_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 */
};
/******************************************************************************/
/* Context Object, Part 1 */
/******************************************************************************/
static PyObject *
context_getprec(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue(CONV_mpd_ssize_t, mpd_getprec(ctx));
}
static PyObject *
context_getemax(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue(CONV_mpd_ssize_t, mpd_getemax(ctx));
}
static PyObject *
context_getemin(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue(CONV_mpd_ssize_t, mpd_getemin(ctx));
}
static PyObject *
context_getetiny(PyObject *self, PyObject *dummy UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue(CONV_mpd_ssize_t, mpd_etiny(ctx));
}
static PyObject *
context_getetop(PyObject *self, PyObject *dummy UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue(CONV_mpd_ssize_t, mpd_etop(ctx));
}
static PyObject *
context_getround(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue("i", mpd_getround(ctx));
}
static PyObject *
context_getcapitals(PyObject *self, void *closure UNUSED)
{
return Py_BuildValue("i", CtxCaps(self));
}
static PyObject *
context_gettraps(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue("i", mpd_gettraps(ctx));
}
static PyObject *
context_getstatus(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue("i", mpd_getstatus(ctx));
}
static PyObject *
context_getclamp(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue("i", mpd_getclamp(ctx));
}
static PyObject *
context_getallcr(PyObject *self, void *closure UNUSED)
{
mpd_context_t *ctx;
ctx = CTX(self);
return Py_BuildValue("i", mpd_getcr(ctx));
}
static int
context_setprec(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_context_t *ctx;
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (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 *closure UNUSED)
{
mpd_context_t *ctx;
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (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 *closure UNUSED)
{
mpd_context_t *ctx;
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (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;
}
static PyObject *
context_unsafe_setprec(PyObject *self, PyObject *value)
{
mpd_context_t *ctx = CTX(self);
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return NULL;
}
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 = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return NULL;
}
ctx->emin = x;
Py_RETURN_NONE;
}
static PyObject *
context_unsafe_setemax(PyObject *self, PyObject *value)
{
mpd_context_t *ctx = CTX(self);
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return NULL;
}
ctx->emax = x;
Py_RETURN_NONE;
}
static int
context_setround(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_context_t *ctx;
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return -1;
}
BOUNDS_CHECK(x, INT_MIN, INT_MAX);
ctx = CTX(self);
if (!mpd_qsetround(ctx, (int)x)) {
return type_error_int(invalid_rounding_err);
}
return 0;
}
static int
context_setcapitals(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return -1;
}
BOUNDS_CHECK(x, INT_MIN, INT_MAX);
if (x != 0 && x != 1) {
return value_error_int(
"valid values for capitals are 0 or 1.");
}
CtxCaps(self) = (int)x;
return 0;
}
static int
context_settraps(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_context_t *ctx;
uint32_t flags;
flags = long_as_flags(value);
if (flags == UINT32_MAX) {
return -1;
}
ctx = CTX(self);
if (!mpd_qsettraps(ctx, flags)) {
INTERNAL_ERROR_INT("context_settraps");
}
return 0;
}
static int
context_settraps_list(PyObject *self, PyObject *value)
{
mpd_context_t *ctx;
uint32_t flags;
flags = list_as_flags(value);
if (flags == UINT32_MAX) {
return -1;
}
ctx = CTX(self);
if (!mpd_qsettraps(ctx, flags)) {
INTERNAL_ERROR_INT("context_settraps_list");
}
return 0;
}
static int
context_settraps_dict(PyObject *self, PyObject *value)
{
mpd_context_t *ctx;
uint32_t flags;
flags = dict_as_flags(value);
if (flags == UINT32_MAX) {
return -1;
}
ctx = CTX(self);
if (!mpd_qsettraps(ctx, flags)) {
INTERNAL_ERROR_INT("context_settraps_dict");
}
return 0;
}
static int
context_setstatus(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_context_t *ctx;
uint32_t flags;
flags = long_as_flags(value);
if (flags == UINT32_MAX) {
return -1;
}
ctx = CTX(self);
if (!mpd_qsetstatus(ctx, flags)) {
INTERNAL_ERROR_INT("context_setstatus");
}
return 0;
}
static int
context_setstatus_list(PyObject *self, PyObject *value)
{
mpd_context_t *ctx;
uint32_t flags;
flags = list_as_flags(value);
if (flags == UINT32_MAX) {
return -1;
}
ctx = CTX(self);
if (!mpd_qsetstatus(ctx, flags)) {
INTERNAL_ERROR_INT("context_setstatus_list");
}
return 0;
}
static int
context_setstatus_dict(PyObject *self, PyObject *value)
{
mpd_context_t *ctx;
uint32_t flags;
flags = dict_as_flags(value);
if (flags == UINT32_MAX) {
return -1;
}
ctx = CTX(self);
if (!mpd_qsetstatus(ctx, flags)) {
INTERNAL_ERROR_INT("context_setstatus_dict");
}
return 0;
}
static int
context_setclamp(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_context_t *ctx;
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return -1;
}
BOUNDS_CHECK(x, INT_MIN, INT_MAX);
ctx = CTX(self);
if (!mpd_qsetclamp(ctx, (int)x)) {
return value_error_int("valid values for clamp are 0 or 1.");
}
return 0;
}
static int
context_setallcr(PyObject *self, PyObject *value, void *closure UNUSED)
{
mpd_context_t *ctx;
mpd_ssize_t x;
x = long_as_mpd_ssize(value);
if (PyErr_Occurred()) {
return -1;
}
BOUNDS_CHECK(x, INT_MIN, INT_MAX);
ctx = CTX(self);
if (!mpd_qsetcr(ctx, (int)x)) {
return value_error_int("valid values for _allcr are 0 or 1.");
}
return 0;
}
static PyObject *
context_getattr(PyObject *self, PyObject *name)
{
PyObject *retval;
if (!PyString_Check(name)) {
PyErr_Format(PyExc_TypeError, /* GCOV_NOT_REACHED (why?) */
"attribute name must be string, not '%.200s'",
name->ob_type->tp_name); /* GCOV_NOT_REACHED */
return NULL; /* GCOV_NOT_REACHED */
}
if (strcmp(PyString_AS_STRING(name), "traps") == 0) {
retval = ((PyDecContextObject *)self)->traps;
Py_INCREF(retval);
return retval;
}
else if (strcmp(PyString_AS_STRING(name), "flags") == 0) {
retval = ((PyDecContextObject *)self)->flags;
Py_INCREF(retval);
return retval;
}
else {
return PyObject_GenericGetAttr(self, name);
}
}
static int
context_setattr(PyObject *self, PyObject *name, PyObject *value)
{
if (!PyString_Check(name)) {
PyErr_Format(PyExc_TypeError, /* GCOV_NOT_REACHED (why?) */
"attribute name must be string, not '%.200s'",
name->ob_type->tp_name); /* GCOV_NOT_REACHED */
return -1; /* GCOV_NOT_REACHED */
}
if (value == NULL) {
PyErr_SetString(PyExc_AttributeError,
"context attributes cannot be deleted.");
return -1;
}
if (strcmp(PyString_AS_STRING(name), "traps") == 0) {
return context_settraps_dict(self, value);
}
else if (strcmp(PyString_AS_STRING(name), "flags") == 0) {
return context_setstatus_dict(self, value);
}
else {
return PyObject_GenericSetAttr(self, name, value);
}
}
static PyObject *
context_clear_traps(PyObject *self, PyObject *dummy UNUSED)
{
PyDecContextObject *decctx = (PyDecContextObject *)self;
if (signaldict_clear_all(decctx->traps) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
context_clear_flags(PyObject *self, PyObject *dummy UNUSED)
{
PyDecContextObject *decctx = (PyDecContextObject *)self;
if (signaldict_clear_all(decctx->flags) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
context_new(PyTypeObject *type UNUSED, PyObject *args UNUSED,
PyObject *kwds UNUSED)
{
PyDecContextObject *self = NULL;
mpd_context_t *ctx;
self = PyObject_New(PyDecContextObject, &PyDecContext_Type);
if (self == NULL) {
return NULL;
}
self->traps = PyObject_CallObject((PyObject *)&PyDecSignalDict_Type, NULL);
if (self->traps == NULL) {
self->flags = NULL;
Py_DECREF(self);
return NULL;
}
self->flags = PyObject_CallObject((PyObject *)&PyDecSignalDict_Type, NULL);
if (self->flags == NULL) {
Py_DECREF(self);
return NULL;
}
ctx = CTX(self);
SdFlagAddr(self->traps) = &ctx->traps;
SdFlagAddr(self->flags) = &ctx->status;
return (PyObject *)self;
}
static void
context_dealloc(PyDecContextObject *self)
{
Py_XDECREF(self->traps);
Py_XDECREF(self->flags);
PyObject_Del(self);
}
#ifdef CONFIG_64
#define DEC_DFLT_EMAX 999999999
#define DEC_DFLT_EMIN -999999999
#else
#define DEC_DFLT_EMAX MPD_MAX_EMAX
#define DEC_DFLT_EMIN MPD_MIN_EMIN
#endif
static mpd_context_t dflt_ctx = {
28, DEC_DFLT_EMAX, DEC_DFLT_EMIN,
MPD_IEEE_Invalid_operation|MPD_Division_by_zero|MPD_Overflow,
0, 0, MPD_ROUND_HALF_EVEN, 0, 1
};
static int
getround(PyObject *v)
{
const char *s;
long x;
int i;
if (PyInt_Check(v) || PyLong_Check(v)) {
x = PyLong_AsLong(v);
if (PyErr_Occurred()) {
return -1;
}
BOUNDS_CHECK(x, 0, INT_MAX);
return (int)x;
}
else if (PyString_Check(v)) {
for (i = 0; i < MPD_ROUND_GUARD; i++) {
s = mpd_round_string[i];
if (strcmp(PyString_AS_STRING(v), s) == 0) {
return i;
}
}
}
return type_error_int("invalid rounding mode.");
}
static int
context_init(PyObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {
"prec", "rounding", "Emin", "Emax", "capitals", "clamp",
"flags", "traps", "_allcr", NULL
};
PyObject *rounding = NULL;
PyObject *traps = NULL;
PyObject *status = NULL;
mpd_context_t *ctx, t=dflt_ctx;
int capitals = 1;
int ret;
assert(PyTuple_Check(args));
ctx = CTX(self);
if (default_context_template) {
t = *CTX(default_context_template);
}
if (!PyArg_ParseTupleAndKeywords(
args, kwds,
"|" CONV_mpd_ssize_t "O" CONV_mpd_ssize_t CONV_mpd_ssize_t "ii"
"OOi", kwlist,
&t.prec, &rounding, &t.emin, &t.emax, &capitals, &t.clamp,
&status, &traps, &t.allcr
)) {
return -1;
}
if (rounding != NULL) {
if ((t.round = getround(rounding)) < 0) {
return -1;
}
}
if (!mpd_qsetprec(ctx, t.prec) ||
!mpd_qsetemin(ctx, t.emin) ||
!mpd_qsetemax(ctx, t.emax) ||
!mpd_qsetclamp(ctx, t.clamp) ||
!mpd_qsetcr(ctx, t.allcr)) {
return value_error_int("invalid context.");
}
if (!mpd_qsetround(ctx, t.round) ||
!mpd_qsettraps(ctx, t.traps) ||
!mpd_qsetstatus(ctx, t.status)) {
return type_error_int("invalid context.");
}
if (capitals != 0 && capitals != 1) {
return value_error_int("invalid context.");
}
CtxCaps(self) = capitals;
if (traps != NULL) {
if (PyInt_Check(traps) || PyLong_Check(traps)) {
ret = context_settraps(self, traps, NULL);
}
else if (PyList_Check(traps)) {
ret = context_settraps_list(self, traps);
}
else {
ret = context_settraps_dict(self, traps);
}
if (ret < 0) {
return ret;
}
}
if (status != NULL) {
if (PyInt_Check(status) || PyLong_Check(status)) {
ret = context_setstatus(self, status, NULL);
}
else if (PyList_Check(status)) {
ret = context_setstatus_list(self, status);
}
else {
ret = context_setstatus_dict(self, status);
}
if (ret < 0) {
return ret;
}
}
return 0;
}
#define FD_CTX_LEN 432
static PyObject *
context_repr(PyDecContextObject *self)
{
mpd_context_t *ctx;
char s[FD_CTX_LEN];
char *cp;
int n, mem;
assert(PyDecContext_Check(self));
ctx = CTX(self);
cp = s; mem = FD_CTX_LEN;
n = snprintf(cp, mem,
"Context(prec=%"PRI_mpd_ssize_t", rounding=%s, "
"Emin=%"PRI_mpd_ssize_t", Emax=%"PRI_mpd_ssize_t", "
"capitals=%d, clamp=%d, flags=",
ctx->prec, mpd_round_string[ctx->round],
ctx->emin, ctx->emax,
self->capitals, ctx->clamp);
if (n < 0 || n >= mem) goto error;
cp += n; mem -= n;
n = mpd_lsnprint_signals(cp, mem, ctx->status, dec_signal_string);
if (n < 0 || n >= mem) goto error;
cp += n; mem -= n;
n = snprintf(cp, mem, ", traps=");
if (n < 0 || n >= mem) goto error;
cp += n; mem -= n;
n = mpd_lsnprint_signals(cp, mem, ctx->traps, dec_signal_string);
if (n < 0 || n >= mem) goto error;
cp += n; mem -= n;
n = snprintf(cp, mem, ")");
if (n < 0 || n >= mem) goto error;
return PyString_FromString(s);
error:
INTERNAL_ERROR_PTR("context_repr");
}
static void
init_basic_context(PyObject *v)
{
mpd_context_t ctx = dflt_ctx;
ctx.prec = 9;
ctx.traps |= (MPD_Underflow|MPD_Clamped);
ctx.round = MPD_ROUND_HALF_UP;
*CTX(v) = ctx;
CtxCaps(v) = 1;
}
static void
init_extended_context(PyObject *v)
{
mpd_context_t ctx = dflt_ctx;
ctx.prec = 9;
ctx.traps = 0;
*CTX(v) = ctx;
CtxCaps(v) = 1;
}
/* Factory function for creating IEEE interchange format contexts */
static PyObject *
ieee_context(PyObject *dummy UNUSED, PyObject *v)
{
PyObject *context;
mpd_ssize_t bits;
mpd_context_t ctx;
bits = long_as_mpd_ssize(v);
if (PyErr_Occurred()) {
return NULL;
}
if (bits <= 0 || bits > INT_MAX) {
goto error;
}
if (mpd_ieee_context(&ctx, (int)bits) < 0) {
goto error;
}
context = PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL);
if (context == NULL) {
return NULL;
}
*CTX(context) = ctx;
return context;
error:
PyErr_Format(PyExc_ValueError,
"argument must be a multiple of 32, with a maximum of %d.",
MPD_IEEE_CONTEXT_MAX_BITS);
return NULL;
}
static PyObject *
context_copy(PyObject *self)
{
PyObject *copy;
copy = PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL);
if (copy == NULL) {
return NULL;
}
*CTX(copy) = *CTX(self);
CTX(copy)->newtrap = 0;
CtxCaps(copy) = CtxCaps(self);
return copy;
}
static PyObject *
context_reduce(PyObject *self, PyObject *args UNUSED)
{
PyObject *flags;
PyObject *traps;
PyObject *ret;
mpd_context_t *ctx;
ctx = CTX(self);
if ((flags = signals_as_list(ctx->status)) == NULL) {
return NULL;
}
if ((traps = signals_as_list(ctx->traps)) == NULL) {
Py_DECREF(flags);
return NULL;
}
ret = Py_BuildValue(
"O(" CONV_mpd_ssize_t "s" CONV_mpd_ssize_t CONV_mpd_ssize_t
"iiOO)",
Py_TYPE(self),
ctx->prec, mpd_round_string[ctx->round], ctx->emin, ctx->emax,
CtxCaps(self), ctx->clamp, flags, traps
);
Py_DECREF(flags);
Py_DECREF(traps);
return ret;
}
static PyObject *
PyDec_SetStatusFromList(PyObject *self, PyObject *value)
{
if (context_setstatus_list(self, value) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
PyDec_SetTrapsFromList(PyObject *self, PyObject *value)
{
if (context_settraps_list(self, value) < 0) {
return NULL;
}
Py_RETURN_NONE;
}
static PyGetSetDef context_getsets [] =
{
{ "prec", (getter)context_getprec, (setter)context_setprec, NULL, NULL},
{ "Emax", (getter)context_getemax, (setter)context_setemax, NULL, NULL},
{ "Emin", (getter)context_getemin, (setter)context_setemin, NULL, NULL},
{ "rounding", (getter)context_getround, (setter)context_setround, NULL, NULL},
{ "capitals", (getter)context_getcapitals, (setter)context_setcapitals, NULL, NULL},
{ "clamp", (getter)context_getclamp, (setter)context_setclamp, NULL, NULL},
{ "_clamp", (getter)context_getclamp, (setter)context_setclamp, NULL, NULL},
{ "_allcr", (getter)context_getallcr, (setter)context_setallcr, NULL, NULL},
{ "_traps", (getter)context_gettraps, (setter)context_settraps, NULL, NULL},
{ "_flags", (getter)context_getstatus, (setter)context_setstatus, NULL, NULL},
{NULL}
};
#define CONTEXT_CHECK(obj) \
if (!PyDecContext_Check(obj)) { \
PyErr_SetString(PyExc_TypeError, \
"argument must be a context."); \
return NULL; \
}
#define CONTEXT_CHECK_VA(obj) \
if (!PyDecContext_Check(obj)) { \
PyErr_SetString(PyExc_TypeError, \
"optional argument must be a context."); \
return NULL; \
}
/******************************************************************************/
/* Global, thread local and temporary contexts */
/******************************************************************************/
#ifdef WITHOUT_THREADS
/* Return borrowed reference to the current context. When compiled
* without threads, this is always the module context. */
static int module_context_set = 0;
static PyObject *
current_context(void)
{
/* In decimal.py, the module context is automatically initialized
* from the DefaultContext when it is first accessed. This
* complicates the code and has a speed penalty of 1-2%. */
if (module_context_set) {
return module_context;
}
*CTX(module_context) = *CTX(default_context_template);
module_context_set = 1;
return module_context;
}
/* ctxobj := borrowed reference to the current context */
#define CURRENT_CONTEXT(ctxobj) \
ctxobj = current_context()
/* ctx := pointer to the mpd_context_t struct of the current context */
#define CURRENT_CONTEXT_ADDR(ctx) \
ctx = CTX(current_context())
/* Return current context, increment reference */
static PyObject *
PyDec_GetCurrentContext(void)
{
PyObject *context;
CURRENT_CONTEXT(context);
Py_INCREF(context);
return context;
}
/* Set the module context to a new context, decrement old reference */
static PyObject *
PyDec_SetCurrentContext(PyObject *self UNUSED, PyObject *v)
{
CONTEXT_CHECK(v);
/* If the new context is one of the templates, make a copy.
* This is the current behavior of decimal.py. */
if (v == default_context_template ||
v == basic_context_template ||
v == extended_context_template) {
if ((v = context_copy(v)) == NULL) {
return NULL;
}
}
else {
Py_INCREF(v);
}
Py_XDECREF(module_context);
module_context = v;
module_context_set = 1;
Py_RETURN_NONE;
}
#else
/*
* Thread local storage currently has a speed penalty of about 16%.
* All functions that map Python's arithmetic operators to mpdecimal
* functions have to look up the current context for each and every
* operation.
*/
/* Return borrowed reference to thread local context. */
static PyObject *
current_context(void)
{
PyObject *dict = NULL;
PyObject *tl_context = NULL;
dict = PyThreadState_GetDict();
if (dict == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"cannot get thread state.");
return NULL;
}
tl_context = PyDict_GetItem(dict, tls_context_key);
if (tl_context != NULL) {
/* We already have a thread local context and
* return a borrowed reference. */
CONTEXT_CHECK(tl_context);
return tl_context;
}
/* Otherwise, set up a new thread local context. */
tl_context = context_copy(default_context_template);
if (tl_context == NULL) {
return NULL;
}
if (PyDict_SetItem(dict, tls_context_key, tl_context) < 0) {
Py_DECREF(tl_context);
return NULL;
}
Py_DECREF(tl_context);
/* refcount is 1 */
return tl_context;
}
/* ctxobj := borrowed reference to the current context */
#define CURRENT_CONTEXT(ctxobj) \
if ((ctxobj = current_context()) == NULL) { \
return NULL; \
}
/* ctx := pointer to the mpd_context_t struct of the current context */
#define CURRENT_CONTEXT_ADDR(ctx) { \
PyObject *_c_t_x_o_b_j = current_context(); \
if (_c_t_x_o_b_j == NULL) { \
return NULL; \
} \
ctx = CTX(_c_t_x_o_b_j); \
}
/* Return current context, increment reference */
static PyObject *
PyDec_GetCurrentContext(void)
{
PyObject *obj;
if ((obj = current_context()) == NULL) {
return NULL;
}
Py_INCREF(obj);
return obj;
}
/* Set the thread local context to a new context, decrement old reference */
static PyObject *
PyDec_SetCurrentContext(PyObject *self UNUSED, PyObject *v)
{
PyObject *dict;
CONTEXT_CHECK(v);
dict = PyThreadState_GetDict();
if (dict == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"cannot get thread state.");
return NULL;
}
/* If the new context is one of the templates, make a copy.
* This is the current behavior of decimal.py. */
if (v == default_context_template ||
v == basic_context_template ||
v == extended_context_template) {
if ((v = context_copy(v)) == NULL) {
return NULL;
}
}
else {
Py_INCREF(v);
}
if (PyDict_SetItem(dict, tls_context_key, v) < 0) {
Py_DECREF(v);
return NULL;
}
Py_DECREF(v);
Py_RETURN_NONE;
}
#endif
/* Context manager object for the 'with' statement. The manager
* owns one reference to the global (outer) context and one
* to the local (inner) context. */
static PyObject *
ctxmanager_new(PyTypeObject *type UNUSED, PyObject *args)
{
PyDecContextManagerObject *self;
PyObject *local;
PyObject *global;
CURRENT_CONTEXT(global);
local = global;
if (!PyArg_ParseTuple(args, "|O", &local)) {
return NULL;
}
CONTEXT_CHECK_VA(local);
self = PyObject_New(PyDecContextManagerObject,
&PyDecContextManager_Type);
if (self == NULL) {
return NULL;
}
self->local = context_copy(local);
if (self->local == NULL) {
self->global = NULL;
Py_DECREF(self);
return NULL;
}
self->global = global;
Py_INCREF(self->global);
return (PyObject *)self;
}
static void
ctxmanager_dealloc(PyDecContextManagerObject *self)
{
Py_XDECREF(self->local);
Py_XDECREF(self->global);
PyObject_Del(self);
}
static PyObject *
ctxmanager_set_local(PyDecContextManagerObject *self, PyObject *args UNUSED)
{
PyObject *ret;
ret = PyDec_SetCurrentContext(NULL, self->local);
if (ret == NULL) {
return NULL;
}
Py_DECREF(ret);
Py_INCREF(self->local);
return self->local;
}
static PyObject *
ctxmanager_restore_global(PyDecContextManagerObject *self,
PyObject *args UNUSED)
{
PyObject *ret;
ret = PyDec_SetCurrentContext(NULL, self->global);
if (ret == NULL) {
return NULL;
}
Py_DECREF(ret);
Py_RETURN_NONE;
}
static PyMethodDef ctxmanager_methods[] = {
{"__enter__", (PyCFunction)ctxmanager_set_local, METH_NOARGS, NULL},
{"__exit__", (PyCFunction)ctxmanager_restore_global, METH_VARARGS, NULL},
{NULL, NULL}
};
static PyTypeObject PyDecContextManager_Type =
{
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"cdecimal.ContextManager", /* tp_name */
sizeof(PyDecContextManagerObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) ctxmanager_dealloc, /* tp_dealloc */
0, /* tp_print */
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
0, /* tp_compare */
(reprfunc) 0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
(getattrofunc) PyObject_GenericGetAttr, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
(PyBufferProcs *) 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
0, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
ctxmanager_methods, /* tp_methods */
};
/******************************************************************************/
/* New Decimal Object */
/******************************************************************************/
static PyObject *
PyDecType_New(PyTypeObject *type)
{
PyObject *dec;
if (type == &PyDec_Type) {
dec = (PyObject *)PyObject_New(PyDecObject, &PyDec_Type);
}
else {
dec = type->tp_alloc(type, 0);
}
if (dec == NULL) {
return NULL;
}
MPD(dec) = mpd_qnew();
if (MPD(dec) == NULL) {
Py_DECREF(dec);
PyErr_NoMemory();
return NULL;
}
return dec;
}
#define dec_alloc() PyDecType_New(&PyDec_Type)
static void
dec_dealloc(PyObject *dec)
{
if (MPD(dec)) {
mpd_del(MPD(dec));
}
Py_TYPE(dec)->tp_free(dec);
}
/******************************************************************************/
/* Conversions to Decimal */
/******************************************************************************/
/* Return a new PyDecObject or a subtype from a C string. Use the context
during conversion. */
static PyObject *
PyDecType_FromCString(PyTypeObject *type, const char *s,
PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
dec = PyDecType_New(type);
if (dec == NULL) {
return NULL;
}
mpd_qset_string(MPD(dec), s, CTX(context), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
/* Return a new PyDecObject or a subtype from a C string. Attempt exact
conversion. If the operand cannot be converted exactly, set
InvalidOperation. */
static PyObject *
PyDecType_FromCStringExact(PyTypeObject *type, const char *s,
PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
mpd_context_t maxctx;
dec = PyDecType_New(type);
if (dec == NULL) {
return NULL;
}
mpd_maxcontext(&maxctx);
mpd_qset_string(MPD(dec), s, &maxctx, &status);
if (status & (MPD_Inexact|MPD_Rounded)) {
/* we want exact results */
mpd_seterror(MPD(dec), MPD_Invalid_operation, &status);
}
status &= MPD_Errors;
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
/* Wrap PyUnicode_EncodeDecimal. */
static char *
dec_unicode_as_str(const PyObject *u)
{
char *s;
s = PyMem_Malloc(PyUnicode_GET_SIZE(u)+1);
if (s == NULL) {
PyErr_NoMemory();
return NULL;
}
if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(u),
PyUnicode_GET_SIZE(u),
s, NULL)) {
PyMem_Free(s);
return NULL;
}
return s;
}
/* Strip leading and trailing whitespace. Return x unchanged if no
whitespace is found, otherwise return a newly allocated string
with whitespace stripped. */
static char *
strip_ws(const char *x)
{
char *s, *t;
char *y;
size_t n;
s = (char *)x;
while (isspace((unsigned char)*s))
s++;
t = y = s+strlen(s);
while (t > s && isspace((unsigned char)*(t-1)))
t--;
if (s != x || t != y) {
n = t-s;
if ((y = PyMem_Malloc(n+1)) == NULL) {
PyErr_NoMemory();
return NULL;
}
strncpy(y, s, n);
y[n] = '\0';
return y;
}
return (char *)x;
}
/* Return a new PyDecObject or a subtype from a PyStringObject. */
static PyObject *
PyDecType_FromString(PyTypeObject *type, const PyObject *v,
PyObject *context)
{
char *s;
s = PyString_AS_STRING(v);
return PyDecType_FromCString(type, s, context);
}
/* Return a new PyDecObject or a subtype from a PyStringObject. Attempt exact
* conversion. If the conversion is not exact, fail with InvalidOperation.
* Allow leading and trailing whitespace in the input operand. */
static PyObject *
PyDecType_FromStringExactWS(PyTypeObject *type, const PyObject *v,
PyObject *context)
{
PyObject *dec;
char *s, *stripped;
s = PyString_AS_STRING(v);
stripped = strip_ws(s);
if (stripped == NULL) {
return NULL;
}
dec = PyDecType_FromCStringExact(type, stripped, context);
if (stripped != s) {
PyMem_Free(stripped);
}
return dec;
}
/* Return a new PyDecObject or a subtype from a PyUnicodeObject. */
static PyObject *
PyDecType_FromUnicode(PyTypeObject *type, const PyObject *u,
PyObject *context)
{
PyObject *dec;
char *s;
s = dec_unicode_as_str(u);
if (s == NULL) {
return NULL;
}
dec = PyDecType_FromCString(type, s, context);
PyMem_Free(s);
return dec;
}
/* Return a new PyDecObject or a subtype from a PyUnicodeObject. Attempt exact
* conversion. If the conversion is not exact, fail with InvalidOperation.
* Allow leading and trailing whitespace in the input operand. */
static PyObject *
PyDecType_FromUnicodeExactWS(PyTypeObject *type, const PyObject *u,
PyObject *context)
{
PyObject *dec;
char *s, *stripped;
s = dec_unicode_as_str(u);
if (s == NULL) {
return NULL;
}
stripped = strip_ws(s);
if (stripped == NULL) {
PyMem_Free(s);
return NULL;
}
dec = PyDecType_FromCStringExact(type, stripped, context);
if (stripped != s) {
PyMem_Free(stripped);
}
PyMem_Free(s);
return dec;
}
/* Set PyDecObject from triple without any error checking. */
static ALWAYS_INLINE void
_dec_settriple(PyObject *dec, uint8_t sign, uint32_t v, mpd_ssize_t exp)
{
#ifdef CONFIG_64
MPD(dec)->data[0] = v;
MPD(dec)->len = 1;
#else
uint32_t q, r;
q = v / MPD_RADIX;
r = v - q * MPD_RADIX;
MPD(dec)->data[1] = q;
MPD(dec)->data[0] = r;
MPD(dec)->len = q ? 2 : 1;
#endif
mpd_set_flags(MPD(dec), sign);
MPD(dec)->exp = exp;
mpd_setdigits(MPD(dec));
}
/* Return a new PyDecObject from an mpd_ssize_t. */
static PyObject *
PyDecType_FromSsize(PyTypeObject *type, mpd_ssize_t v, PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
dec = PyDecType_New(type);
if (dec == NULL) {
return NULL;
}
mpd_qset_ssize(MPD(dec), v, CTX(context), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
/* Return a new PyDecObject from an mpd_ssize_t. Conversion is exact. */
static PyObject *
PyDecType_FromSsizeExact(PyTypeObject *type, mpd_ssize_t v, PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
mpd_context_t maxctx;
dec = PyDecType_New(type);
if (dec == NULL) {
return NULL;
}
mpd_maxcontext(&maxctx);
mpd_qset_ssize(MPD(dec), v, &maxctx, &status);
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
/* Convert from a PyIntObject. The context is not modified; flags set
during conversion are accumulated in the status parameter. */
static PyObject *
PyDecType_FromInt(PyTypeObject *type, PyObject *pyint, PyObject *context)
{
mpd_ssize_t x;
x = _PyInt_AsMpdSsize(pyint);
if (PyErr_Occurred()) {
return NULL;
}
return PyDecType_FromSsize(type, x, context);
}
/* Return a new PyDecObject from a PyIntObject. Use a maximum context
for conversion. If the conversion is not exact, set InvalidOperation. */
static PyObject *
PyDecType_FromIntExact(PyTypeObject *type, PyObject *pyint,
PyObject *context)
{
mpd_ssize_t x;
x = _PyInt_AsMpdSsize(pyint);
if (PyErr_Occurred()) {
return NULL;
}
return PyDecType_FromSsizeExact(type, x, context);
}
/* Convert from a PyLongObject. The context is not modified; flags set
during conversion are accumulated in the status parameter. */
static PyObject *
dec_from_long(PyTypeObject *type, const PyObject *v,
const mpd_context_t *ctx, uint32_t *status)
{
PyObject *dec;
PyLongObject *l = (PyLongObject *)v;
Py_ssize_t ob_size;
size_t len;
uint8_t sign;
dec = PyDecType_New(type);
if (dec == NULL) {
return NULL;
}
ob_size = Py_SIZE(l);
if (ob_size == 0) {
_dec_settriple(dec, MPD_POS, 0, 0);
return dec;
}
if (ob_size < 0) {
len = -ob_size;
sign = MPD_NEG;
}
else {
len = ob_size;
sign = MPD_POS;
}
if (len == 1) {
_dec_settriple(dec, sign, *l->ob_digit, 0);
mpd_qfinalize(MPD(dec), ctx, status);
return dec;
}
#if PYLONG_BITS_IN_DIGIT == 30
mpd_qimport_u32(MPD(dec), l->ob_digit, len, sign, PyLong_BASE,
ctx, status);
#elif PYLONG_BITS_IN_DIGIT == 15
mpd_qimport_u16(MPD(dec), l->ob_digit, len, sign, PyLong_BASE,
ctx, status);
#else
#error "PYLONG_BITS_IN_DIGIT should be 15 or 30."
#endif
return dec;
}
/* Return a new PyDecObject from a PyLongObject. Use the context for
conversion. */
static PyObject *
PyDecType_FromLong(PyTypeObject *type, const PyObject *pylong,
PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
dec = dec_from_long(type, pylong, CTX(context), &status);
if (dec == NULL) {
return NULL;
}
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
/* Return a new PyDecObject from a PyLongObject. Use a maximum context
for conversion. If the conversion is not exact, set InvalidOperation. */
static PyObject *
PyDecType_FromLongExact(PyTypeObject *type, const PyObject *pylong,
PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
mpd_context_t maxctx;
mpd_maxcontext(&maxctx);
dec = dec_from_long(type, pylong, &maxctx, &status);
if (dec == NULL) {
return NULL;
}
if (status & (MPD_Inexact|MPD_Rounded)) {
/* we want exact results */
mpd_seterror(MPD(dec), MPD_Invalid_operation, &status); /* GCOV_NOT_REACHED */
}
status &= MPD_Errors;
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
#if PY_VERSION_HEX >= 0x02060000
/* Return a PyDecObject or a subtype from a PyFloatObject.
Conversion is exact. */
static PyObject *
PyDecType_FromFloatExact(PyTypeObject *type, PyObject *v,
PyObject *context)
{
PyObject *dec, *tmp;
PyObject *n, *d, *n_d;
Py_ssize_t k;
double x;
int sign;
mpd_t *d1, *d2;
uint32_t status = 0;
mpd_context_t maxctx;
assert(PyType_IsSubtype(type, &PyDec_Type));
if (PyInt_Check(v)) {
return PyDecType_FromIntExact(type, v, context);
}
if (PyLong_Check(v)) {
return PyDecType_FromLongExact(type, v, context);
}
if (!PyFloat_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"argument must be int of float.");
return NULL;
}
x = PyFloat_AsDouble(v);
if (x == -1.0 && PyErr_Occurred()) {
return NULL;
}
sign = (copysign(1.0, x) == 1.0) ? 0 : 1;
if (Py_IS_NAN(x) || Py_IS_INFINITY(x)) {
dec = PyDecType_New(type);
if (dec == NULL) {
return NULL;
}
if (Py_IS_NAN(x)) {
/* decimal.py calls repr(float(+-nan)),
* which always gives a positive result. */
mpd_setspecial(MPD(dec), MPD_POS, MPD_NAN);
}
else {
mpd_setspecial(MPD(dec), sign, MPD_INF);
}
return dec;
}
/* absolute value of the float */
tmp = PyObject_CallMethod(v, "__abs__", NULL);
if (tmp == NULL) {
return NULL;
}
/* float as integer ratio: numerator/denominator */
n_d = PyObject_CallMethod(tmp, "as_integer_ratio", NULL);
Py_DECREF(tmp);
if (n_d == NULL) {
return NULL;
}
n = PyTuple_GET_ITEM(n_d, 0);
d = PyTuple_GET_ITEM(n_d, 1);
/* slow but portable bit_length() */
if (PyInt_Check(d)) {
if ((tmp = _PyInt_Format((PyIntObject *)d, 2, 0)) == NULL) {
Py_DECREF(n_d);
return NULL;
}
}
else {
if ((tmp = _PyLong_Format(d, 2, 0, 0)) == NULL) {
Py_DECREF(n_d);
return NULL;
}
}
k = (PyString_Size(tmp)-2) - 1;
Py_DECREF(tmp);
if (PyInt_Check(n)) {
dec = PyDecType_FromIntExact(type, n, context);
}
else {
dec = PyDecType_FromLongExact(type, n, context);
}
Py_DECREF(n_d);
if (dec == NULL) {
return NULL;
}
d1 = mpd_qnew();
if (d1 == NULL) {
Py_DECREF(dec);
PyErr_NoMemory();
return NULL;
}
d2 = mpd_qnew();
if (d2 == NULL) {
mpd_del(d1);
Py_DECREF(dec);
PyErr_NoMemory();
return NULL;
}
mpd_maxcontext(&maxctx);
mpd_qset_uint(d1, 5, &maxctx, &status);
mpd_qset_ssize(d2, k, &maxctx, &status);
mpd_qpow(d1, d1, d2, &maxctx, &status);
if (dec_addstatus(context, status)) {
mpd_del(d1); /* GCOV_NOT_REACHED */
mpd_del(d2); /* GCOV_NOT_REACHED */
Py_DECREF(dec); /* GCOV_NOT_REACHED */
return NULL; /* GCOV_NOT_REACHED */
}
/* result = n * 5**k */
mpd_qmul(MPD(dec), MPD(dec), d1, &maxctx, &status);
mpd_del(d1);
mpd_del(d2);
if (dec_addstatus(context, status)) {
Py_DECREF(dec); /* GCOV_NOT_REACHED */
return NULL; /* GCOV_NOT_REACHED */
}
/* result = +- n * 5**k * 10**-k */
mpd_set_sign(MPD(dec), sign);
MPD(dec)->exp = -k;
return dec;
}
static PyObject *
PyDecType_FromFloat(PyTypeObject *type, PyObject *v,
PyObject *context)
{
PyObject *dec;
uint32_t status = 0;
dec = PyDecType_FromFloatExact(type, v, context);
if (dec == NULL) {
return NULL;
}
mpd_qfinalize(MPD(dec), CTX(context), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(dec);
return NULL;
}
return dec;
}
#else
static PyObject *
PyDecType_FromFloat(PyTypeObject *type, PyObject *v,
PyObject *context)
{
PyErr_SetString(PyExc_NotImplementedError, "upgrade to Python 2.6");
return NULL;
}
static PyObject *
PyDecType_FromFloatExact(PyTypeObject *type, PyObject *v,
PyObject *context)
{
PyErr_SetString(PyExc_NotImplementedError, "upgrade to Python 2.6");
return NULL;
}
#endif
/* Return a new C string representation of a DecimalTuple. */
static char *
dectuple_as_str(PyObject *dectuple)
{
PyObject *digits, *tmp;
char *decstring = NULL;
char sign_special[6];
char *cp;
long sign, l;
mpd_ssize_t exp = 0;
Py_ssize_t i, mem, tsize;
int n;
assert(PyTuple_Check(dectuple));
if (PyTuple_Size(dectuple) != 3) {
PyErr_SetString(PyExc_ValueError,
"argument must be a sequence of length 3.");
goto error;
}
/* sign */
tmp = PyTuple_GET_ITEM(dectuple, 0);
if (!PyInt_Check(tmp) && !PyLong_Check(tmp)) {
PyErr_SetString(PyExc_ValueError,
"sign must be an integer with the value 0 or 1.");
goto error;
}
sign = PyLong_AsLong(tmp);
if (PyErr_Occurred()) {
goto error;
}
if (sign != 0 && sign != 1) {
PyErr_SetString(PyExc_ValueError,
"sign must be an integer with the value 0 or 1.");
goto error;
}
sign_special[0] = sign ? '-' : '+';
sign_special[1] = '\0';
/* exponent or encoding for a special number */
tmp = PyTuple_GET_ITEM(dectuple, 2);
if (PyString_Check(tmp)) {
/* special */
if (strcmp(PyString_AS_STRING(tmp), "F") == 0) {
strcat(sign_special, "Inf");
}
else if (strcmp(PyString_AS_STRING(tmp), "n") == 0) {
strcat(sign_special, "NaN");
}
else if (strcmp(PyString_AS_STRING(tmp), "N") == 0) {
strcat(sign_special, "sNaN");
}
else {
PyErr_SetString(PyExc_ValueError,
"string argument in the third position "
"must be 'F', 'n' or 'N'.");
goto error;
}
}
else {
/* exponent */
if (!PyInt_Check(tmp) && !PyLong_Check(tmp)) {
PyErr_SetString(PyExc_ValueError,
"exponent must be an integer.");
goto error;
}
exp = long_as_mpd_ssize(tmp);
if (PyErr_Occurred()) {
goto error;
}
}
/* coefficient */
digits = PyTuple_GET_ITEM(dectuple, 1);
if (!PyTuple_Check(digits)) {
PyErr_SetString(PyExc_ValueError,
"coefficient must be a tuple of digits.");
goto error;
}
tsize = PyTuple_Size(digits);
/* [sign][coeffdigits+1][E][-][expdigits+1]['\0'] */
mem = 1 + tsize + 3 + MPD_EXPDIGITS + 2;
cp = decstring = PyMem_Malloc(mem);
if (decstring == NULL) {
PyErr_NoMemory();
goto error;
}
n = snprintf(cp, mem, "%s", sign_special);
if (n < 0 || n >= mem) {
PyErr_SetString(PyExc_RuntimeError,
"internal error in dec_sequence_as_str.");
goto error;
}
cp += n;
if (tsize == 0 && sign_special[1] == '\0') {
/* empty tuple: zero coefficient, except for special numbers */
*cp++ = '0';
}
for (i = 0; i < tsize; i++) {
tmp = PyTuple_GET_ITEM(digits, i);
if (!PyInt_Check(tmp) && !PyLong_Check(tmp)) {
PyErr_SetString(PyExc_ValueError,
"coefficient must be a tuple of digits.");
goto error;
}
l = PyLong_AsLong(tmp);
if (PyErr_Occurred()) {
goto error;
}
if (l < 0 || l > 9) {
PyErr_SetString(PyExc_ValueError,
"coefficient must be a tuple of digits.");
goto error;
}
*cp++ = (char)l + '0';
}
*cp = '\0';
if (sign_special[1] == '\0') {
/* not a special number */
*cp++ = 'E';
n = snprintf(cp, MPD_EXPDIGITS+1, "%" PRI_mpd_ssize_t, exp);
if (n < 0 || n >= MPD_EXPDIGITS+1) {
PyErr_SetString(PyExc_RuntimeError,
"internal error in dec_sequence_as_str.");
goto error;
}
}
return decstring;
error:
if (decstring) PyMem_Free(decstring);
return NULL;
}
static PyObject *
sequence_as_tuple(PyObject *v)
{
if (PyTuple_Check(v)) {
Py_INCREF(v);
return v;
}
if (PyList_Check(v)) {
return PyList_AsTuple(v);
}
return type_error_ptr("argument must be tuple or list."); /* GCOV_NOT_REACHED */
}
/* Currently accepts tuples and lists. */
static PyObject *
PyDecType_FromSequence(PyTypeObject *type, PyObject *v,
PyObject *context)
{
PyObject *dectuple;
PyObject *dec;
char *s;
dectuple = sequence_as_tuple(v);
if (dectuple == NULL) {
return NULL;
}
s = dectuple_as_str(dectuple);
Py_DECREF(dectuple);
if (s == NULL) {
return NULL;
}
dec = PyDecType_FromCString(type, s, context);
PyMem_Free(s);
return dec;
}
/* Currently accepts tuples and lists. */
static PyObject *
PyDecType_FromSequenceExact(PyTypeObject *type, PyObject *v,
PyObject *context)
{
PyObject *dectuple;
PyObject *dec;
char *s;
dectuple = sequence_as_tuple(v);
if (dectuple == NULL) {
return NULL;
}
s = dectuple_as_str(dectuple);
Py_DECREF(dectuple);
if (s == NULL) {
return NULL;
}
dec = PyDecType_FromCStringExact(type, s, context);
PyMem_Free(s);
return dec;
}
#define PyDec_FromCString(str, context) \
PyDecType_FromCString(&PyDec_Type, str, context)
#define PyDec_FromCStringExact(str, context) \
PyDecType_FromCStringExact(&PyDec_Type, str, context)
#define PyDec_FromString(str, context) \
PyDecType_FromString(&PyDec_Type, str, context)
#define PyDec_FromStringExact(str, context) \
PyDecType_FromStringExact(&PyDec_Type, str, context)
#define PyDec_FromStringExactWS(str, context) \
PyDecType_FromStringExactWS(&PyDec_Type, str, context)
#define PyDec_FromUnicode(unicode, context) \
PyDecType_FromUnicode(&PyDec_Type, unicode, context)
#define PyDec_FromUnicodeExact(unicode, context) \
PyDecType_FromUnicodeExact(&PyDec_Type, unicode, context)
#define PyDec_FromUnicodeExactWS(unicode, context) \
PyDecType_FromUnicodeExactWS(&PyDec_Type, unicode, context)
#define PyDec_FromSsize(v, context) \
PyDecType_FromSsize(&PyDec_Type, v, context)
#define PyDec_FromSsizeExact(v, context) \
PyDecType_FromSsizeExact(&PyDec_Type, v, context)
#define PyDec_FromInt(pyint, context) \
PyDecType_FromInt(&PyDec_Type, pyint, context)
#define PyDec_FromIntExact(pyint, context) \
PyDecType_FromIntExact(&PyDec_Type, pyint, context)
#define PyDec_FromLong(pylong, context) \
PyDecType_FromLong(&PyDec_Type, pylong, context)
#define PyDec_FromLongExact(pylong, context) \
PyDecType_FromLongExact(&PyDec_Type, pylong, context)
#define PyDec_FromFloat(pyfloat, context) \
PyDecType_FromFloat(&PyDec_Type, pyfloat, context)
#define PyDec_FromFloatExact(pyfloat, context) \
PyDecType_FromFloatExact(&PyDec_Type, pyfloat, context)
#define PyDec_FromSequence(sequence, context) \
PyDecType_FromSequence(&PyDec_Type, sequence, context)
#define PyDec_FromSequenceExact(sequence, context) \
PyDecType_FromSequenceExact(&PyDec_Type, sequence, context)
/* class method */
static PyObject *
dec_from_float(PyObject *dec, PyObject *pyfloat)
{
PyObject *context;
CURRENT_CONTEXT(context);
return PyDecType_FromFloatExact((PyTypeObject *)dec, pyfloat, context);
}
/* create_decimal_from_float */
static PyObject *
ctx_from_float(PyObject *context, PyObject *v)
{
return PyDec_FromFloat(v, context);
}
/* Apply the context to the input operand. Return a new PyDecObject. */
static PyObject *
dec_apply(PyObject *v, PyObject *context)
{
PyObject *result;
uint32_t status = 0;
result = dec_alloc();
if (result == NULL) {
return NULL;
}
mpd_qcopy(MPD(result), MPD(v), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
mpd_qfinalize(MPD(result), CTX(context), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
/* 'v' can have any type accepted by the Decimal constructor. Attempt
an exact conversion. If the result does not meet the restrictions
for an mpd_t, fail with InvalidOperation. */
static PyObject *
PyDecType_FromObjectExact(PyTypeObject *type, PyObject *v, PyObject *context)
{
if (v == NULL) {
return PyDecType_FromSsizeExact(type, 0, context);
}
else if (PyDec_Check(v)) {
Py_INCREF(v);
return v;
}
else if (PyString_Check(v)) {
return PyDecType_FromStringExactWS(type, v, context);
}
else if (PyUnicode_Check(v)) {
return PyDecType_FromUnicodeExactWS(type, v, context);
}
else if (PyInt_Check(v)) {
return PyDecType_FromIntExact(type, v, context);
}
else if (PyLong_Check(v)) {
return PyDecType_FromLongExact(type, v, context);
}
else if (PyTuple_Check(v) || PyList_Check(v)) {
return PyDecType_FromSequenceExact(type, v, context);
}
#if PY_VERSION_HEX >= 0x02070000
else if (PyFloat_Check(v)) {
if (dec_addstatus(context, MPD_Float_operation)) {
return NULL;
}
return PyDecType_FromFloatExact(type, v, context);
}
#endif
else {
PyErr_Format(PyExc_TypeError,
"conversion from %s to Decimal is not supported.",
v->ob_type->tp_name);
return NULL;
}
}
/* The context is used during conversion. This function is the
equivalent of context.create_decimal(). */
static PyObject *
PyDec_FromObject(PyObject *v, PyObject *context)
{
if (v == NULL) {
return PyDec_FromSsize(0, context);
}
else if (PyDec_Check(v)) {
mpd_context_t *ctx = CTX(context);
if (mpd_isnan(MPD(v)) &&
MPD(v)->digits > ctx->prec - ctx->clamp) {
/* Special case: too many NaN payload digits */
PyObject *result;
if (dec_addstatus(context, MPD_Conversion_syntax)) {
return NULL;
}
result = dec_alloc();
if (result == NULL) {
return NULL;
}
mpd_setspecial(MPD(result), MPD_POS, MPD_NAN);
return result;
}
return dec_apply(v, context);
}
else if (PyString_Check(v)) {
return PyDec_FromString(v, context);
}
else if (PyUnicode_Check(v)) {
return PyDec_FromUnicode(v, context);
}
else if (PyInt_Check(v)) {
return PyDec_FromInt(v, context);
}
else if (PyLong_Check(v)) {
return PyDec_FromLong(v, context);
}
else if (PyTuple_Check(v) || PyList_Check(v)) {
return PyDec_FromSequence(v, context);
}
#if PY_VERSION_HEX >= 0x02070000
else if (PyFloat_Check(v)) {
if (dec_addstatus(context, MPD_Float_operation)) {
return NULL;
}
return PyDec_FromFloat(v, context);
}
#endif
else {
PyErr_Format(PyExc_TypeError,
"conversion from %s to Decimal is not supported.",
v->ob_type->tp_name);
return NULL;
}
}
static PyObject *
dec_new(PyTypeObject *type, PyObject *args, PyObject *kwds UNUSED)
{
PyObject *v = NULL;
PyObject *context;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "|OO", &v, &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
return PyDecType_FromObjectExact(type, v, context);
}
static PyObject *
ctx_create_decimal(PyObject *context, PyObject *args)
{
PyObject *v = NULL;
if (!PyArg_ParseTuple(args, "|O", &v)) {
return NULL;
}
return PyDec_FromObject(v, context);
}
/******************************************************************************/
/* Implicit conversions to Decimal */
/******************************************************************************/
/* Try to convert PyObject v to a new PyDecObject conv. If the conversion
fails, set conv to NULL (exception is set). If the conversion is not
implemented, set conv to Py_NotImplemented. */
#define NOT_IMPL 0
#define TYPE_ERR 1
static inline int
convert_op(int type_err, PyObject **conv, PyObject *v, PyObject *context)
{
if (PyDec_Check(v)) {
*conv = v;
Py_INCREF(v);
return 1;
}
if (PyInt_Check(v)) {
*conv = PyDec_FromIntExact(v, context);
if (*conv == NULL) {
return 0;
}
return 1;
}
if (PyLong_Check(v)) {
*conv = PyDec_FromLongExact(v, context);
if (*conv == NULL) {
return 0;
}
return 1;
}
if (type_err) {
PyErr_Format(PyExc_TypeError,
"conversion from %s to Decimal is not supported.",
v->ob_type->tp_name);
}
else {
Py_INCREF(Py_NotImplemented);
*conv = Py_NotImplemented;
}
return 0;
}
/* Return NotImplemented for unsupported types. */
#define CONVERT_OP(a, v, context) \
if (!convert_op(NOT_IMPL, a, v, context)) { \
return *(a); \
}
#define CONVERT_BINOP(a, b, v, w, context) \
if (!convert_op(NOT_IMPL, a, v, context)) { \
return *(a); \
} \
if (!convert_op(NOT_IMPL, b, w, context)) { \
Py_DECREF(*(a)); \
return *(b); \
}
#define CONVERT_TERNOP(a, b, c, v, w, x, context) \
if (!convert_op(NOT_IMPL, a, v, context)) { \
return *(a); \
} \
if (!convert_op(NOT_IMPL, b, w, context)) { \
Py_DECREF(*(a)); \
return *(b); \
} \
if (!convert_op(NOT_IMPL, c, x, context)) { \
Py_DECREF(*(a)); \
Py_DECREF(*(b)); \
return *(c); \
}
/* Raise TypeError for unsupported types. */
#define CONVERT_OP_RAISE(a, v, context) \
if (!convert_op(TYPE_ERR, a, v, context)) { \
return NULL; \
}
#define CONVERT_BINOP_RAISE(a, b, v, w, context) \
if (!convert_op(TYPE_ERR, a, v, context)) { \
return NULL; \
} \
if (!convert_op(TYPE_ERR, b, w, context)) { \
Py_DECREF(*(a)); \
return NULL; \
}
#define CONVERT_TERNOP_RAISE(a, b, c, v, w, x, context) \
if (!convert_op(TYPE_ERR, a, v, context)) { \
return NULL; \
} \
if (!convert_op(TYPE_ERR, b, w, context)) { \
Py_DECREF(*(a)); \
return NULL; \
} \
if (!convert_op(TYPE_ERR, c, x, context)) { \
Py_DECREF(*(a)); \
Py_DECREF(*(b)); \
return NULL; \
}
/******************************************************************************/
/* Implicit conversions to Decimal for comparison */
/******************************************************************************/
#if PY_VERSION_HEX >= 0x02080000
/* Convert rationals for comparison */
static PyObject *_Rational = NULL;
static PyObject *
multiply_by_denominator(PyObject *v, PyObject *r, PyObject *context)
{
PyObject *result;
PyObject *tmp = NULL;
PyObject *denom = NULL;
uint32_t status = 0;
mpd_context_t maxctx;
mpd_ssize_t exp;
mpd_t *vv;
/* v is not special, r is a rational */
tmp = PyObject_GetAttrString(r, "denominator");
if (tmp == NULL) {
return NULL;
}
denom = PyDec_FromLongExact(tmp, context);
Py_DECREF(tmp);
if (denom == NULL) {
return NULL;
}
vv = mpd_qncopy(MPD(v));
if (vv == NULL) {
Py_DECREF(denom);
PyErr_NoMemory();
return NULL;
}
result = dec_alloc();
if (result == NULL) {
Py_DECREF(denom);
mpd_del(vv);
return NULL;
}
mpd_maxcontext(&maxctx);
/* Prevent Overflow in the following multiplication. The result of
the multiplication is only used in mpd_qcmp, which can handle
values that are technically out of bounds, like (for 32-bit)
99999999999999999999...99999999e+425000000. */
exp = vv->exp;
vv->exp = 0;
mpd_qmul(MPD(result), vv, MPD(denom), &maxctx, &status);
MPD(result)->exp = exp;
Py_DECREF(denom);
mpd_del(vv);
/* If any status has been accumulated during the multiplication,
the result is invalid. This is very unlikely, since even the
32-bit version supports 425000000 digits. */
if (status) {
PyErr_SetString(PyExc_ValueError, /* GCOV_NOT_REACHED */
"exact conversion for comparison failed."); /* GCOV_NOT_REACHED */
Py_DECREF(result); /* GCOV_NOT_REACHED */
return NULL; /* GCOV_NOT_REACHED */
}
return result;
}
static PyObject *
numerator_as_decimal(PyObject *r, PyObject *context)
{
PyObject *tmp, *num;
tmp = PyObject_GetAttrString(r, "numerator");
if (tmp == NULL) {
return NULL;
}
num = PyDec_FromLongExact(tmp, context);
Py_DECREF(tmp);
return num;
}
#endif
/* Convert v and w for comparison. v is a Decimal. If w is a Rational, both
v and w have to be transformed. Return 1 for success, with new references
to the converted objects in vcmp and wcmp. Return 0 for failure. In that
case wcmp is either NULL or Py_NotImplemented (new reference) and vcmp
is undefined. */
static int
convert_op_cmp(PyObject **vcmp, PyObject **wcmp, PyObject *v, PyObject *w,
int op, PyObject *context)
{
mpd_context_t *ctx = CTX(context);
*vcmp = v;
if (PyDec_Check(w)) {
Py_INCREF(w);
*wcmp = w;
}
else if (PyInt_Check(w)) {
*wcmp = PyDec_FromIntExact(w, context);
}
else if (PyLong_Check(w)) {
*wcmp = PyDec_FromLongExact(w, context);
}
else if (PyFloat_Check(w)) {
if (op != Py_EQ && op != Py_NE &&
dec_addstatus(context, MPD_Float_operation)) {
*wcmp = NULL;
}
else {
ctx->status |= MPD_Float_operation;
#if PY_VERSION_HEX >= 0x02070000
*wcmp = PyDec_FromFloatExact(w, context);
#else
Py_INCREF(Py_NotImplemented);
*wcmp = Py_NotImplemented;
#endif
}
}
#if PY_VERSION_HEX >= 0x02080000
else if (PyComplex_Check(w) && (op == Py_EQ || op == Py_NE)) {
Py_complex c = PyComplex_AsCComplex(w);
if (PyErr_Occurred()) {
*wcmp = NULL;
}
else if (c.imag == 0.0) {
PyObject *tmp = PyFloat_FromDouble(c.real);
if (tmp == NULL) {
*wcmp = NULL;
}
else {
ctx->status |= MPD_Float_operation;
*wcmp = PyDec_FromFloatExact(tmp, context);
Py_DECREF(tmp);
}
}
else {
Py_INCREF(Py_NotImplemented);
*wcmp = Py_NotImplemented;
}
}
else if (PyObject_IsInstance(w, _Rational)) {
*wcmp = numerator_as_decimal(w, context);
if (*wcmp && !mpd_isspecial(MPD(v))) {
*vcmp = multiply_by_denominator(v, w, context);
if (*vcmp == NULL) {
Py_CLEAR(*wcmp);
}
}
}
#endif
else {
Py_INCREF(Py_NotImplemented);
*wcmp = Py_NotImplemented;
}
if (*wcmp == NULL || *wcmp == Py_NotImplemented) {
return 0;
}
if (*vcmp == v) {
Py_INCREF(v);
}
return 1;
}
#define CONVERT_BINOP_CMP(vcmp, wcmp, v, w, op, ctx) \
if (!convert_op_cmp(vcmp, wcmp, v, w, op, ctx)) { \
return *(wcmp); \
} \
/******************************************************************************/
/* Conversions from decimal */
/******************************************************************************/
/* PyDecObject as a string. The default module context is only used for
the value of 'capitals'. */
static PyObject *
dec_str(PyObject *dec)
{
PyObject *s, *c;
char *res;
CURRENT_CONTEXT(c);
res = mpd_to_sci(MPD(dec), CtxCaps(c));
if (res == NULL) {
PyErr_NoMemory();
return NULL;
}
s = PyString_FromString(res);
mpd_free(res);
return s;
}
static const char *dtag = "Decimal('";
static const size_t dtaglen = 9; /* without NUL terminator */
/* Representation of a PyDecObject. */
static PyObject *
dec_repr(PyObject *dec)
{
PyObject *s, *c;
uint8_t err;
char *cp;
size_t declen;
CURRENT_CONTEXT(c);
cp = mpd_to_sci(MPD(dec), CtxCaps(c));
if (cp == NULL) {
PyErr_NoMemory();
return NULL;
}
declen = strlen(cp);
err = 0;
cp = mpd_realloc(cp, (mpd_size_t)(declen+dtaglen+3), sizeof *cp, &err);
if (err) {
mpd_free(cp);
PyErr_NoMemory();
return NULL;
}
memmove(cp+dtaglen, cp, declen);
memcpy(cp, dtag, dtaglen);
cp[declen+dtaglen] = '\'';
cp[declen+dtaglen+1] = ')';
cp[declen+dtaglen+2] = '\0';
s = PyString_FromString(cp);
mpd_free(cp);
return s;
}
#if PY_VERSION_HEX >= 0x02060000
/* Formatted representation of a PyDecObject. */
static PyObject *
dec_format(PyObject *dec, PyObject *args)
{
PyObject *result = NULL;
PyObject *override = NULL;
PyObject *dot = NULL;
PyObject *sep = NULL;
PyObject *grouping = NULL;
PyObject *fmt = NULL;
PyObject *fmtarg;
PyObject *context;
mpd_spec_t spec;
char *decstring= NULL;
uint32_t status = 0;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "O|O", &fmtarg, &override)) {
return NULL;
}
if (PyString_Check(fmtarg)) {
fmt = fmtarg;
}
else if (PyUnicode_Check(fmtarg)) {
if ((fmt = PyUnicode_AsUTF8String(fmtarg)) == NULL) {
return NULL;
}
}
else {
PyErr_SetString(PyExc_TypeError,
"format arg must be str or unicode.");
return NULL;
}
if (!mpd_parse_fmt_str(&spec, PyBytes_AS_STRING(fmt),
CtxCaps(context))) {
PyErr_SetString(PyExc_ValueError,
"invalid format string.");
goto finish;
}
if (override) {
if (!PyDict_Check(override)) {
PyErr_SetString(PyExc_TypeError,
"optional argument must be a dict.");
goto finish;
}
if ((dot = PyDict_GetItemString(override, "decimal_point"))) {
if ((dot = PyUnicode_AsUTF8String(dot)) == NULL) {
goto finish;
}
spec.dot = PyBytes_AS_STRING(dot);
}
if ((sep = PyDict_GetItemString(override, "thousands_sep"))) {
if ((sep = PyUnicode_AsUTF8String(sep)) == NULL) {
goto finish;
}
spec.sep = PyBytes_AS_STRING(sep);
}
if ((grouping = PyDict_GetItemString(override, "grouping"))) {
if ((grouping = PyUnicode_AsUTF8String(grouping)) == NULL) {
goto finish;
}
spec.grouping = PyBytes_AS_STRING(grouping);
}
}
decstring = mpd_qformat_spec(MPD(dec), &spec, CTX(context), &status);
if (decstring == NULL) {
dec_addstatus(context, status);
goto finish;
}
result = Py_BuildValue("s", decstring);
finish:
Py_XDECREF(grouping);
Py_XDECREF(sep);
Py_XDECREF(dot);
if (fmt != fmtarg) { Py_XDECREF(fmt); }
if (decstring) mpd_free(decstring);
return result;
}
#endif
/* Return a PyLongObject from a PyDecObject, using the specified rounding
* mode. The context precision is not observed. If tryint is true and
* abs(result) is sufficiently small, a PyIntObject is returned. */
static PyObject *
_dec_as_integral(int tryint, PyObject *dec, PyObject *context, int round)
{
PyLongObject *pylong;
size_t maxsize, n;
Py_ssize_t i;
mpd_t *x;
mpd_context_t workctx;
uint32_t status = 0;
if (mpd_isspecial(MPD(dec))) {
if (mpd_isnan(MPD(dec))) {
PyErr_SetString(PyExc_ValueError,
"cannot convert NaN to integer.");
}
else {
PyErr_SetString(PyExc_OverflowError,
"cannot convert Infinity to integer.");
}
return NULL;
}
if ((x = mpd_qnew()) == NULL) {
PyErr_NoMemory();
return NULL;
}
workctx = *CTX(context);
workctx.round = round;
mpd_qround_to_int(x, MPD(dec), &workctx, &status);
if (dec_addstatus(context, status)) {
mpd_del(x);
return NULL;
}
if (tryint) {
mpd_ssize_t l;
status = 0;
l = mpd_qget_ssize(x, &status);
if (!(status&MPD_Invalid_operation)) {
mpd_del(x);
return _PyInt_FromMpdSsize(l);
}
}
maxsize = mpd_sizeinbase(x, PyLong_BASE);
if (maxsize > PY_SSIZE_T_MAX) {
mpd_del(x);
PyErr_NoMemory();
return NULL;
}
if ((pylong = _PyLong_New(maxsize)) == NULL) {
mpd_del(x);
return NULL;
}
status = 0;
#if PYLONG_BITS_IN_DIGIT == 30
n = mpd_qexport_u32(pylong->ob_digit, maxsize, PyLong_BASE, x, &status);
#elif PYLONG_BITS_IN_DIGIT == 15
n = mpd_qexport_u16(pylong->ob_digit, maxsize, PyLong_BASE, x, &status);
#else
#error "PYLONG_BITS_IN_DIGIT should be 15 or 30."
#endif
if (dec_addstatus(context, status)) {
Py_DECREF((PyObject *) pylong);
mpd_del(x);
return NULL;
}
i = n;
while ((i > 0) && (pylong->ob_digit[i-1] == 0)) {
i--;
}
Py_SIZE(pylong) = i;
if (mpd_isnegative(x) && !mpd_iszero(x)) {
Py_SIZE(pylong) = -i;
}
mpd_del(x);
return (PyObject *) pylong;
}
static PyObject *
PyDec_ToIntegralValue(PyObject *dec, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"rounding", "context", NULL};
PyObject *result;
PyObject *context;
uint32_t status = 0;
mpd_context_t workctx;
int round = -1;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
&round, &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
workctx = *CTX(context);
if (round >= 0) {
if (!mpd_qsetround(&workctx, round)) {
return type_error_ptr(invalid_rounding_err);
}
}
if ((result = dec_alloc()) == NULL) {
return NULL;
}
mpd_qround_to_int(MPD(result), MPD(dec), &workctx, &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
static PyObject *
PyDec_ToIntegralExact(PyObject *dec, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"rounding", "context", NULL};
PyObject *result;
PyObject *context;
uint32_t status = 0;
mpd_context_t workctx;
int round = -1;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iO", kwlist,
&round, &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
workctx = *CTX(context);
if (round >= 0) {
if (!mpd_qsetround(&workctx, round)) {
return type_error_ptr(invalid_rounding_err);
}
}
if ((result = dec_alloc()) == NULL) {
return NULL;
}
mpd_qround_to_intx(MPD(result), MPD(dec), &workctx, &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
static PyObject *
PyDec_AsFloat(PyObject *dec)
{
PyObject *f, *s;
if ((s = dec_str(dec)) == NULL) {
return NULL;
}
f = PyFloat_FromString(s, NULL);
Py_DECREF(s);
return f;
}
static PyObject *
PyDec_Round(PyObject *dec, PyObject *args)
{
PyObject *result;
PyObject *x = NULL;
uint32_t status = 0;
PyObject *context;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "|O", &x)) {
return NULL;
}
if (x) {
mpd_uint_t dq[1] = {1};
mpd_t q = {MPD_STATIC|MPD_CONST_DATA,0,1,1,1,dq};
mpd_ssize_t y;
if (!PyInt_Check(x) && !PyLong_Check(x)) {
return type_error_ptr(
"optional arg must be an integer");
}
y = long_as_mpd_ssize(x);
if (PyErr_Occurred()) {
return NULL;
}
if ((result = dec_alloc()) == NULL) {
return NULL;
}
q.exp = (y == MPD_SSIZE_MIN) ? MPD_SSIZE_MAX : -y;
mpd_qquantize(MPD(result), MPD(dec), &q, CTX(context), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
else {
return _dec_as_integral(1, dec, context, MPD_ROUND_HALF_EVEN);
}
}
#if PY_VERSION_HEX >= 0x02060000
PyObject *DecimalTuple = NULL;
#endif
/* Return the DecimalTuple representation of a PyDecObject. */
static PyObject *
PyDec_AsTuple(PyObject *dec, PyObject *dummy UNUSED)
{
PyObject *result = NULL;
PyObject *sign = NULL;
PyObject *coeff = NULL;
PyObject *expt = NULL;
PyObject *tmp = NULL;
mpd_t *x = NULL;
char *intstring = NULL;
Py_ssize_t intlen, i;
if ((x = mpd_qncopy(MPD(dec))) == NULL) {
PyErr_NoMemory();
goto out;
}
sign = Py_BuildValue("i", mpd_sign(MPD(dec)));
if (sign == NULL) goto out;
if (mpd_isinfinite(x)) {
if ((expt = Py_BuildValue("s", "F")) == NULL) {
goto out;
}
/* decimal.py has non-compliant infinity payloads. */
if ((coeff = Py_BuildValue("(i)", 0)) == NULL) {
goto out;
}
}
else {
if (mpd_isnan(x)) {
expt = Py_BuildValue("s", mpd_isqnan(x)?"n":"N");
}
else {
expt = Py_BuildValue(CONV_mpd_ssize_t, MPD(dec)->exp);
}
if (expt == NULL) goto out;
/* coefficient is defined */
if (x->len > 0) {
/* make an integer */
x->exp = 0;
/* clear NaN and sign */
mpd_clear_flags(x);
intstring = mpd_to_sci(x, 1);
if (intstring == NULL) {
PyErr_NoMemory();
goto out;
}
intlen = strlen(intstring);
if ((coeff = PyTuple_New(intlen)) == NULL) {
goto out;
}
for (i = 0; i < intlen; i++) {
tmp = Py_BuildValue("i", intstring[i]-'0');
if (tmp == NULL) goto out;
PyTuple_SET_ITEM(coeff, i, tmp);
}
}
else {
if ((coeff = PyTuple_New(0)) == NULL) {
goto out;
}
}
}
#if PY_VERSION_HEX >= 0x02060000
result = PyObject_CallFunctionObjArgs(DecimalTuple,
sign, coeff, expt, NULL);
#else
result = Py_BuildValue("(OOO)", sign, coeff, expt);
#endif
out:
if (x) mpd_del(x);
if (intstring) mpd_free(intstring);
Py_XDECREF(sign);
Py_XDECREF(coeff);
Py_XDECREF(expt);
return result;
}
/******************************************************************************/
/* Macros for converting mpdecimal functions to Decimal methods */
/******************************************************************************/
/* Unary number method that uses the default module context. */
#define Dec_UnaryNumberMethod(MPDFUNC) \
static PyObject * \
nm_##MPDFUNC(PyObject *self) \
{ \
PyObject *result; \
PyObject *context; \
uint32_t status = 0; \
\
CURRENT_CONTEXT(context); \
if ((result = dec_alloc()) == NULL) { \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(self), CTX(context), &status); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/* Binary number method that uses default module context. */
#define Dec_BinaryNumberMethod(MPDFUNC) \
static PyObject * \
nm_##MPDFUNC(PyObject *v, PyObject *w) \
{ \
PyObject *a, *b; \
PyObject *result; \
PyObject *context; \
uint32_t status = 0; \
\
CURRENT_CONTEXT(context) ; \
CONVERT_BINOP(&a, &b, v, w, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b), CTX(context), &status); \
Py_DECREF(a); \
Py_DECREF(b); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/* Boolean function without a context arg. */
#define Dec_BoolFunc(MPDFUNC) \
static PyObject * \
dec_##MPDFUNC(PyObject *self, PyObject *dummy UNUSED) \
{ \
return MPDFUNC(MPD(self)) ? Dec_INCREF_TRUE : Dec_INCREF_FALSE; \
}
/* Boolean function with an optional context arg. */
#define Dec_BoolFuncVA(MPDFUNC) \
static PyObject * \
dec_##MPDFUNC(PyObject *self, PyObject *args) \
{ \
PyObject *context; \
\
CURRENT_CONTEXT(context); \
if (!PyArg_ParseTuple(args, "|O", &context)) { \
return NULL; \
} \
CONTEXT_CHECK_VA(context); \
\
return MPDFUNC(MPD(self), CTX(context)) \
? Dec_INCREF_TRUE : Dec_INCREF_FALSE; \
}
/* Unary function with an optional context arg. */
#define Dec_UnaryFuncVA(MPDFUNC) \
static PyObject * \
dec_##MPDFUNC(PyObject *self, PyObject *args) \
{ \
PyObject *result; \
PyObject *context; \
uint32_t status = 0; \
\
CURRENT_CONTEXT(context); \
if (!PyArg_ParseTuple(args, "|O", &context)) { \
return NULL; \
} \
CONTEXT_CHECK_VA(context); \
\
if ((result = dec_alloc()) == NULL) { \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(self), CTX(context), &status); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/* Binary function with an optional context arg. */
#define Dec_BinaryFuncVA(MPDFUNC) \
static PyObject * \
dec_##MPDFUNC(PyObject *v, PyObject *args) \
{ \
PyObject *w, *context; \
PyObject *a, *b; \
PyObject *result; \
uint32_t status = 0; \
\
CURRENT_CONTEXT(context); \
if (!PyArg_ParseTuple(args, "O|O", &w, &context)) { \
return NULL; \
} \
CONTEXT_CHECK_VA(context); \
CONVERT_BINOP_RAISE(&a, &b, v, w, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b), CTX(context), &status); \
Py_DECREF(a); \
Py_DECREF(b); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/* Binary function with an optional context arg. Actual MPDFUNC does
NOT take a context. Uses optional context for conversion only. */
#define Dec_BinaryFuncVA_NO_CTX(MPDFUNC) \
static PyObject * \
dec_##MPDFUNC(PyObject *v, PyObject *args) \
{ \
PyObject *w, *context; \
PyObject *a, *b; \
PyObject *result; \
\
CURRENT_CONTEXT(context); \
if (!PyArg_ParseTuple(args, "O|O", &w, &context)) { \
return NULL; \
} \
CONTEXT_CHECK_VA(context); \
CONVERT_BINOP_RAISE(&a, &b, v, w, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b)); \
Py_DECREF(a); \
Py_DECREF(b); \
\
return result; \
}
/* Ternary function with an optional context arg. */
#define Dec_TernaryFuncVA(MPDFUNC) \
static PyObject * \
dec_##MPDFUNC(PyObject *v, PyObject *args) \
{ \
PyObject *w, *x, *context; \
PyObject *a, *b, *c; \
PyObject *result; \
uint32_t status = 0; \
\
CURRENT_CONTEXT(context); \
if (!PyArg_ParseTuple(args, "OO|O", &w, &x, &context)) { \
return NULL; \
} \
CONTEXT_CHECK_VA(context); \
CONVERT_TERNOP_RAISE(&a, &b, &c, v, w, x, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
Py_DECREF(c); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b), MPD(c), CTX(context), &status); \
Py_DECREF(a); \
Py_DECREF(b); \
Py_DECREF(c); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/**********************************************/
/* Number methods */
/**********************************************/
Dec_UnaryNumberMethod(mpd_qminus)
Dec_UnaryNumberMethod(mpd_qplus)
Dec_UnaryNumberMethod(mpd_qabs)
Dec_BinaryNumberMethod(mpd_qadd)
Dec_BinaryNumberMethod(mpd_qsub)
Dec_BinaryNumberMethod(mpd_qmul)
Dec_BinaryNumberMethod(mpd_qdiv)
Dec_BinaryNumberMethod(mpd_qrem)
Dec_BinaryNumberMethod(mpd_qdivint)
static PyObject *
nm_dec_as_int(PyObject *dec)
{
PyObject *context;
CURRENT_CONTEXT(context);
return _dec_as_integral(1, dec, context, MPD_ROUND_DOWN);
}
static PyObject *
nm_dec_as_long(PyObject *dec)
{
PyObject *context;
CURRENT_CONTEXT(context);
return _dec_as_integral(0, dec, context, MPD_ROUND_DOWN);
}
static int
nm_nonzero(PyDecObject *v)
{
return !mpd_iszero(v->dec);
}
static PyObject *
nm_mpd_qdivmod(PyObject *v, PyObject *w)
{
PyObject *a, *b;
PyObject *q, *r;
PyObject *context;
uint32_t status = 0;
PyObject *ret;
CURRENT_CONTEXT(context);
CONVERT_BINOP(&a, &b, v, w, context);
if ((q = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
return NULL;
}
if ((r = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
Py_DECREF(q);
return NULL;
}
mpd_qdivmod(MPD(q), MPD(r), MPD(a), MPD(b), CTX(context), &status);
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(r);
Py_DECREF(q);
return NULL;
}
ret = Py_BuildValue("(OO)", q, r);
Py_DECREF(r);
Py_DECREF(q);
return ret;
}
static PyObject *
nm_mpd_qpow(PyObject *base, PyObject *exp, PyObject *mod)
{
PyObject *a, *b, *c = NULL;
PyObject *result;
PyObject *context;
uint32_t status = 0;
CURRENT_CONTEXT(context);
CONVERT_BINOP(&a, &b, base, exp, context);
if (mod != Py_None) {
if (!convert_op(NOT_IMPL, &c, mod, context)) {
Py_DECREF(a);
Py_DECREF(b);
return c;
}
}
if ((result = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
Py_XDECREF(c);
return NULL;
}
if (c == NULL) {
mpd_qpow(MPD(result), MPD(a), MPD(b),
CTX(context), &status);
}
else {
mpd_qpowmod(MPD(result), MPD(a), MPD(b), MPD(c),
CTX(context), &status);
Py_DECREF(c);
}
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
/******************************************************************************/
/* Decimal Methods */
/******************************************************************************/
/* Arithmetic operations */
Dec_UnaryFuncVA(mpd_qabs)
Dec_UnaryFuncVA(mpd_qexp)
Dec_UnaryFuncVA(mpd_qinvroot)
Dec_UnaryFuncVA(mpd_qln)
Dec_UnaryFuncVA(mpd_qlog10)
Dec_UnaryFuncVA(mpd_qminus)
Dec_UnaryFuncVA(mpd_qnext_minus)
Dec_UnaryFuncVA(mpd_qnext_plus)
Dec_UnaryFuncVA(mpd_qplus)
Dec_UnaryFuncVA(mpd_qreduce)
Dec_UnaryFuncVA(mpd_qsqrt)
Dec_BinaryFuncVA(mpd_qadd)
Dec_BinaryFuncVA(mpd_qcompare)
Dec_BinaryFuncVA(mpd_qcompare_signal)
Dec_BinaryFuncVA(mpd_qdiv)
Dec_BinaryFuncVA(mpd_qdivint)
Dec_BinaryFuncVA(mpd_qmax)
Dec_BinaryFuncVA(mpd_qmax_mag)
Dec_BinaryFuncVA(mpd_qmin)
Dec_BinaryFuncVA(mpd_qmin_mag)
Dec_BinaryFuncVA(mpd_qmul)
Dec_BinaryFuncVA(mpd_qnext_toward)
Dec_BinaryFuncVA(mpd_qpow)
Dec_BinaryFuncVA(mpd_qrem)
Dec_BinaryFuncVA(mpd_qrem_near)
Dec_BinaryFuncVA(mpd_qsub)
Dec_TernaryFuncVA(mpd_qfma)
Dec_TernaryFuncVA(mpd_qpowmod)
/* Miscellaneous */
Dec_BoolFunc(mpd_iscanonical)
Dec_BoolFunc(mpd_isfinite)
Dec_BoolFunc(mpd_isinfinite)
Dec_BoolFunc(mpd_isinteger)
Dec_BoolFunc(mpd_isnan)
Dec_BoolFunc(mpd_isqnan)
Dec_BoolFunc(mpd_issnan)
Dec_BoolFunc(mpd_issigned)
Dec_BoolFunc(mpd_isspecial)
Dec_BoolFunc(mpd_iszero)
Dec_BoolFuncVA(mpd_isnormal)
Dec_BoolFuncVA(mpd_issubnormal)
static PyObject *
dec_mpd_adjexp(PyObject *self, PyObject *dummy UNUSED)
{
mpd_ssize_t retval;
if (mpd_isspecial(MPD(self))) {
retval = 0;
}
else {
retval = mpd_adjexp(MPD(self));
}
return _PyLong_FromMpdSsize(retval);
}
/* Apply either the current context or the context provided as an optional
argument. */
static PyObject *
PyDec_Apply(PyObject *dec, PyObject *args)
{
PyObject *context;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "|O", &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
return dec_apply(dec, context);
}
static PyObject *
dec_mpd_qcopy_abs(PyObject *self, PyObject *dummy UNUSED)
{
PyObject *result;
PyObject *context;
uint32_t status = 0;
CURRENT_CONTEXT(context);
if ((result = dec_alloc()) == NULL) {
return NULL;
}
mpd_qcopy_abs(MPD(result), MPD(self), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
static PyObject *
dec_mpd_qcopy_negate(PyObject *self, PyObject *dummy UNUSED)
{
PyObject *result;
PyObject *context;
uint32_t status = 0;
CURRENT_CONTEXT(context);
if ((result = dec_alloc()) == NULL) {
return NULL;
}
mpd_qcopy_negate(MPD(result), MPD(self), &status);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
Dec_UnaryFuncVA(mpd_qinvert)
Dec_UnaryFuncVA(mpd_qlogb)
Dec_BinaryFuncVA_NO_CTX(mpd_compare_total)
Dec_BinaryFuncVA_NO_CTX(mpd_compare_total_mag)
static PyObject *
dec_mpd_qcopy_sign(PyObject *v, PyObject *w)
{
PyObject *result;
PyObject *a, *b;
PyObject *context;
uint32_t status = 0;
CURRENT_CONTEXT(context);
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
if ((result = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
return NULL;
}
mpd_qcopy_sign(MPD(result), MPD(a), MPD(b), &status);
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
Dec_BinaryFuncVA(mpd_qand)
Dec_BinaryFuncVA(mpd_qor)
Dec_BinaryFuncVA(mpd_qxor)
Dec_BinaryFuncVA(mpd_qrotate)
Dec_BinaryFuncVA(mpd_qscaleb)
Dec_BinaryFuncVA(mpd_qshift)
static PyObject *
dec_mpd_class(PyObject *self, PyObject *args)
{
PyObject *context;
const char *cp;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "|O", &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
cp = mpd_class(MPD(self), CTX(context));
return Py_BuildValue("s", cp);
}
static PyObject *
dec_canonical(PyObject *self, PyObject *dummy UNUSED)
{
Py_INCREF(self);
return self;
}
static PyObject *
dec_copy(PyObject *self, PyObject *dummy UNUSED)
{
Py_INCREF(self);
return self;
}
static PyObject *
dec_mpd_qdivmod(PyObject *v, PyObject *args)
{
PyObject *w, *context;
PyObject *a, *b;
PyObject *q, *r;
uint32_t status = 0;
PyObject *ret;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "O|O", &w, &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
if ((q = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
return NULL;
}
if ((r = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
Py_DECREF(q);
return NULL;
}
mpd_qdivmod(MPD(q), MPD(r), MPD(a), MPD(b), CTX(context), &status);
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(r);
Py_DECREF(q);
return NULL;
}
ret = Py_BuildValue("(OO)", q, r);
Py_DECREF(r);
Py_DECREF(q);
return ret;
}
static PyObject *
dec_mpd_qquantize(PyObject *v, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"exp", "rounding", "context", NULL};
PyObject *w, *context;
PyObject *a, *b;
PyObject *result;
uint32_t status = 0;
mpd_context_t workctx;
int round = -1;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|iO", kwlist,
&w, &round, &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
workctx = *CTX(context);
if (round >= 0) {
if (!mpd_qsetround(&workctx, round)) {
return type_error_ptr(invalid_rounding_err);
}
}
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
if ((result = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
return NULL;
}
mpd_qquantize(MPD(result), MPD(a), MPD(b), &workctx, &status);
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
static PyObject *
dec_mpd_radix(PyObject *self UNUSED, PyObject *dummy UNUSED)
{
PyObject *result;
if ((result = dec_alloc()) == NULL) {
return NULL;
}
_dec_settriple(result, MPD_POS, 10, 0);
return result;
}
static PyObject *
dec_mpd_same_quantum(PyObject *v, PyObject *args)
{
PyObject *result;
PyObject *w, *context;
PyObject *a, *b;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "O|O", &w, &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
result = mpd_same_quantum(MPD(a), MPD(b)) ?
Dec_INCREF_TRUE : Dec_INCREF_FALSE;
Py_DECREF(a);
Py_DECREF(b);
return result;
}
static PyObject *
dec_mpd_sign(PyObject *self, PyObject *dummy UNUSED)
{
return Py_BuildValue("i", mpd_arith_sign(MPD(self)));
}
static PyObject *
dec_mpd_to_sci(PyObject *self, PyObject *args)
{
PyObject *result;
PyObject *context;
char *s;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "|O", &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
s = mpd_to_sci(MPD(self), CtxCaps(context));
if (s == NULL) {
PyErr_NoMemory();
return NULL;
}
result = PyString_FromString(s);
mpd_free(s);
return result;
}
static PyObject *
dec_mpd_to_eng(PyObject *self, PyObject *args)
{
PyObject *result;
PyObject *context;
char *s;
CURRENT_CONTEXT(context);
if (!PyArg_ParseTuple(args, "|O", &context)) {
return NULL;
}
CONTEXT_CHECK_VA(context);
s = mpd_to_eng(MPD(self), CtxCaps(context));
if (s == NULL) {
PyErr_NoMemory();
return NULL;
}
result = PyString_FromString(s);
mpd_free(s);
return result;
}
static PyObject *
dec_richcompare(PyObject *v, PyObject *w, int op)
{
PyObject *a;
PyObject *b;
PyObject *context;
uint32_t status = 0;
int a_issnan, b_issnan;
int r;
assert(PyDec_Check(v));
CURRENT_CONTEXT(context);
CONVERT_BINOP_CMP(&a, &b, v, w, op, context);
a_issnan = mpd_issnan(MPD(a));
b_issnan = mpd_issnan(MPD(b));
r = mpd_qcmp(MPD(a), MPD(b), &status);
Py_DECREF(a);
Py_DECREF(b);
if (r == INT_MAX) {
/* sNaNs or op={le,ge,lt,gt} always signal. */
if (a_issnan || b_issnan || (op != Py_EQ && op != Py_NE)) {
if (dec_addstatus(context, status)) {
return NULL;
}
}
/* qNaN comparison with op={eq,ne} or comparison
* with InvalidOperation disabled. */
return (op == Py_NE) ? Dec_INCREF_TRUE : Dec_INCREF_FALSE;
}
switch (op) {
case Py_EQ:
r = (r == 0);
break;
case Py_NE:
r = (r != 0);
break;
case Py_LE:
r = (r <= 0);
break;
case Py_GE:
r = (r >= 0);
break;
case Py_LT:
r = (r == -1);
break;
case Py_GT:
r = (r == 1);
break;
}
return PyBool_FromLong(r);
}
/* Always uses the module context */
static long
_dec_hash(PyObject *v)
{
#if PY_VERSION_HEX >= 0x02060000
#if defined(CONFIG_64)
mpd_uint_t data_two64m1[2] = {8446744073709551615ULL, 1ULL};
mpd_t two64m1 = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 20, 2, 2,
data_two64m1};
#elif defined(CONFIG_32)
mpd_uint_t data_two64m1[3] = {709551615UL, 446744073UL, 18UL};
mpd_t two64m1 = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 20, 3, 2,
data_two64m1};
#else
#error "CONFIG_64 or CONFIG_32 must be defined."
#endif
mpd_uint_t data_ten[1] = {10};
mpd_t ten = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 2, 1, 1, data_ten};
#endif
PyObject *a;
PyObject *obj = NULL;
mpd_t *tmp = NULL;
char *cp = NULL;
uint32_t status = 0;
mpd_context_t maxcontext;
long result;
if ((a = dec_alloc()) == NULL) {
PyErr_NoMemory();
return -1;
}
if (!mpd_qcopy(MPD(a), MPD(v), &status)) {
PyErr_NoMemory();
result = -1;
goto finish;
}
if (mpd_isinteger(MPD(a))) {
PyObject *context = current_context();
if (context == NULL) {
result = -1;
goto finish;
}
mpd_maxcontext(&maxcontext);
#if PY_VERSION_HEX >= 0x02060000
if ((tmp = mpd_qnew()) == NULL) {
PyErr_NoMemory();
result = -1;
goto finish;
}
/* clobbering a function scope object */
mpd_qround_to_int(MPD(a), MPD(a), CTX(context), &status);
mpd_qset_ssize(tmp, MPD(a)->exp, &maxcontext, &status);
mpd_qpowmod(tmp, &ten, tmp, &two64m1, &maxcontext, &status);
MPD(a)->exp = 0;
mpd_qmul(MPD(a), MPD(a), tmp, &maxcontext, &status);
if (status&MPD_Errors) {
if (dec_addstatus(context, status)) {
result = -1;
goto finish;
}
}
#endif
obj = _dec_as_integral(0, a, context, MPD_ROUND_DOWN);
if (obj == NULL) {
result = -1;
goto finish;
}
result = PyObject_Hash(obj);
}
else {
mpd_ssize_t tz;
mpd_ssize_t exp;
int sign;
mpd_maxcontext(&maxcontext);
tz = mpd_trail_zeros(MPD(a));
exp = MPD(a)->exp + MPD(a)->digits;
sign = mpd_sign(MPD(a));
mpd_qshiftr_inplace(MPD(a), tz);
MPD(a)->exp = 0;
mpd_set_flags(MPD(a), MPD_POS);
cp = mpd_to_sci(MPD(a), 1);
if (cp == NULL) {
PyErr_NoMemory();
result = -1;
goto finish;
}
obj = Py_BuildValue("(i"CONV_mpd_ssize_t"s)", sign, exp, cp);
if (obj == NULL) {
result = -1;
goto finish;
}
result = PyObject_Hash(obj);
}
finish:
Py_DECREF(a);
Py_XDECREF(obj);
if (tmp) mpd_del(tmp);
if (cp) mpd_free(cp);
return result;
}
#if PY_VERSION_HEX < 0x02070000
static long
dec_hash(PyObject *v)
{
if (mpd_isspecial(MPD(v))) {
if (mpd_isnan(MPD(v))) {
PyErr_SetString(PyExc_TypeError,
"cannot hash a NaN value.");
return -1;
}
else {
long result;
PyObject *obj = dec_str(v);
if (obj == NULL) {
return -1;
}
result = PyObject_Hash(obj);
Py_DECREF(obj);
return result;
}
}
if (mpd_iszero(MPD(v))) {
return 0;
}
return _dec_hash(v);
}
#else
static long
dec_hash(PyObject *v)
{
PyObject *v_as_float;
PyObject *roundtrip;
PyObject *context;
uint32_t status = 0;
long ret;
context = current_context();
if (context == NULL) {
return -1;
}
if (mpd_isspecial(MPD(v))) {
if (mpd_issnan(MPD(v))) {
PyErr_SetString(PyExc_TypeError,
"Cannot hash a signaling NaN value.");
return -1;
}
else if (mpd_isnan(MPD(v))) {
return 0;
}
else {
return mpd_ispositive(MPD(v)) ? 314159L : -271828L;
}
}
v_as_float = PyDec_AsFloat(v);
if (v_as_float == NULL) {
return -1;
}
roundtrip = PyDec_FromFloatExact(v_as_float, context);
if (roundtrip == NULL) {
Py_DECREF(v_as_float);
return -1;
}
if (!mpd_isspecial(MPD(roundtrip)) &&
mpd_qcmp(MPD(v), MPD(roundtrip), &status) == 0) {
ret = PyObject_Hash(v_as_float);
}
else {
ret = _dec_hash(v);
}
Py_DECREF(v_as_float);
Py_DECREF(roundtrip);
return ret;
}
#endif
static PyObject *
dec_reduce(PyObject *self, PyObject *dummy UNUSED)
{
PyObject *result, *str;
if ((str = dec_str(self)) == NULL) {
return NULL;
}
result = Py_BuildValue("O(O)", Py_TYPE(self), str);
Py_DECREF(str);
return result;
}
static PyObject *
dec_real(PyObject *self, void *closure UNUSED)
{
Py_INCREF(self);
return self;
}
static PyObject *
dec_imag(PyObject *self UNUSED, void *closure UNUSED)
{
PyObject *result;
if ((result = dec_alloc()) == NULL) {
return NULL;
}
_dec_settriple(result, MPD_POS, 0, 0);
return result;
}
static PyObject *
dec_conjugate(PyObject *self, PyObject *dummy UNUSED)
{
Py_INCREF(self);
return self;
}
static PyObject *
dec_complex(PyObject *self, PyObject *dummy UNUSED)
{
PyObject *f;
double x;
if ((f = PyDec_AsFloat(self)) == NULL) {
return NULL;
}
x = PyFloat_AsDouble(f);
Py_DECREF(f);
if (PyErr_Occurred()) {
return NULL;
}
return PyComplex_FromDoubles(x, 0);
}
static PyObject *
dec_trunc(PyObject *dec, PyObject *dummy UNUSED)
{
PyObject *context;
CURRENT_CONTEXT(context);
return _dec_as_integral(1, dec, context, MPD_ROUND_DOWN);
}
static PyGetSetDef dec_getsets [] =
{
{ "real", (getter)dec_real, NULL, NULL, NULL},
{ "imag", (getter)dec_imag, NULL, NULL, NULL},
{NULL}
};
static PyNumberMethods dec_number_methods =
{
(binaryfunc) nm_mpd_qadd,
(binaryfunc) nm_mpd_qsub,
(binaryfunc) nm_mpd_qmul,
(binaryfunc) nm_mpd_qdiv,
(binaryfunc) nm_mpd_qrem,
(binaryfunc) nm_mpd_qdivmod,
(ternaryfunc) nm_mpd_qpow,
(unaryfunc) nm_mpd_qminus,
(unaryfunc) nm_mpd_qplus,
(unaryfunc) nm_mpd_qabs,
(inquiry) nm_nonzero,
(unaryfunc) 0, /* no bit-complement */
(binaryfunc) 0, /* no shiftl */
(binaryfunc) 0, /* no shiftr */
(binaryfunc) 0, /* no bit-and */
(binaryfunc) 0, /* no bit-xor */
(binaryfunc) 0, /* no bit-ior */
(coercion) 0, /* nb_coerce */
(unaryfunc) nm_dec_as_int,
(unaryfunc) nm_dec_as_long,
(unaryfunc) PyDec_AsFloat,
(unaryfunc) 0, /* no oct */
(unaryfunc) 0, /* no hex */
0, /* binaryfunc nb_inplace_add; */
0, /* binaryfunc nb_inplace_subtract; */
0, /* binaryfunc nb_inplace_multiply; */
0, /* binaryfunc nb_inplace_divide; */
0, /* binaryfunc nb_inplace_remainder; */
0, /* ternaryfunc nb_inplace_power; */
0, /* binaryfunc nb_inplace_lshift; */
0, /* binaryfunc nb_inplace_rshift; */
0, /* binaryfunc nb_inplace_and; */
0, /* binaryfunc nb_inplace_xor; */
0, /* binaryfunc nb_inplace_or; */
(binaryfunc) nm_mpd_qdivint, /* binaryfunc nb_floor_divide; */
(binaryfunc) nm_mpd_qdiv, /* binaryfunc nb_true_divide; */
0, /* binaryfunc nb_inplace_floor_divide; */
0, /* binaryfunc nb_inplace_true_divide; */
};
static PyMethodDef dec_methods [] =
{
/* Unary arithmetic functions */
{ "abs", dec_mpd_qabs, METH_VARARGS, doc_abs },
{ "exp", dec_mpd_qexp, METH_VARARGS, doc_exp },
{ "invroot", dec_mpd_qinvroot, METH_VARARGS, doc_invroot },
{ "ln", dec_mpd_qln, METH_VARARGS, doc_ln },
{ "log10", dec_mpd_qlog10, METH_VARARGS, doc_log10 },
{ "minus", dec_mpd_qminus, METH_VARARGS, doc_minus },
{ "next_minus", dec_mpd_qnext_minus, METH_VARARGS, doc_next_minus },
{ "next_plus", dec_mpd_qnext_plus, METH_VARARGS, doc_next_plus },
{ "normalize", dec_mpd_qreduce, METH_VARARGS, doc_normalize }, /* alias for reduce */
{ "plus", dec_mpd_qplus, METH_VARARGS, doc_plus },
{ "reduce", dec_mpd_qreduce, METH_VARARGS, doc_reduce },
{ "to_integral", (PyCFunction)PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral },
{ "to_integral_exact", (PyCFunction)PyDec_ToIntegralExact, METH_VARARGS|METH_KEYWORDS, doc_to_integral_exact },
{ "to_integral_value", (PyCFunction)PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral_value },
{ "sqrt", dec_mpd_qsqrt, METH_VARARGS, doc_sqrt },
/* Binary arithmetic functions */
{ "add", dec_mpd_qadd, METH_VARARGS, doc_add },
{ "compare", dec_mpd_qcompare, METH_VARARGS, doc_compare },
{ "compare_signal", dec_mpd_qcompare_signal, METH_VARARGS, doc_compare_signal },
{ "div", dec_mpd_qdiv, METH_VARARGS, doc_div }, /* alias for divide */
{ "divide", dec_mpd_qdiv, METH_VARARGS, doc_divide },
{ "divide_int", dec_mpd_qdivint, METH_VARARGS, doc_divide_int },
{ "divint", dec_mpd_qdivint, METH_VARARGS, doc_divint }, /* alias for divide_int */
{ "divmod", dec_mpd_qdivmod, METH_VARARGS, doc_divmod },
{ "max", dec_mpd_qmax, METH_VARARGS, doc_max },
{ "max_mag", dec_mpd_qmax_mag, METH_VARARGS, doc_max_mag },
{ "min", dec_mpd_qmin, METH_VARARGS, doc_min },
{ "min_mag", dec_mpd_qmin_mag, METH_VARARGS, doc_min_mag },
{ "mul", dec_mpd_qmul, METH_VARARGS, doc_mul }, /* alias for multiply */
{ "multiply", dec_mpd_qmul, METH_VARARGS, doc_multiply },
{ "next_toward", dec_mpd_qnext_toward, METH_VARARGS, doc_next_toward },
{ "pow", dec_mpd_qpow, METH_VARARGS, doc_pow }, /* alias for power */
{ "power", dec_mpd_qpow, METH_VARARGS, doc_power },
{ "quantize", (PyCFunction)dec_mpd_qquantize, METH_VARARGS|METH_KEYWORDS, doc_quantize },
{ "rem", dec_mpd_qrem, METH_VARARGS, doc_rem }, /* alias for remainder */
{ "remainder", dec_mpd_qrem, METH_VARARGS, doc_remainder },
{ "remainder_near", dec_mpd_qrem_near, METH_VARARGS, doc_remainder_near },
{ "sub", dec_mpd_qsub, METH_VARARGS, doc_sub }, /* alias for subtract */
{ "subtract", dec_mpd_qsub, METH_VARARGS, doc_subtract },
/* Ternary arithmetic functions */
{ "fma", dec_mpd_qfma, METH_VARARGS, doc_fma },
{ "powmod", dec_mpd_qpowmod, METH_VARARGS, doc_powmod },
/* Boolean functions, no context arg */
{ "is_canonical", dec_mpd_iscanonical, METH_NOARGS, doc_is_canonical },
{ "is_finite", dec_mpd_isfinite, METH_NOARGS, doc_is_finite },
{ "is_infinite", dec_mpd_isinfinite, METH_NOARGS, doc_is_infinite },
{ "is_integer", dec_mpd_isinteger, METH_NOARGS, doc_is_integer },
{ "is_nan", dec_mpd_isnan, METH_NOARGS, doc_is_nan },
{ "is_qnan", dec_mpd_isqnan, METH_NOARGS, doc_is_qnan },
{ "is_snan", dec_mpd_issnan, METH_NOARGS, doc_is_snan },
{ "is_signed", dec_mpd_issigned, METH_NOARGS, doc_is_signed },
{ "is_special", dec_mpd_isspecial, METH_NOARGS, doc_is_special },
{ "is_zero", dec_mpd_iszero, METH_NOARGS, doc_is_zero },
/* Boolean functions, optional context arg */
{ "is_normal", dec_mpd_isnormal, METH_VARARGS, doc_is_normal },
{ "is_subnormal", dec_mpd_issubnormal, METH_VARARGS, doc_is_subnormal },
/* Unary functions, no context arg */
{ "adjusted", dec_mpd_adjexp, METH_NOARGS, doc_adjusted },
{ "canonical", dec_canonical, METH_NOARGS, doc_canonical },
{ "conjugate", dec_conjugate, METH_NOARGS, doc_conjugate },
{ "copy_abs", dec_mpd_qcopy_abs, METH_NOARGS, doc_copy_abs },
{ "copy_negate", dec_mpd_qcopy_negate, METH_NOARGS, doc_copy_negate },
{ "radix", dec_mpd_radix, METH_NOARGS, doc_radix },
{ "sign", dec_mpd_sign, METH_NOARGS, doc_sign },
/* Unary functions, optional context arg */
{ "apply", PyDec_Apply, METH_VARARGS, doc_apply },
{ "logb", dec_mpd_qlogb, METH_VARARGS, doc_logb },
{ "logical_invert", dec_mpd_qinvert, METH_VARARGS, doc_logical_invert },
{ "number_class", dec_mpd_class, METH_VARARGS, doc_number_class },
{ "to_sci", dec_mpd_to_sci, METH_VARARGS, doc_to_sci }, /* alias for to_sci_string */
{ "to_sci_string", dec_mpd_to_sci, METH_VARARGS, doc_to_sci_string },
{ "to_eng", dec_mpd_to_eng, METH_VARARGS, doc_to_eng }, /* alias for to_eng_string */
{ "to_eng_string", dec_mpd_to_eng, METH_VARARGS, doc_to_eng_string },
/* Binary functions, optional context arg */
{ "compare_total", dec_mpd_compare_total, METH_VARARGS, doc_compare_total },
{ "compare_total_mag", dec_mpd_compare_total_mag, METH_VARARGS, doc_compare_total_mag },
{ "copy_sign", dec_mpd_qcopy_sign, METH_O, doc_copy_sign },
{ "logical_and", dec_mpd_qand, METH_VARARGS, doc_logical_and },
{ "logical_or", dec_mpd_qor, METH_VARARGS, doc_logical_or },
{ "logical_xor", dec_mpd_qxor, METH_VARARGS, doc_logical_xor },
{ "rotate", dec_mpd_qrotate, METH_VARARGS, doc_rotate },
{ "same_quantum", dec_mpd_same_quantum, METH_VARARGS, doc_same_quantum },
{ "scaleb", dec_mpd_qscaleb, METH_VARARGS, doc_scaleb },
{ "shift", dec_mpd_qshift, METH_VARARGS, doc_shift },
/* Miscellaneous */
{ "from_float", dec_from_float, METH_O|METH_CLASS, doc_from_float },
{ "as_tuple", PyDec_AsTuple, METH_NOARGS, doc_as_tuple },
/* Generic stuff */
{ "__copy__", dec_copy, METH_NOARGS, NULL },
{ "__deepcopy__", dec_copy, METH_O, NULL },
#if PY_VERSION_HEX >= 0x02060000
{ "__format__", dec_format, METH_VARARGS, NULL },
#endif
{ "__reduce__", dec_reduce, METH_NOARGS, NULL },
{ "__round__", PyDec_Round, METH_VARARGS, NULL },
{ "__trunc__", dec_trunc, METH_NOARGS, NULL },
{ "__complex__", dec_complex, METH_NOARGS, NULL },
{ NULL, NULL, 1 }
};
static PyTypeObject PyDec_Type =
{
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"cdecimal.Decimal", /* tp_name */
sizeof(PyDecObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) dec_dealloc, /* tp_dealloc */
0, /* tp_print */
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
0, /* tp_compare */
(reprfunc) dec_repr, /* tp_repr */
&dec_number_methods, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc) dec_hash, /* tp_hash */
0, /* tp_call */
(reprfunc) dec_str, /* tp_str */
(getattrofunc) PyObject_GenericGetAttr, /* tp_getattro */
(setattrofunc) 0, /* tp_setattro */
(PyBufferProcs *) 0, /* tp_as_buffer */
(Py_TPFLAGS_DEFAULT|
Py_TPFLAGS_CHECKTYPES|
Py_TPFLAGS_BASETYPE) /* tp_flags */,
doc_decimal, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
dec_richcompare, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
dec_methods, /* tp_methods */
0, /* tp_members */
dec_getsets, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
dec_new, /* tp_new */
PyObject_Del, /* tp_free */
};
/******************************************************************************/
/* Context Object, Part 2 */
/******************************************************************************/
/************************************************************************/
/* Macros for converting mpdecimal functions to Context methods */
/************************************************************************/
/* Boolean context method. */
#define DecCtx_BoolFunc(MPDFUNC) \
static PyObject * \
ctx_##MPDFUNC(PyObject *context, PyObject *v) \
{ \
PyObject *ret; \
PyObject *a; \
\
CONVERT_OP_RAISE(&a, v, context); \
\
ret = MPDFUNC(MPD(a), CTX(context)) \
? Dec_INCREF_TRUE : Dec_INCREF_FALSE; \
Py_DECREF(a); \
return ret; \
}
/* Boolean context method. MPDFUNC does NOT use a context. */
#define DecCtx_BoolFunc_NO_CTX(MPDFUNC) \
static PyObject * \
ctx_##MPDFUNC(PyObject *context, PyObject *v) \
{ \
PyObject *ret; \
PyObject *a; \
\
CONVERT_OP_RAISE(&a, v, context); \
\
ret = MPDFUNC(MPD(a)) ? Dec_INCREF_TRUE : Dec_INCREF_FALSE; \
Py_DECREF(a); \
return ret; \
}
/* Unary context method. */
#define DecCtx_UnaryFunc(MPDFUNC) \
static PyObject * \
ctx_##MPDFUNC(PyObject *context, PyObject *v) \
{ \
PyObject *result, *a; \
uint32_t status = 0; \
\
CONVERT_OP_RAISE(&a, v, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), CTX(context), &status); \
Py_DECREF(a); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/* Binary context method. */
#define DecCtx_BinaryFunc(MPDFUNC) \
static PyObject * \
ctx_##MPDFUNC(PyObject *context, PyObject *args) \
{ \
PyObject *v, *w; \
PyObject *a, *b; \
PyObject *result; \
uint32_t status = 0; \
\
if (!PyArg_ParseTuple(args, "OO", &v, &w)) { \
return NULL; \
} \
\
CONVERT_BINOP_RAISE(&a, &b, v, w, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b), CTX(context), &status); \
Py_DECREF(a); \
Py_DECREF(b); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
/*
* Binary context method. The context is only used for conversion.
* The actual MPDFUNC does NOT take a context arg.
*/
#define DecCtx_BinaryFunc_NO_CTX(MPDFUNC) \
static PyObject * \
ctx_##MPDFUNC(PyObject *context, PyObject *args) \
{ \
PyObject *v, *w; \
PyObject *a, *b; \
PyObject *result; \
\
if (!PyArg_ParseTuple(args, "OO", &v, &w)) { \
return NULL; \
} \
\
CONVERT_BINOP_RAISE(&a, &b, v, w, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b)); \
Py_DECREF(a); \
Py_DECREF(b); \
\
return result; \
}
/* Ternary context method. */
#define DecCtx_TernaryFunc(MPDFUNC) \
static PyObject * \
ctx_##MPDFUNC(PyObject *context, PyObject *args) \
{ \
PyObject *v, *w, *x; \
PyObject *a, *b, *c; \
PyObject *result; \
uint32_t status = 0; \
\
if (!PyArg_ParseTuple(args, "OOO", &v, &w, &x)) { \
return NULL; \
} \
\
CONVERT_TERNOP_RAISE(&a, &b, &c, v, w, x, context); \
\
if ((result = dec_alloc()) == NULL) { \
Py_DECREF(a); \
Py_DECREF(b); \
Py_DECREF(c); \
return NULL; \
} \
\
MPDFUNC(MPD(result), MPD(a), MPD(b), MPD(c), CTX(context), &status); \
Py_DECREF(a); \
Py_DECREF(b); \
Py_DECREF(c); \
if (dec_addstatus(context, status)) { \
Py_DECREF(result); \
return NULL; \
} \
\
return result; \
}
static PyObject *
ctx_copy_decimal(PyObject *context, PyObject *v)
{
PyObject *result;
CONVERT_OP_RAISE(&result, v, context);
return result;
}
/* Arithmetic operations */
DecCtx_UnaryFunc(mpd_qabs)
DecCtx_UnaryFunc(mpd_qexp)
DecCtx_UnaryFunc(mpd_qinvroot)
DecCtx_UnaryFunc(mpd_qln)
DecCtx_UnaryFunc(mpd_qlog10)
DecCtx_UnaryFunc(mpd_qminus)
DecCtx_UnaryFunc(mpd_qnext_minus)
DecCtx_UnaryFunc(mpd_qnext_plus)
DecCtx_UnaryFunc(mpd_qplus)
DecCtx_UnaryFunc(mpd_qreduce)
DecCtx_UnaryFunc(mpd_qround_to_int)
DecCtx_UnaryFunc(mpd_qround_to_intx)
DecCtx_UnaryFunc(mpd_qsqrt)
DecCtx_BinaryFunc(mpd_qadd)
DecCtx_BinaryFunc(mpd_qcompare)
DecCtx_BinaryFunc(mpd_qcompare_signal)
DecCtx_BinaryFunc(mpd_qdiv)
DecCtx_BinaryFunc(mpd_qdivint)
DecCtx_BinaryFunc(mpd_qmax)
DecCtx_BinaryFunc(mpd_qmax_mag)
DecCtx_BinaryFunc(mpd_qmin)
DecCtx_BinaryFunc(mpd_qmin_mag)
DecCtx_BinaryFunc(mpd_qmul)
DecCtx_BinaryFunc(mpd_qnext_toward)
DecCtx_BinaryFunc(mpd_qpow)
DecCtx_BinaryFunc(mpd_qquantize)
DecCtx_BinaryFunc(mpd_qrem)
DecCtx_BinaryFunc(mpd_qrem_near)
DecCtx_BinaryFunc(mpd_qsub)
DecCtx_TernaryFunc(mpd_qfma)
DecCtx_TernaryFunc(mpd_qpowmod)
/* Miscellaneous */
DecCtx_BoolFunc(mpd_isnormal)
DecCtx_BoolFunc(mpd_issubnormal)
DecCtx_BoolFunc_NO_CTX(mpd_isfinite)
DecCtx_BoolFunc_NO_CTX(mpd_isinfinite)
DecCtx_BoolFunc_NO_CTX(mpd_isnan)
DecCtx_BoolFunc_NO_CTX(mpd_isqnan)
DecCtx_BoolFunc_NO_CTX(mpd_issigned)
DecCtx_BoolFunc_NO_CTX(mpd_issnan)
DecCtx_BoolFunc_NO_CTX(mpd_iszero)
static PyObject *
ctx_mpd_qcopy_abs(PyObject *context, PyObject *v)
{
PyObject *result, *a;
uint32_t status = 0;
CONVERT_OP_RAISE(&a, v, context);
if ((result = dec_alloc()) == NULL) {
Py_DECREF(a);
return NULL;
}
mpd_qcopy_abs(MPD(result), MPD(a), &status);
Py_DECREF(a);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
/* apply() as a context method. */
static PyObject *
PyDecContext_Apply(PyObject *context, PyObject *v)
{
PyObject *result, *a;
CONVERT_OP_RAISE(&a, v, context);
result = dec_apply(a, context);
Py_DECREF(a);
return result;
}
static PyObject *
ctx_mpd_qcopy_negate(PyObject *context, PyObject *v)
{
PyObject *result, *a;
uint32_t status = 0;
CONVERT_OP_RAISE(&a, v, context);
if ((result = dec_alloc()) == NULL) {
Py_DECREF(a);
return NULL;
}
mpd_qcopy_negate(MPD(result), MPD(a), &status);
Py_DECREF(a);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
DecCtx_UnaryFunc(mpd_qinvert)
DecCtx_UnaryFunc(mpd_qlogb)
DecCtx_BinaryFunc_NO_CTX(mpd_compare_total)
DecCtx_BinaryFunc_NO_CTX(mpd_compare_total_mag)
static PyObject *
ctx_mpd_qcopy_sign(PyObject *context, PyObject *args)
{
PyObject *v, *w;
PyObject *a, *b;
PyObject *result;
uint32_t status = 0;
if (!PyArg_ParseTuple(args, "OO", &v, &w)) {
return NULL;
}
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
if ((result = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
return NULL;
}
mpd_qcopy_sign(MPD(result), MPD(a), MPD(b), &status);
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(result);
return NULL;
}
return result;
}
DecCtx_BinaryFunc(mpd_qand)
DecCtx_BinaryFunc(mpd_qor)
DecCtx_BinaryFunc(mpd_qxor)
DecCtx_BinaryFunc(mpd_qrotate)
DecCtx_BinaryFunc(mpd_qscaleb)
DecCtx_BinaryFunc(mpd_qshift)
static PyObject *
ctx_iscanonical(PyObject *context UNUSED, PyObject *v)
{
if (!PyDec_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"argument must be a Decimal.");
return NULL;
}
return mpd_iscanonical(MPD(v)) ? Dec_INCREF_TRUE : Dec_INCREF_FALSE;
}
static PyObject *
ctx_canonical(PyObject *context UNUSED, PyObject *v)
{
if (!PyDec_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"argument must be a Decimal.");
return NULL;
}
Py_INCREF(v);
return v;
}
static PyObject *
ctx_mpd_class(PyObject *context, PyObject *v)
{
PyObject *a;
const char *cp;
CONVERT_OP_RAISE(&a, v, context);
cp = mpd_class(MPD(a), CTX(context));
Py_DECREF(a);
return Py_BuildValue("s", cp);
}
static PyObject *
ctx_mpd_qdivmod(PyObject *context, PyObject *args)
{
PyObject *v, *w;
PyObject *a, *b;
PyObject *q, *r;
uint32_t status = 0;
PyObject *ret;
if (!PyArg_ParseTuple(args, "OO", &v, &w)) {
return NULL;
}
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
if ((q = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
return NULL;
}
if ((r = dec_alloc()) == NULL) {
Py_DECREF(a);
Py_DECREF(b);
Py_DECREF(q);
return NULL;
}
mpd_qdivmod(MPD(q), MPD(r), MPD(a), MPD(b), CTX(context), &status);
Py_DECREF(a);
Py_DECREF(b);
if (dec_addstatus(context, status)) {
Py_DECREF(r);
Py_DECREF(q);
return NULL;
}
ret = Py_BuildValue("(OO)", q, r);
Py_DECREF(r);
Py_DECREF(q);
return ret;
}
static PyObject *
ctx_mpd_to_sci(PyObject *context, PyObject *v)
{
PyObject *result;
PyObject *a;
char *s;
CONVERT_OP_RAISE(&a, v, context);
s = mpd_to_sci(MPD(a), CtxCaps(context));
Py_DECREF(a);
if (s == NULL) {
PyErr_NoMemory();
return NULL;
}
result = PyString_FromString(s);
mpd_free(s);
return result;
}
static PyObject *
ctx_mpd_to_eng(PyObject *context, PyObject *v)
{
PyObject *result;
PyObject *a;
char *s;
CONVERT_OP_RAISE(&a, v, context);
s = mpd_to_eng(MPD(a), CtxCaps(context));
Py_DECREF(a);
if (s == NULL) {
PyErr_NoMemory();
return NULL;
}
result = PyString_FromString(s);
mpd_free(s);
return result;
}
static PyObject *
ctx_mpd_radix(PyObject *context UNUSED, PyObject *dummy UNUSED)
{
return dec_mpd_radix(context, dummy);
}
static PyObject *
ctx_mpd_same_quantum(PyObject *context, PyObject *args)
{
PyObject *v, *w;
PyObject *a, *b;
PyObject *result;
if (!PyArg_ParseTuple(args, "OO", &v, &w)) {
return NULL;
}
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
result = mpd_same_quantum(MPD(a), MPD(b)) ?
Dec_INCREF_TRUE : Dec_INCREF_FALSE;
Py_DECREF(a);
Py_DECREF(b);
return result;
}
static PyMethodDef context_methods [] =
{
/* Unary arithmetic functions */
{ "abs", ctx_mpd_qabs, METH_O, doc_ctx_abs },
{ "exp", ctx_mpd_qexp, METH_O, doc_ctx_exp },
{ "invroot", ctx_mpd_qinvroot, METH_O, doc_ctx_invroot },
{ "ln", ctx_mpd_qln, METH_O, doc_ctx_ln },
{ "log10", ctx_mpd_qlog10, METH_O, doc_ctx_log10 },
{ "minus", ctx_mpd_qminus, METH_O, doc_ctx_minus },
{ "next_minus", ctx_mpd_qnext_minus, METH_O, doc_ctx_next_minus },
{ "next_plus", ctx_mpd_qnext_plus, METH_O, doc_ctx_next_plus },
{ "normalize", ctx_mpd_qreduce, METH_O, doc_ctx_normalize }, /* alias for reduce */
{ "plus", ctx_mpd_qplus, METH_O, doc_ctx_plus },
{ "reduce", ctx_mpd_qreduce, METH_O, doc_ctx_reduce },
{ "to_integral", ctx_mpd_qround_to_int, METH_O, doc_ctx_to_integral },
{ "to_integral_exact", ctx_mpd_qround_to_intx, METH_O, doc_ctx_to_integral_exact },
{ "to_integral_value", ctx_mpd_qround_to_int, METH_O, doc_ctx_to_integral_value },
{ "sqrt", ctx_mpd_qsqrt, METH_O, doc_ctx_sqrt },
/* Binary arithmetic functions */
{ "add", ctx_mpd_qadd, METH_VARARGS, doc_ctx_add },
{ "compare", ctx_mpd_qcompare, METH_VARARGS, doc_ctx_compare },
{ "compare_signal", ctx_mpd_qcompare_signal, METH_VARARGS, doc_ctx_compare_signal },
{ "div", ctx_mpd_qdiv, METH_VARARGS, doc_ctx_div }, /* alias for divide */
{ "divide", ctx_mpd_qdiv, METH_VARARGS, doc_ctx_divide },
{ "divide_int", ctx_mpd_qdivint, METH_VARARGS, doc_ctx_divide_int },
{ "divint", ctx_mpd_qdivint, METH_VARARGS, doc_ctx_divint }, /* alias for divide_int */
{ "divmod", ctx_mpd_qdivmod, METH_VARARGS, doc_ctx_divmod },
{ "max", ctx_mpd_qmax, METH_VARARGS, doc_ctx_max },
{ "max_mag", ctx_mpd_qmax_mag, METH_VARARGS, doc_ctx_max_mag },
{ "min", ctx_mpd_qmin, METH_VARARGS, doc_ctx_min },
{ "min_mag", ctx_mpd_qmin_mag, METH_VARARGS, doc_ctx_min_mag },
{ "mul", ctx_mpd_qmul, METH_VARARGS, doc_ctx_mul }, /* alias for multiply */
{ "multiply", ctx_mpd_qmul, METH_VARARGS, doc_ctx_multiply },
{ "next_toward", ctx_mpd_qnext_toward, METH_VARARGS, doc_ctx_next_toward },
{ "pow", ctx_mpd_qpow, METH_VARARGS, doc_ctx_pow }, /* alias for power */
{ "power", ctx_mpd_qpow, METH_VARARGS, doc_ctx_power },
{ "quantize", ctx_mpd_qquantize, METH_VARARGS, doc_ctx_quantize },
{ "rem", ctx_mpd_qrem, METH_VARARGS, doc_ctx_rem }, /* alias for remainder */
{ "remainder", ctx_mpd_qrem, METH_VARARGS, doc_ctx_remainder },
{ "remainder_near", ctx_mpd_qrem_near, METH_VARARGS, doc_ctx_remainder_near },
{ "sub", ctx_mpd_qsub, METH_VARARGS, doc_ctx_sub }, /* alias for subtract */
{ "subtract", ctx_mpd_qsub, METH_VARARGS, doc_ctx_subtract },
/* Ternary arithmetic functions */
{ "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma },
{ "powmod", ctx_mpd_qpowmod, METH_VARARGS, doc_ctx_powmod },
/* No argument */
{ "Etiny", context_getetiny, METH_NOARGS, doc_ctx_Etiny },
{ "Etop", context_getetop, METH_NOARGS, doc_ctx_Etop },
{ "radix", ctx_mpd_radix, METH_NOARGS, doc_ctx_radix },
/* Boolean functions */
{ "is_canonical", ctx_iscanonical, METH_O, doc_ctx_is_canonical },
{ "is_finite", ctx_mpd_isfinite, METH_O, doc_ctx_is_finite },
{ "is_infinite", ctx_mpd_isinfinite, METH_O, doc_ctx_is_infinite },
{ "is_nan", ctx_mpd_isnan, METH_O, doc_ctx_is_nan },
{ "is_normal", ctx_mpd_isnormal, METH_O, doc_ctx_is_normal },
{ "is_qnan", ctx_mpd_isqnan, METH_O, doc_ctx_is_qnan },
{ "is_signed", ctx_mpd_issigned, METH_O, doc_ctx_is_signed },
{ "is_snan", ctx_mpd_issnan, METH_O, doc_ctx_is_snan },
{ "is_subnormal", ctx_mpd_issubnormal, METH_O, doc_ctx_is_subnormal },
{ "is_zero", ctx_mpd_iszero, METH_O, doc_ctx_is_zero },
/* Functions with a single decimal argument */
{ "_apply", PyDecContext_Apply, METH_O, NULL }, /* alias for apply */
{ "apply", PyDecContext_Apply, METH_O, doc_ctx_apply },
{ "canonical", ctx_canonical, METH_O, doc_ctx_canonical },
{ "copy_abs", ctx_mpd_qcopy_abs, METH_O, doc_ctx_copy_abs },
{ "copy_decimal", ctx_copy_decimal, METH_O, doc_ctx_copy_decimal },
{ "copy_negate", ctx_mpd_qcopy_negate, METH_O, doc_ctx_copy_negate },
{ "logb", ctx_mpd_qlogb, METH_O, doc_ctx_logb },
{ "logical_invert", ctx_mpd_qinvert, METH_O, doc_ctx_logical_invert },
{ "number_class", ctx_mpd_class, METH_O, doc_ctx_number_class },
{ "to_sci", ctx_mpd_to_sci, METH_O, doc_ctx_to_sci }, /* alias for to_sci_string */
{ "to_sci_string", ctx_mpd_to_sci, METH_O, doc_ctx_to_sci_string },
{ "to_eng", ctx_mpd_to_eng, METH_O, doc_ctx_to_eng }, /* alias for to_eng_string */
{ "to_eng_string", ctx_mpd_to_eng, METH_O, doc_ctx_to_eng_string },
/* Functions with two decimal arguments */
{ "compare_total", ctx_mpd_compare_total, METH_VARARGS, doc_ctx_compare_total },
{ "compare_total_mag", ctx_mpd_compare_total_mag, METH_VARARGS, doc_ctx_compare_total_mag },
{ "copy_sign", ctx_mpd_qcopy_sign, METH_VARARGS, doc_ctx_copy_sign },
{ "logical_and", ctx_mpd_qand, METH_VARARGS, doc_ctx_logical_and },
{ "logical_or", ctx_mpd_qor, METH_VARARGS, doc_ctx_logical_or },
{ "logical_xor", ctx_mpd_qxor, METH_VARARGS, doc_ctx_logical_xor },
{ "rotate", ctx_mpd_qrotate, METH_VARARGS, doc_ctx_rotate },
{ "same_quantum", ctx_mpd_same_quantum, METH_VARARGS, doc_ctx_same_quantum },
{ "scaleb", ctx_mpd_qscaleb, METH_VARARGS, doc_ctx_scaleb },
{ "shift", ctx_mpd_qshift, METH_VARARGS, doc_ctx_shift },
/* Set context values */
{ "setflags", PyDec_SetStatusFromList, METH_O, doc_ctx_setflags },
{ "settraps", PyDec_SetTrapsFromList, METH_O, doc_ctx_settraps },
{ "clear_flags", context_clear_flags, METH_NOARGS, doc_ctx_clear_flags },
{ "clear_traps", context_clear_traps, METH_NOARGS, doc_ctx_clear_traps },
/* Unsafe set functions with no range checks */
{ "unsafe_setprec", context_unsafe_setprec, METH_O, NULL },
{ "unsafe_setemin", context_unsafe_setemin, METH_O, NULL },
{ "unsafe_setemax", context_unsafe_setemax, METH_O, NULL },
/* Miscellaneous */
{ "__copy__", (PyCFunction)context_copy, METH_NOARGS, NULL },
{ "__reduce__", context_reduce, METH_NOARGS, NULL },
{ "copy", (PyCFunction)context_copy, METH_NOARGS, doc_ctx_copy },
{ "create_decimal", ctx_create_decimal, METH_VARARGS, doc_ctx_create_decimal },
{ "create_decimal_from_float", ctx_from_float, METH_O, doc_ctx_create_decimal_from_float },
{ NULL, NULL, 1 }
};
static PyTypeObject PyDecContext_Type =
{
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"cdecimal.Context", /* tp_name */
sizeof(PyDecContextObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) context_dealloc, /* tp_dealloc */
0, /* tp_print */
(getattrfunc) 0, /* tp_getattr */
(setattrfunc) 0, /* tp_setattr */
(cmpfunc) 0, /* tp_compare */
(reprfunc) context_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc) 0, /* tp_hash */
0, /* tp_call */
(reprfunc) context_repr, /* tp_str */
(getattrofunc) context_getattr, /* tp_getattro */
(setattrofunc) context_setattr, /* tp_setattro */
(PyBufferProcs *) 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
doc_context, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
context_methods, /* tp_methods */
0, /* tp_members */
context_getsets, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
context_init, /* tp_init */
0, /* tp_alloc */
context_new, /* tp_new */
0 /* tp_free */
};
static PyMethodDef cdecimal_methods [] =
{
{ "getcontext", (PyCFunction)PyDec_GetCurrentContext, METH_NOARGS, doc_getcontext},
{ "setcontext", (PyCFunction)PyDec_SetCurrentContext, METH_O, doc_setcontext},
{ "localcontext", (PyCFunction)ctxmanager_new, METH_VARARGS, doc_localcontext},
{ "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context},
{ NULL, NULL, 1, NULL }
};
struct ssize_constmap { const char *name; mpd_ssize_t val; };
static struct ssize_constmap ssize_constants [] = {
{"MAX_PREC", MPD_MAX_PREC},
{"MAX_EMAX", MPD_MAX_EMAX},
{"MIN_EMIN", MPD_MIN_EMIN},
{"MIN_ETINY", MPD_MIN_ETINY},
{NULL}
};
struct int_constmap { const char *name; int val; };
static struct int_constmap int_constants [] = {
/* int constants */
{"DECIMAL32", MPD_DECIMAL32},
{"DECIMAL64", MPD_DECIMAL64},
{"DECIMAL128", MPD_DECIMAL128},
{"IEEE_CONTEXT_MAX_BITS", MPD_IEEE_CONTEXT_MAX_BITS},
{"ROUND_CEILING", MPD_ROUND_CEILING},
{"ROUND_FLOOR", MPD_ROUND_FLOOR},
{"ROUND_UP", MPD_ROUND_UP},
{"ROUND_DOWN", MPD_ROUND_DOWN},
{"ROUND_HALF_UP", MPD_ROUND_HALF_UP},
{"ROUND_HALF_DOWN", MPD_ROUND_HALF_DOWN},
{"ROUND_HALF_EVEN", MPD_ROUND_HALF_EVEN},
{"ROUND_05UP", MPD_ROUND_05UP},
{"ROUND_TRUNC", MPD_ROUND_TRUNC},
/* int condition flags */
{"DecClamped", MPD_Clamped},
{"DecConversionSyntax", MPD_Conversion_syntax},
{"DecDivisionByZero", MPD_Division_by_zero},
{"DecDivisionImpossible", MPD_Division_impossible},
{"DecDivisionUndefined", MPD_Division_undefined},
{"DecFpuError", MPD_Fpu_error},
{"DecInexact", MPD_Inexact},
{"DecInvalidContext", MPD_Invalid_context},
{"DecInvalidOperation", MPD_Invalid_operation},
{"DecIEEEInvalidOperation", MPD_IEEE_Invalid_operation},
{"DecMallocError", MPD_Malloc_error},
{"DecFloatOperation", MPD_Float_operation},
{"DecOverflow", MPD_Overflow},
{"DecRounded", MPD_Rounded},
{"DecSubnormal", MPD_Subnormal},
{"DecUnderflow", MPD_Underflow},
{"DecErrors", MPD_Errors},
{"DecTraps", MPD_Traps},
{NULL}
};
#define CHECK_INT(expr) \
do { if ((expr) < 0) goto error; } while (0)
#define ASSIGN_PTR(result, expr) \
do { result = (expr); if (result == NULL) goto error; } while (0)
#define CHECK_PTR(expr) \
do { if ((expr) == NULL) goto error; } while (0)
PyMODINIT_FUNC
initcdecimal(void)
{
PyObject *m = NULL;
PyObject *_numbers = NULL;
PyObject *_Number = NULL;
PyObject *_collections = NULL;
PyObject *obj = NULL;
#if PY_VERSION_HEX >= 0x02060000
PyObject *ret = NULL;
PyObject *str1 = NULL;
PyObject *str2 = NULL;
PyObject *str3 = NULL;
#endif
DecCondMap *cm;
struct ssize_constmap *ssize_cm;
struct int_constmap *int_cm;
/* Init libmpdec */
mpd_traphandler = dec_traphandler;
mpd_mallocfunc = PyMem_Malloc;
mpd_reallocfunc = PyMem_Realloc;
mpd_callocfunc = mpd_callocfunc_em;
mpd_free = PyMem_Free;
mpd_setminalloc(4);
/* Init types */
PyDec_Type.tp_base = &PyBaseObject_Type;
PyDecContext_Type.tp_base = &PyBaseObject_Type;
PyDecSignalDict_Type.tp_base = &PyDict_Type;
PyDecContextManager_Type.tp_base = &PyBaseObject_Type;
CHECK_INT(PyType_Ready(&PyDec_Type));
CHECK_INT(PyType_Ready(&PyDecContext_Type));
CHECK_INT(PyType_Ready(&PyDecSignalDict_Type));
CHECK_INT(PyType_Ready(&PyDecContextManager_Type));
ASSIGN_PTR(obj, PyString_FromString("cdecimal"));
CHECK_INT(PyDict_SetItemString(PyDec_Type.tp_dict, "__module__", obj));
CHECK_INT(PyDict_SetItemString(PyDecContext_Type.tp_dict,
"__module__", obj));
Py_CLEAR(obj);
/* Imports from other modules */
#if PY_VERSION_HEX >= 0x02060000
ASSIGN_PTR(_numbers, PyImport_ImportModule("numbers"));
ASSIGN_PTR(_Number, PyObject_GetAttrString(_numbers, "Number"));
#if PY_VERSION_HEX >= 0x02080000
ASSIGN_PTR(_Rational, PyObject_GetAttrString(_numbers, "Rational"));
#endif
ASSIGN_PTR(str1, Py_BuildValue("s", "register"));
ASSIGN_PTR(obj, Py_BuildValue("O", &PyDec_Type));
ASSIGN_PTR(ret, PyObject_CallMethodObjArgs(_Number, str1, obj, NULL));
Py_CLEAR(str1);
Py_CLEAR(obj);
Py_CLEAR(ret);
#endif
#if PY_VERSION_HEX >= 0x02060000
ASSIGN_PTR(_collections, PyImport_ImportModule("collections"));
ASSIGN_PTR(str1, Py_BuildValue("s", "namedtuple"));
ASSIGN_PTR(str2, Py_BuildValue("s", "DecimalTuple"));
ASSIGN_PTR(str3, Py_BuildValue("s", "sign digits exponent"));
ASSIGN_PTR(DecimalTuple, PyObject_CallMethodObjArgs(
_collections, str1, str2, str3, NULL));
Py_CLEAR(str1);
Py_CLEAR(str2);
Py_CLEAR(str3);
#endif
/* Create the module */
ASSIGN_PTR(m, Py_InitModule3("cdecimal", cdecimal_methods, doc_cdecimal));
/* Add types to the module */
Py_INCREF(&PyDec_Type);
CHECK_INT(PyModule_AddObject(m, "Decimal", (PyObject *)&PyDec_Type));
Py_INCREF(&PyDecContext_Type);
CHECK_INT(PyModule_AddObject(m, "Context",
(PyObject *)&PyDecContext_Type));
/* Create top level exception */
ASSIGN_PTR(DecimalException, PyErr_NewException(
"cdecimal.DecimalException",
PyExc_ArithmeticError, NULL));
Py_INCREF(DecimalException);
CHECK_INT(PyModule_AddObject(m, "DecimalException", DecimalException));
/* Add exceptions that correspond to IEEE signals */
for (cm = signal_map; cm->name != NULL; cm++) {
cm->dec_cond = PyErr_NewException((char *)cm->fqname,
DecimalException, NULL);
Py_INCREF(cm->dec_cond);
CHECK_INT(PyModule_AddObject(m, cm->name, cm->dec_cond));
}
/*
* Unfortunately, InvalidOperation is a signal that comprises
* several conditions, including InvalidOperation! Naming the
* signal IEEEInvalidOperation would prevent the confusion.
*/
cond_map[0].dec_cond = signal_map[0].dec_cond;
/* Add remaining exceptions, inherit from InvalidOperation */
for (cm = cond_map+1; cm->name != NULL; cm++) {
cm->dec_cond = PyErr_NewException((char *)cm->fqname,
signal_map[0].dec_cond, NULL);
Py_INCREF(cm->dec_cond);
CHECK_INT(PyModule_AddObject(m, cm->name, cm->dec_cond));
}
/* Init default context template first */
ASSIGN_PTR(default_context_template,
PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
Py_INCREF(default_context_template);
CHECK_INT(PyModule_AddObject(m, "DefaultContext",
default_context_template));
#ifdef WITHOUT_THREADS
/* Init module context */
ASSIGN_PTR(module_context,
PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
CHECK_INT(PyModule_AddIntConstant(m, "HAVE_THREADS", 0));
#else
ASSIGN_PTR(tls_context_key, Py_BuildValue("s", "___DECIMAL_CTX__"));
CHECK_INT(PyModule_AddIntConstant(m, "HAVE_THREADS", 1));
#endif
/* Init basic context template */
ASSIGN_PTR(basic_context_template,
PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
init_basic_context(basic_context_template);
Py_INCREF(basic_context_template);
CHECK_INT(PyModule_AddObject(m, "BasicContext",
basic_context_template));
/* Init extended context template */
ASSIGN_PTR(extended_context_template,
PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
init_extended_context(extended_context_template);
Py_INCREF(extended_context_template);
CHECK_INT(PyModule_AddObject(m, "ExtendedContext",
extended_context_template));
/* Init mpd_ssize_t constants */
for (ssize_cm = ssize_constants; ssize_cm->name != NULL; ssize_cm++) {
ASSIGN_PTR(obj, Py_BuildValue(CONV_mpd_ssize_t, ssize_cm->val));
CHECK_INT(PyModule_AddObject(m, ssize_cm->name, obj));
}
/* Init int constants */
for (int_cm = int_constants; int_cm->name != NULL; int_cm++) {
CHECK_INT(PyModule_AddIntConstant(m, int_cm->name,
int_cm->val));
}
return;
error:
Py_XDECREF(_numbers); /* GCOV_NOT_REACHED */
Py_XDECREF(_Number); /* GCOV_NOT_REACHED */
#if PY_VERSION_HEX >= 0x02080000
Py_XDECREF(_Rational); /* GCOV_NOT_REACHED */
#endif
Py_XDECREF(_collections); /* GCOV_NOT_REACHED */
#if PY_VERSION_HEX >= 0x02060000
Py_XDECREF(DecimalTuple); /* GCOV_NOT_REACHED */
#endif
#ifdef WITHOUT_THREADS
Py_XDECREF(module_context); /* GCOV_NOT_REACHED */
#else
Py_XDECREF(default_context_template); /* GCOV_NOT_REACHED */
Py_XDECREF(tls_context_key); /* GCOV_NOT_REACHED */
#endif
Py_XDECREF(basic_context_template); /* GCOV_NOT_REACHED */
Py_XDECREF(extended_context_template); /* GCOV_NOT_REACHED */
Py_XDECREF(m); /* GCOV_NOT_REACHED */
return; /* GCOV_NOT_REACHED */
}