mirror of
https://github.com/python/cpython
synced 2024-09-05 08:17:45 +00:00
![Christian Heimes](/assets/img/avatar_default.png)
setup.py no longer defines Py_BUILD_CORE_MODULE. Instead every module defines the macro before #include "Python.h" unless Py_BUILD_CORE_BUILTIN is already defined. Py_BUILD_CORE_BUILTIN is defined for every module that is built by Modules/Setup. The PR also simplifies Modules/Setup. Makefile and makesetup already define Py_BUILD_CORE_BUILTIN and include Modules/internal for us. Signed-off-by: Christian Heimes <christian@python.org>
5940 lines
172 KiB
C
5940 lines
172 KiB
C
/*
|
|
* Copyright (c) 2008-2012 Stefan Krah. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef Py_BUILD_CORE_BUILTIN
|
|
# define Py_BUILD_CORE_MODULE 1
|
|
#endif
|
|
|
|
#include <Python.h>
|
|
#include "pycore_pystate.h" // _PyThreadState_GET()
|
|
#include "complexobject.h"
|
|
#include "mpdecimal.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "docstrings.h"
|
|
|
|
|
|
#if !defined(MPD_VERSION_HEX) || MPD_VERSION_HEX < 0x02050000
|
|
#error "libmpdec version >= 2.5.0 required"
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Type sizes with assertions in mpdecimal.h and pyport.h:
|
|
* sizeof(size_t) == sizeof(Py_ssize_t)
|
|
* sizeof(size_t) == sizeof(mpd_uint_t) == sizeof(mpd_ssize_t)
|
|
*/
|
|
|
|
#ifdef TEST_COVERAGE
|
|
#undef Py_LOCAL_INLINE
|
|
#define Py_LOCAL_INLINE Py_LOCAL
|
|
#endif
|
|
|
|
#define MPD_Float_operation MPD_Not_implemented
|
|
|
|
#define BOUNDS_CHECK(x, MIN, MAX) x = (x < MIN || MAX < x) ? MAX : x
|
|
|
|
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
|
|
#define UNUSED __attribute__((unused))
|
|
#else
|
|
#define UNUSED
|
|
#endif
|
|
|
|
/* _Py_DEC_MINALLOC >= MPD_MINALLOC */
|
|
#define _Py_DEC_MINALLOC 4
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
Py_hash_t hash;
|
|
mpd_t dec;
|
|
mpd_uint_t data[_Py_DEC_MINALLOC];
|
|
} PyDecObject;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
uint32_t *flags;
|
|
} PyDecSignalDictObject;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
mpd_context_t ctx;
|
|
PyObject *traps;
|
|
PyObject *flags;
|
|
int capitals;
|
|
PyThreadState *tstate;
|
|
} 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_IS_TYPE(v, &PyDec_Type)
|
|
#define PyDec_Check(v) PyObject_TypeCheck(v, &PyDec_Type)
|
|
#define PyDecSignalDict_Check(v) Py_IS_TYPE(v, PyDecSignalDict_Type)
|
|
#define PyDecContext_Check(v) PyObject_TypeCheck(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)
|
|
|
|
|
|
Py_LOCAL_INLINE(PyObject *)
|
|
incr_true(void)
|
|
{
|
|
Py_INCREF(Py_True);
|
|
return Py_True;
|
|
}
|
|
|
|
Py_LOCAL_INLINE(PyObject *)
|
|
incr_false(void)
|
|
{
|
|
Py_INCREF(Py_False);
|
|
return Py_False;
|
|
}
|
|
|
|
|
|
#ifndef WITH_DECIMAL_CONTEXTVAR
|
|
/* Key for thread state dictionary */
|
|
static PyObject *tls_context_key = NULL;
|
|
/* Invariant: NULL or the most recently accessed thread local context */
|
|
static PyDecContextObject *cached_context = NULL;
|
|
#else
|
|
static PyObject *current_context_var = 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;
|
|
|
|
|
|
/* Error codes for functions that return signals or conditions */
|
|
#define DEC_INVALID_SIGNALS (MPD_Max_status+1U)
|
|
#define DEC_ERR_OCCURRED (DEC_INVALID_SIGNALS<<1)
|
|
#define DEC_ERRORS (DEC_INVALID_SIGNALS|DEC_ERR_OCCURRED)
|
|
|
|
typedef struct {
|
|
const char *name; /* condition or signal name */
|
|
const char *fqname; /* fully qualified name */
|
|
uint32_t flag; /* libmpdec flag */
|
|
PyObject *ex; /* corresponding exception */
|
|
} DecCondMap;
|
|
|
|
/* Top level Exception; inherits from ArithmeticError */
|
|
static PyObject *DecimalException = NULL;
|
|
|
|
/* Exceptions that correspond to IEEE signals */
|
|
#define SUBNORMAL 5
|
|
#define INEXACT 6
|
|
#define ROUNDED 7
|
|
#define SIGNAL_MAP_LEN 9
|
|
static DecCondMap signal_map[] = {
|
|
{"InvalidOperation", "decimal.InvalidOperation", MPD_IEEE_Invalid_operation, NULL},
|
|
{"FloatOperation", "decimal.FloatOperation", MPD_Float_operation, NULL},
|
|
{"DivisionByZero", "decimal.DivisionByZero", MPD_Division_by_zero, NULL},
|
|
{"Overflow", "decimal.Overflow", MPD_Overflow, NULL},
|
|
{"Underflow", "decimal.Underflow", MPD_Underflow, NULL},
|
|
{"Subnormal", "decimal.Subnormal", MPD_Subnormal, NULL},
|
|
{"Inexact", "decimal.Inexact", MPD_Inexact, NULL},
|
|
{"Rounded", "decimal.Rounded", MPD_Rounded, NULL},
|
|
{"Clamped", "decimal.Clamped", MPD_Clamped, NULL},
|
|
{NULL}
|
|
};
|
|
|
|
/* Exceptions that inherit from InvalidOperation */
|
|
static DecCondMap cond_map[] = {
|
|
{"InvalidOperation", "decimal.InvalidOperation", MPD_Invalid_operation, NULL},
|
|
{"ConversionSyntax", "decimal.ConversionSyntax", MPD_Conversion_syntax, NULL},
|
|
{"DivisionImpossible", "decimal.DivisionImpossible", MPD_Division_impossible, NULL},
|
|
{"DivisionUndefined", "decimal.DivisionUndefined", MPD_Division_undefined, NULL},
|
|
{"InvalidContext", "decimal.InvalidContext", MPD_Invalid_context, NULL},
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
{"MallocError", "decimal.MallocError", MPD_Malloc_error, NULL},
|
|
#endif
|
|
{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",
|
|
};
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
#define _PY_DEC_ROUND_GUARD MPD_ROUND_GUARD
|
|
#else
|
|
#define _PY_DEC_ROUND_GUARD (MPD_ROUND_GUARD-1)
|
|
#endif
|
|
static PyObject *round_map[_PY_DEC_ROUND_GUARD];
|
|
|
|
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]";
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
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]";
|
|
#endif
|
|
|
|
static int
|
|
value_error_int(const char *mesg)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, mesg);
|
|
return -1;
|
|
}
|
|
|
|
#ifdef CONFIG_32
|
|
static PyObject *
|
|
value_error_ptr(const char *mesg)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, mesg);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
type_error_int(const char *mesg)
|
|
{
|
|
PyErr_SetString(PyExc_TypeError, mesg);
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
runtime_error_int(const char *mesg)
|
|
{
|
|
PyErr_SetString(PyExc_RuntimeError, mesg);
|
|
return -1;
|
|
}
|
|
#define INTERNAL_ERROR_INT(funcname) \
|
|
return runtime_error_int("internal error in " funcname)
|
|
|
|
static PyObject *
|
|
runtime_error_ptr(const char *mesg)
|
|
{
|
|
PyErr_SetString(PyExc_RuntimeError, mesg);
|
|
return NULL;
|
|
}
|
|
#define INTERNAL_ERROR_PTR(funcname) \
|
|
return runtime_error_ptr("internal error in " funcname)
|
|
|
|
static void
|
|
dec_traphandler(mpd_context_t *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->flag) {
|
|
return cm->ex;
|
|
}
|
|
}
|
|
|
|
INTERNAL_ERROR_PTR("flags_as_exception"); /* GCOV_NOT_REACHED */
|
|
}
|
|
|
|
Py_LOCAL_INLINE(uint32_t)
|
|
exception_as_flag(PyObject *ex)
|
|
{
|
|
DecCondMap *cm;
|
|
|
|
for (cm = signal_map; cm->name != NULL; cm++) {
|
|
if (cm->ex == ex) {
|
|
return cm->flag;
|
|
}
|
|
}
|
|
|
|
PyErr_SetString(PyExc_KeyError, invalid_signals_err);
|
|
return DEC_INVALID_SIGNALS;
|
|
}
|
|
|
|
static PyObject *
|
|
flags_as_list(uint32_t flags)
|
|
{
|
|
PyObject *list;
|
|
DecCondMap *cm;
|
|
|
|
list = PyList_New(0);
|
|
if (list == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
for (cm = cond_map; cm->name != NULL; cm++) {
|
|
if (flags&cm->flag) {
|
|
if (PyList_Append(list, cm->ex) < 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
}
|
|
for (cm = signal_map+1; cm->name != NULL; cm++) {
|
|
if (flags&cm->flag) {
|
|
if (PyList_Append(list, cm->ex) < 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
}
|
|
|
|
return list;
|
|
|
|
error:
|
|
Py_DECREF(list);
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
signals_as_list(uint32_t flags)
|
|
{
|
|
PyObject *list;
|
|
DecCondMap *cm;
|
|
|
|
list = PyList_New(0);
|
|
if (list == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
for (cm = signal_map; cm->name != NULL; cm++) {
|
|
if (flags&cm->flag) {
|
|
if (PyList_Append(list, cm->ex) < 0) {
|
|
Py_DECREF(list);
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static uint32_t
|
|
list_as_flags(PyObject *list)
|
|
{
|
|
PyObject *item;
|
|
uint32_t flags, x;
|
|
Py_ssize_t n, j;
|
|
|
|
assert(PyList_Check(list));
|
|
|
|
n = PyList_Size(list);
|
|
flags = 0;
|
|
for (j = 0; j < n; j++) {
|
|
item = PyList_GetItem(list, j);
|
|
x = exception_as_flag(item);
|
|
if (x & DEC_ERRORS) {
|
|
return x;
|
|
}
|
|
flags |= x;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
static PyObject *
|
|
flags_as_dict(uint32_t flags)
|
|
{
|
|
DecCondMap *cm;
|
|
PyObject *dict;
|
|
|
|
dict = PyDict_New();
|
|
if (dict == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
for (cm = signal_map; cm->name != NULL; cm++) {
|
|
PyObject *b = flags&cm->flag ? Py_True : Py_False;
|
|
if (PyDict_SetItem(dict, cm->ex, b) < 0) {
|
|
Py_DECREF(dict);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return dict;
|
|
}
|
|
|
|
static uint32_t
|
|
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 DEC_INVALID_SIGNALS;
|
|
}
|
|
|
|
if (PyDict_Size(val) != SIGNAL_MAP_LEN) {
|
|
PyErr_SetString(PyExc_KeyError,
|
|
"invalid signal dict");
|
|
return DEC_INVALID_SIGNALS;
|
|
}
|
|
|
|
for (cm = signal_map; cm->name != NULL; cm++) {
|
|
b = PyDict_GetItemWithError(val, cm->ex);
|
|
if (b == NULL) {
|
|
if (PyErr_Occurred()) {
|
|
return DEC_ERR_OCCURRED;
|
|
}
|
|
PyErr_SetString(PyExc_KeyError,
|
|
"invalid signal dict");
|
|
return DEC_INVALID_SIGNALS;
|
|
}
|
|
|
|
x = PyObject_IsTrue(b);
|
|
if (x < 0) {
|
|
return DEC_ERR_OCCURRED;
|
|
}
|
|
if (x == 1) {
|
|
flags |= cm->flag;
|
|
}
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
static uint32_t
|
|
long_as_flags(PyObject *v)
|
|
{
|
|
long x;
|
|
|
|
x = PyLong_AsLong(v);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return DEC_ERR_OCCURRED;
|
|
}
|
|
if (x < 0 || x > (long)MPD_Max_status) {
|
|
PyErr_SetString(PyExc_TypeError, invalid_flags_err);
|
|
return DEC_INVALID_SIGNALS;
|
|
}
|
|
|
|
return x;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
dec_addstatus(PyObject *context, uint32_t status)
|
|
{
|
|
mpd_context_t *ctx = CTX(context);
|
|
|
|
ctx->status |= status;
|
|
if (status & (ctx->traps|MPD_Malloc_error)) {
|
|
PyObject *ex, *siglist;
|
|
|
|
if (status & MPD_Malloc_error) {
|
|
PyErr_NoMemory();
|
|
return 1;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static int
|
|
getround(PyObject *v)
|
|
{
|
|
int i;
|
|
|
|
if (PyUnicode_Check(v)) {
|
|
for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {
|
|
if (v == round_map[i]) {
|
|
return i;
|
|
}
|
|
}
|
|
for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {
|
|
if (PyUnicode_Compare(v, round_map[i]) == 0) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return type_error_int(invalid_rounding_err);
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/* SignalDict Object */
|
|
/******************************************************************************/
|
|
|
|
/* The SignalDict is a MutableMapping that provides access to the
|
|
mpd_context_t flags, which reside in the context object. When a
|
|
new context is created, context.traps and context.flags are
|
|
initialized to new SignalDicts. Once a SignalDict is tied to
|
|
a context, it cannot be deleted. */
|
|
|
|
static int
|
|
signaldict_init(PyObject *self, PyObject *args UNUSED, PyObject *kwds UNUSED)
|
|
{
|
|
SdFlagAddr(self) = NULL;
|
|
return 0;
|
|
}
|
|
|
|
static Py_ssize_t
|
|
signaldict_len(PyObject *self UNUSED)
|
|
{
|
|
return SIGNAL_MAP_LEN;
|
|
}
|
|
|
|
static PyObject *SignalTuple;
|
|
static PyObject *
|
|
signaldict_iter(PyObject *self UNUSED)
|
|
{
|
|
return PyTuple_Type.tp_iter(SignalTuple);
|
|
}
|
|
|
|
static PyObject *
|
|
signaldict_getitem(PyObject *self, PyObject *key)
|
|
{
|
|
uint32_t flag;
|
|
|
|
flag = exception_as_flag(key);
|
|
if (flag & DEC_ERRORS) {
|
|
return NULL;
|
|
}
|
|
|
|
return SdFlags(self)&flag ? incr_true() : incr_false();
|
|
}
|
|
|
|
static int
|
|
signaldict_setitem(PyObject *self, PyObject *key, PyObject *value)
|
|
{
|
|
uint32_t flag;
|
|
int x;
|
|
|
|
if (value == NULL) {
|
|
return value_error_int("signal keys cannot be deleted");
|
|
}
|
|
|
|
flag = exception_as_flag(key);
|
|
if (flag & DEC_ERRORS) {
|
|
return -1;
|
|
}
|
|
|
|
x = PyObject_IsTrue(value);
|
|
if (x < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (x == 1) {
|
|
SdFlags(self) |= flag;
|
|
}
|
|
else {
|
|
SdFlags(self) &= ~flag;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
signaldict_repr(PyObject *self)
|
|
{
|
|
DecCondMap *cm;
|
|
const char *n[SIGNAL_MAP_LEN]; /* name */
|
|
const char *b[SIGNAL_MAP_LEN]; /* bool */
|
|
int i;
|
|
|
|
assert(SIGNAL_MAP_LEN == 9);
|
|
|
|
for (cm=signal_map, i=0; cm->name != NULL; cm++, i++) {
|
|
n[i] = cm->fqname;
|
|
b[i] = SdFlags(self)&cm->flag ? "True" : "False";
|
|
}
|
|
return PyUnicode_FromFormat(
|
|
"{<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s, "
|
|
"<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s, "
|
|
"<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s}",
|
|
n[0], b[0], n[1], b[1], n[2], b[2],
|
|
n[3], b[3], n[4], b[4], n[5], b[5],
|
|
n[6], b[6], n[7], b[7], n[8], b[8]);
|
|
}
|
|
|
|
static PyObject *
|
|
signaldict_richcompare(PyObject *v, PyObject *w, int op)
|
|
{
|
|
PyObject *res = Py_NotImplemented;
|
|
|
|
assert(PyDecSignalDict_Check(v));
|
|
|
|
if (op == Py_EQ || op == Py_NE) {
|
|
if (PyDecSignalDict_Check(w)) {
|
|
res = (SdFlags(v)==SdFlags(w)) ^ (op==Py_NE) ? Py_True : Py_False;
|
|
}
|
|
else if (PyDict_Check(w)) {
|
|
uint32_t flags = dict_as_flags(w);
|
|
if (flags & DEC_ERRORS) {
|
|
if (flags & DEC_INVALID_SIGNALS) {
|
|
/* non-comparable: Py_NotImplemented */
|
|
PyErr_Clear();
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
res = (SdFlags(v)==flags) ^ (op==Py_NE) ? Py_True : Py_False;
|
|
}
|
|
}
|
|
}
|
|
|
|
Py_INCREF(res);
|
|
return res;
|
|
}
|
|
|
|
static PyObject *
|
|
signaldict_copy(PyObject *self, PyObject *args UNUSED)
|
|
{
|
|
return flags_as_dict(SdFlags(self));
|
|
}
|
|
|
|
|
|
static PyMappingMethods signaldict_as_mapping = {
|
|
(lenfunc)signaldict_len, /* mp_length */
|
|
(binaryfunc)signaldict_getitem, /* mp_subscript */
|
|
(objobjargproc)signaldict_setitem /* mp_ass_subscript */
|
|
};
|
|
|
|
static PyMethodDef signaldict_methods[] = {
|
|
{ "copy", (PyCFunction)signaldict_copy, METH_NOARGS, NULL},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
|
|
static PyTypeObject PyDecSignalDictMixin_Type =
|
|
{
|
|
PyVarObject_HEAD_INIT(0, 0)
|
|
"decimal.SignalDictMixin", /* tp_name */
|
|
sizeof(PyDecSignalDictObject), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
0, /* tp_dealloc */
|
|
0, /* tp_vectorcall_offset */
|
|
(getattrfunc) 0, /* tp_getattr */
|
|
(setattrfunc) 0, /* tp_setattr */
|
|
0, /* tp_as_async */
|
|
(reprfunc) signaldict_repr, /* tp_repr */
|
|
0, /* tp_as_number */
|
|
0, /* tp_as_sequence */
|
|
&signaldict_as_mapping, /* tp_as_mapping */
|
|
PyObject_HashNotImplemented, /* tp_hash */
|
|
0, /* tp_call */
|
|
(reprfunc) 0, /* tp_str */
|
|
PyObject_GenericGetAttr, /* tp_getattro */
|
|
(setattrofunc) 0, /* tp_setattro */
|
|
(PyBufferProcs *) 0, /* tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
0, /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
signaldict_richcompare, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
(getiterfunc)signaldict_iter, /* tp_iter */
|
|
0, /* tp_iternext */
|
|
signaldict_methods, /* tp_methods */
|
|
0, /* tp_members */
|
|
0, /* tp_getset */
|
|
0, /* tp_base */
|
|
0, /* tp_dict */
|
|
0, /* tp_descr_get */
|
|
0, /* tp_descr_set */
|
|
0, /* tp_dictoffset */
|
|
(initproc)signaldict_init, /* tp_init */
|
|
0, /* tp_alloc */
|
|
PyType_GenericNew, /* tp_new */
|
|
};
|
|
|
|
|
|
/******************************************************************************/
|
|
/* Context Object, Part 1 */
|
|
/******************************************************************************/
|
|
|
|
#define Dec_CONTEXT_GET_SSIZE(mem) \
|
|
static PyObject * \
|
|
context_get##mem(PyObject *self, void *closure UNUSED) \
|
|
{ \
|
|
return PyLong_FromSsize_t(mpd_get##mem(CTX(self))); \
|
|
}
|
|
|
|
#define Dec_CONTEXT_GET_ULONG(mem) \
|
|
static PyObject * \
|
|
context_get##mem(PyObject *self, void *closure UNUSED) \
|
|
{ \
|
|
return PyLong_FromUnsignedLong(mpd_get##mem(CTX(self))); \
|
|
}
|
|
|
|
Dec_CONTEXT_GET_SSIZE(prec)
|
|
Dec_CONTEXT_GET_SSIZE(emax)
|
|
Dec_CONTEXT_GET_SSIZE(emin)
|
|
Dec_CONTEXT_GET_SSIZE(clamp)
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
Dec_CONTEXT_GET_ULONG(traps)
|
|
Dec_CONTEXT_GET_ULONG(status)
|
|
#endif
|
|
|
|
static PyObject *
|
|
context_getround(PyObject *self, void *closure UNUSED)
|
|
{
|
|
int i = mpd_getround(CTX(self));
|
|
|
|
Py_INCREF(round_map[i]);
|
|
return round_map[i];
|
|
}
|
|
|
|
static PyObject *
|
|
context_getcapitals(PyObject *self, void *closure UNUSED)
|
|
{
|
|
return PyLong_FromLong(CtxCaps(self));
|
|
}
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
static PyObject *
|
|
context_getallcr(PyObject *self, void *closure UNUSED)
|
|
{
|
|
return PyLong_FromLong(mpd_getcr(CTX(self)));
|
|
}
|
|
#endif
|
|
|
|
static PyObject *
|
|
context_getetiny(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
return PyLong_FromSsize_t(mpd_etiny(CTX(self)));
|
|
}
|
|
|
|
static PyObject *
|
|
context_getetop(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
return PyLong_FromSsize_t(mpd_etop(CTX(self)));
|
|
}
|
|
|
|
static int
|
|
context_setprec(PyObject *self, PyObject *value, void *closure UNUSED)
|
|
{
|
|
mpd_context_t *ctx;
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsetprec(ctx, x)) {
|
|
return value_error_int(
|
|
"valid range for prec is [1, MAX_PREC]");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
context_setemin(PyObject *self, PyObject *value, void *closure UNUSED)
|
|
{
|
|
mpd_context_t *ctx;
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsetemin(ctx, x)) {
|
|
return value_error_int(
|
|
"valid range for Emin is [MIN_EMIN, 0]");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
context_setemax(PyObject *self, PyObject *value, void *closure UNUSED)
|
|
{
|
|
mpd_context_t *ctx;
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsetemax(ctx, x)) {
|
|
return value_error_int(
|
|
"valid range for Emax is [0, MAX_EMAX]");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_32
|
|
static PyObject *
|
|
context_unsafe_setprec(PyObject *self, PyObject *value)
|
|
{
|
|
mpd_context_t *ctx = CTX(self);
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return NULL;
|
|
}
|
|
|
|
if (x < 1 || x > 1070000000L) {
|
|
return value_error_ptr(
|
|
"valid range for unsafe prec is [1, 1070000000]");
|
|
}
|
|
|
|
ctx->prec = x;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
context_unsafe_setemin(PyObject *self, PyObject *value)
|
|
{
|
|
mpd_context_t *ctx = CTX(self);
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return NULL;
|
|
}
|
|
|
|
if (x < -1070000000L || x > 0) {
|
|
return value_error_ptr(
|
|
"valid range for unsafe emin is [-1070000000, 0]");
|
|
}
|
|
|
|
ctx->emin = x;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
context_unsafe_setemax(PyObject *self, PyObject *value)
|
|
{
|
|
mpd_context_t *ctx = CTX(self);
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return NULL;
|
|
}
|
|
|
|
if (x < 0 || x > 1070000000L) {
|
|
return value_error_ptr(
|
|
"valid range for unsafe emax is [0, 1070000000]");
|
|
}
|
|
|
|
ctx->emax = x;
|
|
Py_RETURN_NONE;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
context_setround(PyObject *self, PyObject *value, void *closure UNUSED)
|
|
{
|
|
mpd_context_t *ctx;
|
|
int x;
|
|
|
|
x = getround(value);
|
|
if (x == -1) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsetround(ctx, x)) {
|
|
INTERNAL_ERROR_INT("context_setround"); /* GCOV_NOT_REACHED */
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
context_setcapitals(PyObject *self, PyObject *value, void *closure UNUSED)
|
|
{
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && PyErr_Occurred()) {
|
|
return -1;
|
|
}
|
|
|
|
if (x != 0 && x != 1) {
|
|
return value_error_int(
|
|
"valid values for capitals are 0 or 1");
|
|
}
|
|
CtxCaps(self) = (int)x;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
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 & DEC_ERRORS) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsettraps(ctx, flags)) {
|
|
INTERNAL_ERROR_INT("context_settraps");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
context_settraps_list(PyObject *self, PyObject *value)
|
|
{
|
|
mpd_context_t *ctx;
|
|
uint32_t flags;
|
|
|
|
flags = list_as_flags(value);
|
|
if (flags & DEC_ERRORS) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsettraps(ctx, flags)) {
|
|
INTERNAL_ERROR_INT("context_settraps_list");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
context_settraps_dict(PyObject *self, PyObject *value)
|
|
{
|
|
mpd_context_t *ctx;
|
|
uint32_t flags;
|
|
|
|
if (PyDecSignalDict_Check(value)) {
|
|
flags = SdFlags(value);
|
|
}
|
|
else {
|
|
flags = dict_as_flags(value);
|
|
if (flags & DEC_ERRORS) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsettraps(ctx, flags)) {
|
|
INTERNAL_ERROR_INT("context_settraps_dict");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
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 & DEC_ERRORS) {
|
|
return -1;
|
|
}
|
|
|
|
ctx = CTX(self);
|
|
if (!mpd_qsetstatus(ctx, flags)) {
|
|
INTERNAL_ERROR_INT("context_setstatus");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
context_setstatus_list(PyObject *self, PyObject *value)
|
|
{
|
|
mpd_context_t *ctx;
|
|
uint32_t flags;
|
|
|
|
flags = list_as_flags(value);
|
|
if (flags & DEC_ERRORS) {
|
|
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;
|
|
|
|
if (PyDecSignalDict_Check(value)) {
|
|
flags = SdFlags(value);
|
|
}
|
|
else {
|
|
flags = dict_as_flags(value);
|
|
if (flags & DEC_ERRORS) {
|
|
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 = PyLong_AsSsize_t(value);
|
|
if (x == -1 && 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;
|
|
}
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
static int
|
|
context_setallcr(PyObject *self, PyObject *value, void *closure UNUSED)
|
|
{
|
|
mpd_context_t *ctx;
|
|
mpd_ssize_t x;
|
|
|
|
x = PyLong_AsSsize_t(value);
|
|
if (x == -1 && 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;
|
|
}
|
|
#endif
|
|
|
|
static PyObject *
|
|
context_getattr(PyObject *self, PyObject *name)
|
|
{
|
|
PyObject *retval;
|
|
|
|
if (PyUnicode_Check(name)) {
|
|
if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
|
|
retval = ((PyDecContextObject *)self)->traps;
|
|
Py_INCREF(retval);
|
|
return retval;
|
|
}
|
|
if (PyUnicode_CompareWithASCIIString(name, "flags") == 0) {
|
|
retval = ((PyDecContextObject *)self)->flags;
|
|
Py_INCREF(retval);
|
|
return retval;
|
|
}
|
|
}
|
|
|
|
return PyObject_GenericGetAttr(self, name);
|
|
}
|
|
|
|
static int
|
|
context_setattr(PyObject *self, PyObject *name, PyObject *value)
|
|
{
|
|
if (value == NULL) {
|
|
PyErr_SetString(PyExc_AttributeError,
|
|
"context attributes cannot be deleted");
|
|
return -1;
|
|
}
|
|
|
|
if (PyUnicode_Check(name)) {
|
|
if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
|
|
return context_settraps_dict(self, value);
|
|
}
|
|
if (PyUnicode_CompareWithASCIIString(name, "flags") == 0) {
|
|
return context_setstatus_dict(self, value);
|
|
}
|
|
}
|
|
|
|
return PyObject_GenericSetAttr(self, name, value);
|
|
}
|
|
|
|
static PyObject *
|
|
context_clear_traps(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
CTX(self)->traps = 0;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
context_clear_flags(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
CTX(self)->status = 0;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
#define DEC_DFLT_EMAX 999999
|
|
#define DEC_DFLT_EMIN -999999
|
|
|
|
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 PyObject *
|
|
context_new(PyTypeObject *type, PyObject *args UNUSED, PyObject *kwds UNUSED)
|
|
{
|
|
PyDecContextObject *self = NULL;
|
|
mpd_context_t *ctx;
|
|
|
|
if (type == &PyDecContext_Type) {
|
|
self = PyObject_New(PyDecContextObject, &PyDecContext_Type);
|
|
}
|
|
else {
|
|
self = (PyDecContextObject *)type->tp_alloc(type, 0);
|
|
}
|
|
|
|
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);
|
|
|
|
if (default_context_template) {
|
|
*ctx = *CTX(default_context_template);
|
|
}
|
|
else {
|
|
*ctx = dflt_ctx;
|
|
}
|
|
|
|
SdFlagAddr(self->traps) = &ctx->traps;
|
|
SdFlagAddr(self->flags) = &ctx->status;
|
|
|
|
CtxCaps(self) = 1;
|
|
self->tstate = NULL;
|
|
|
|
return (PyObject *)self;
|
|
}
|
|
|
|
static void
|
|
context_dealloc(PyDecContextObject *self)
|
|
{
|
|
#ifndef WITH_DECIMAL_CONTEXTVAR
|
|
if (self == cached_context) {
|
|
cached_context = NULL;
|
|
}
|
|
#endif
|
|
|
|
Py_XDECREF(self->traps);
|
|
Py_XDECREF(self->flags);
|
|
Py_TYPE(self)->tp_free(self);
|
|
}
|
|
|
|
static int
|
|
context_init(PyObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {
|
|
"prec", "rounding", "Emin", "Emax", "capitals", "clamp",
|
|
"flags", "traps", NULL
|
|
};
|
|
PyObject *prec = Py_None;
|
|
PyObject *rounding = Py_None;
|
|
PyObject *emin = Py_None;
|
|
PyObject *emax = Py_None;
|
|
PyObject *capitals = Py_None;
|
|
PyObject *clamp = Py_None;
|
|
PyObject *status = Py_None;
|
|
PyObject *traps = Py_None;
|
|
int ret;
|
|
|
|
assert(PyTuple_Check(args));
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(
|
|
args, kwds,
|
|
"|OOOOOOOO", kwlist,
|
|
&prec, &rounding, &emin, &emax, &capitals, &clamp, &status, &traps
|
|
)) {
|
|
return -1;
|
|
}
|
|
|
|
if (prec != Py_None && context_setprec(self, prec, NULL) < 0) {
|
|
return -1;
|
|
}
|
|
if (rounding != Py_None && context_setround(self, rounding, NULL) < 0) {
|
|
return -1;
|
|
}
|
|
if (emin != Py_None && context_setemin(self, emin, NULL) < 0) {
|
|
return -1;
|
|
}
|
|
if (emax != Py_None && context_setemax(self, emax, NULL) < 0) {
|
|
return -1;
|
|
}
|
|
if (capitals != Py_None && context_setcapitals(self, capitals, NULL) < 0) {
|
|
return -1;
|
|
}
|
|
if (clamp != Py_None && context_setclamp(self, clamp, NULL) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (traps != Py_None) {
|
|
if (PyList_Check(traps)) {
|
|
ret = context_settraps_list(self, traps);
|
|
}
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
else if (PyLong_Check(traps)) {
|
|
ret = context_settraps(self, traps, NULL);
|
|
}
|
|
#endif
|
|
else {
|
|
ret = context_settraps_dict(self, traps);
|
|
}
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
}
|
|
if (status != Py_None) {
|
|
if (PyList_Check(status)) {
|
|
ret = context_setstatus_list(self, status);
|
|
}
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
else if (PyLong_Check(status)) {
|
|
ret = context_setstatus(self, status, NULL);
|
|
}
|
|
#endif
|
|
else {
|
|
ret = context_setstatus_dict(self, status);
|
|
}
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
context_repr(PyDecContextObject *self)
|
|
{
|
|
mpd_context_t *ctx;
|
|
char flags[MPD_MAX_SIGNAL_LIST];
|
|
char traps[MPD_MAX_SIGNAL_LIST];
|
|
int n, mem;
|
|
|
|
assert(PyDecContext_Check(self));
|
|
ctx = CTX(self);
|
|
|
|
mem = MPD_MAX_SIGNAL_LIST;
|
|
n = mpd_lsnprint_signals(flags, mem, ctx->status, dec_signal_string);
|
|
if (n < 0 || n >= mem) {
|
|
INTERNAL_ERROR_PTR("context_repr");
|
|
}
|
|
|
|
n = mpd_lsnprint_signals(traps, mem, ctx->traps, dec_signal_string);
|
|
if (n < 0 || n >= mem) {
|
|
INTERNAL_ERROR_PTR("context_repr");
|
|
}
|
|
|
|
return PyUnicode_FromFormat(
|
|
"Context(prec=%zd, rounding=%s, Emin=%zd, Emax=%zd, "
|
|
"capitals=%d, clamp=%d, flags=%s, traps=%s)",
|
|
ctx->prec, mpd_round_string[ctx->round], ctx->emin, ctx->emax,
|
|
self->capitals, ctx->clamp, flags, traps);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
/* 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 = PyLong_AsSsize_t(v);
|
|
if (bits == -1 && 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;
|
|
}
|
|
#endif
|
|
|
|
static PyObject *
|
|
context_copy(PyObject *self, PyObject *args UNUSED)
|
|
{
|
|
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);
|
|
|
|
flags = signals_as_list(ctx->status);
|
|
if (flags == NULL) {
|
|
return NULL;
|
|
}
|
|
traps = signals_as_list(ctx->traps);
|
|
if (traps == NULL) {
|
|
Py_DECREF(flags);
|
|
return NULL;
|
|
}
|
|
|
|
ret = Py_BuildValue(
|
|
"O(nsnniiOO)",
|
|
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 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},
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
{ "_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},
|
|
#endif
|
|
{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 (obj == Py_None) { \
|
|
CURRENT_CONTEXT(obj); \
|
|
} \
|
|
else if (!PyDecContext_Check(obj)) { \
|
|
PyErr_SetString(PyExc_TypeError, \
|
|
"optional argument must be a context"); \
|
|
return NULL; \
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/* Global, thread local and temporary contexts */
|
|
/******************************************************************************/
|
|
|
|
/*
|
|
* Thread local storage currently has a speed penalty of about 4%.
|
|
* All functions that map Python's arithmetic operators to mpdecimal
|
|
* functions have to look up the current context for each and every
|
|
* operation.
|
|
*/
|
|
|
|
#ifndef WITH_DECIMAL_CONTEXTVAR
|
|
/* Get the context from the thread state dictionary. */
|
|
static PyObject *
|
|
current_context_from_dict(void)
|
|
{
|
|
PyThreadState *tstate = _PyThreadState_GET();
|
|
#ifdef Py_DEBUG
|
|
// The caller must hold the GIL
|
|
_Py_EnsureTstateNotNULL(tstate);
|
|
#endif
|
|
|
|
PyObject *dict = _PyThreadState_GetDict(tstate);
|
|
if (dict == NULL) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"cannot get thread state");
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *tl_context = PyDict_GetItemWithError(dict, tls_context_key);
|
|
if (tl_context != NULL) {
|
|
/* We already have a thread local context. */
|
|
CONTEXT_CHECK(tl_context);
|
|
}
|
|
else {
|
|
if (PyErr_Occurred()) {
|
|
return NULL;
|
|
}
|
|
|
|
/* Set up a new thread local context. */
|
|
tl_context = context_copy(default_context_template, NULL);
|
|
if (tl_context == NULL) {
|
|
return NULL;
|
|
}
|
|
CTX(tl_context)->status = 0;
|
|
|
|
if (PyDict_SetItem(dict, tls_context_key, tl_context) < 0) {
|
|
Py_DECREF(tl_context);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(tl_context);
|
|
}
|
|
|
|
/* Cache the context of the current thread, assuming that it
|
|
* will be accessed several times before a thread switch. */
|
|
cached_context = (PyDecContextObject *)tl_context;
|
|
cached_context->tstate = tstate;
|
|
|
|
/* Borrowed reference with refcount==1 */
|
|
return tl_context;
|
|
}
|
|
|
|
/* Return borrowed reference to thread local context. */
|
|
static PyObject *
|
|
current_context(void)
|
|
{
|
|
PyThreadState *tstate = _PyThreadState_GET();
|
|
if (cached_context && cached_context->tstate == tstate) {
|
|
return (PyObject *)cached_context;
|
|
}
|
|
|
|
return current_context_from_dict();
|
|
}
|
|
|
|
/* ctxobj := borrowed reference to the current context */
|
|
#define CURRENT_CONTEXT(ctxobj) \
|
|
ctxobj = current_context(); \
|
|
if (ctxobj == NULL) { \
|
|
return NULL; \
|
|
}
|
|
|
|
/* Return a new reference to the current context */
|
|
static PyObject *
|
|
PyDec_GetCurrentContext(PyObject *self UNUSED, PyObject *args UNUSED)
|
|
{
|
|
PyObject *context;
|
|
|
|
context = current_context();
|
|
if (context == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
Py_INCREF(context);
|
|
return context;
|
|
}
|
|
|
|
/* 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) {
|
|
v = context_copy(v, NULL);
|
|
if (v == NULL) {
|
|
return NULL;
|
|
}
|
|
CTX(v)->status = 0;
|
|
}
|
|
else {
|
|
Py_INCREF(v);
|
|
}
|
|
|
|
cached_context = NULL;
|
|
if (PyDict_SetItem(dict, tls_context_key, v) < 0) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
|
|
Py_DECREF(v);
|
|
Py_RETURN_NONE;
|
|
}
|
|
#else
|
|
static PyObject *
|
|
init_current_context(void)
|
|
{
|
|
PyObject *tl_context = context_copy(default_context_template, NULL);
|
|
if (tl_context == NULL) {
|
|
return NULL;
|
|
}
|
|
CTX(tl_context)->status = 0;
|
|
|
|
PyObject *tok = PyContextVar_Set(current_context_var, tl_context);
|
|
if (tok == NULL) {
|
|
Py_DECREF(tl_context);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(tok);
|
|
|
|
return tl_context;
|
|
}
|
|
|
|
static inline PyObject *
|
|
current_context(void)
|
|
{
|
|
PyObject *tl_context;
|
|
if (PyContextVar_Get(current_context_var, NULL, &tl_context) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
if (tl_context != NULL) {
|
|
return tl_context;
|
|
}
|
|
|
|
return init_current_context();
|
|
}
|
|
|
|
/* ctxobj := borrowed reference to the current context */
|
|
#define CURRENT_CONTEXT(ctxobj) \
|
|
ctxobj = current_context(); \
|
|
if (ctxobj == NULL) { \
|
|
return NULL; \
|
|
} \
|
|
Py_DECREF(ctxobj);
|
|
|
|
/* Return a new reference to the current context */
|
|
static PyObject *
|
|
PyDec_GetCurrentContext(PyObject *self UNUSED, PyObject *args UNUSED)
|
|
{
|
|
return current_context();
|
|
}
|
|
|
|
/* Set the thread local 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) {
|
|
v = context_copy(v, NULL);
|
|
if (v == NULL) {
|
|
return NULL;
|
|
}
|
|
CTX(v)->status = 0;
|
|
}
|
|
else {
|
|
Py_INCREF(v);
|
|
}
|
|
|
|
PyObject *tok = PyContextVar_Set(current_context_var, v);
|
|
Py_DECREF(v);
|
|
if (tok == NULL) {
|
|
return NULL;
|
|
}
|
|
Py_DECREF(tok);
|
|
|
|
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, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"ctx", NULL};
|
|
PyDecContextManagerObject *self;
|
|
PyObject *local = Py_None;
|
|
PyObject *global;
|
|
|
|
CURRENT_CONTEXT(global);
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &local)) {
|
|
return NULL;
|
|
}
|
|
if (local == Py_None) {
|
|
local = global;
|
|
}
|
|
else if (!PyDecContext_Check(local)) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"optional argument must be a context");
|
|
return NULL;
|
|
}
|
|
|
|
self = PyObject_New(PyDecContextManagerObject,
|
|
&PyDecContextManager_Type);
|
|
if (self == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
self->local = context_copy(local, NULL);
|
|
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_Free(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 =
|
|
{
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"decimal.ContextManager", /* tp_name */
|
|
sizeof(PyDecContextManagerObject), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
(destructor) ctxmanager_dealloc, /* tp_dealloc */
|
|
0, /* tp_vectorcall_offset */
|
|
(getattrfunc) 0, /* tp_getattr */
|
|
(setattrfunc) 0, /* tp_setattr */
|
|
0, /* tp_as_async */
|
|
(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)
|
|
{
|
|
PyDecObject *dec;
|
|
|
|
if (type == &PyDec_Type) {
|
|
dec = PyObject_New(PyDecObject, &PyDec_Type);
|
|
}
|
|
else {
|
|
dec = (PyDecObject *)type->tp_alloc(type, 0);
|
|
}
|
|
if (dec == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
dec->hash = -1;
|
|
|
|
MPD(dec)->flags = MPD_STATIC|MPD_STATIC_DATA;
|
|
MPD(dec)->exp = 0;
|
|
MPD(dec)->digits = 0;
|
|
MPD(dec)->len = 0;
|
|
MPD(dec)->alloc = _Py_DEC_MINALLOC;
|
|
MPD(dec)->data = dec->data;
|
|
|
|
return (PyObject *)dec;
|
|
}
|
|
#define dec_alloc() PyDecType_New(&PyDec_Type)
|
|
|
|
static void
|
|
dec_dealloc(PyObject *dec)
|
|
{
|
|
mpd_del(MPD(dec));
|
|
Py_TYPE(dec)->tp_free(dec);
|
|
}
|
|
|
|
|
|
/******************************************************************************/
|
|
/* Conversions to Decimal */
|
|
/******************************************************************************/
|
|
|
|
Py_LOCAL_INLINE(int)
|
|
is_space(enum PyUnicode_Kind kind, const void *data, Py_ssize_t pos)
|
|
{
|
|
Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
|
|
return Py_UNICODE_ISSPACE(ch);
|
|
}
|
|
|
|
/* Return the ASCII representation of a numeric Unicode string. The numeric
|
|
string may contain ascii characters in the range [1, 127], any Unicode
|
|
space and any unicode digit. If strip_ws is true, leading and trailing
|
|
whitespace is stripped. If ignore_underscores is true, underscores are
|
|
ignored.
|
|
|
|
Return NULL if malloc fails and an empty string if invalid characters
|
|
are found. */
|
|
static char *
|
|
numeric_as_ascii(const PyObject *u, int strip_ws, int ignore_underscores)
|
|
{
|
|
enum PyUnicode_Kind kind;
|
|
const void *data;
|
|
Py_UCS4 ch;
|
|
char *res, *cp;
|
|
Py_ssize_t j, len;
|
|
int d;
|
|
|
|
if (PyUnicode_READY(u) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
kind = PyUnicode_KIND(u);
|
|
data = PyUnicode_DATA(u);
|
|
len = PyUnicode_GET_LENGTH(u);
|
|
|
|
cp = res = PyMem_Malloc(len+1);
|
|
if (res == NULL) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
j = 0;
|
|
if (strip_ws) {
|
|
while (len > 0 && is_space(kind, data, len-1)) {
|
|
len--;
|
|
}
|
|
while (j < len && is_space(kind, data, j)) {
|
|
j++;
|
|
}
|
|
}
|
|
|
|
for (; j < len; j++) {
|
|
ch = PyUnicode_READ(kind, data, j);
|
|
if (ignore_underscores && ch == '_') {
|
|
continue;
|
|
}
|
|
if (0 < ch && ch <= 127) {
|
|
*cp++ = ch;
|
|
continue;
|
|
}
|
|
if (Py_UNICODE_ISSPACE(ch)) {
|
|
*cp++ = ' ';
|
|
continue;
|
|
}
|
|
d = Py_UNICODE_TODECIMAL(ch);
|
|
if (d < 0) {
|
|
/* empty string triggers ConversionSyntax */
|
|
*res = '\0';
|
|
return res;
|
|
}
|
|
*cp++ = '0' + d;
|
|
}
|
|
*cp = '\0';
|
|
return res;
|
|
}
|
|
|
|
/* 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|MPD_Clamped)) {
|
|
/* 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;
|
|
}
|
|
|
|
/* 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 = numeric_as_ascii(u, 0, 0);
|
|
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;
|
|
|
|
s = numeric_as_ascii(u, 1, 1);
|
|
if (s == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
dec = PyDecType_FromCStringExact(type, s, context);
|
|
PyMem_Free(s);
|
|
return dec;
|
|
}
|
|
|
|
/* Set PyDecObject from triple without any error checking. */
|
|
Py_LOCAL_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 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 *v, PyObject *context)
|
|
{
|
|
PyObject *dec;
|
|
uint32_t status = 0;
|
|
|
|
if (!PyLong_Check(v)) {
|
|
PyErr_SetString(PyExc_TypeError, "argument must be an integer");
|
|
return NULL;
|
|
}
|
|
|
|
dec = dec_from_long(type, v, 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 *v,
|
|
PyObject *context)
|
|
{
|
|
PyObject *dec;
|
|
uint32_t status = 0;
|
|
mpd_context_t maxctx;
|
|
|
|
if (!PyLong_Check(v)) {
|
|
PyErr_SetString(PyExc_TypeError, "argument must be an integer");
|
|
return NULL;
|
|
}
|
|
|
|
mpd_maxcontext(&maxctx);
|
|
dec = dec_from_long(type, v, &maxctx, &status);
|
|
if (dec == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (status & (MPD_Inexact|MPD_Rounded|MPD_Clamped)) {
|
|
/* 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;
|
|
}
|
|
|
|
/* External C-API functions */
|
|
static binaryfunc _py_long_multiply;
|
|
static binaryfunc _py_long_floor_divide;
|
|
static ternaryfunc _py_long_power;
|
|
static unaryfunc _py_float_abs;
|
|
static PyCFunction _py_long_bit_length;
|
|
static PyCFunction _py_float_as_integer_ratio;
|
|
|
|
/* 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;
|
|
mpd_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 (PyLong_Check(v)) {
|
|
return PyDecType_FromLongExact(type, v, context);
|
|
}
|
|
if (!PyFloat_Check(v)) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"argument must be int or 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 = _py_float_abs(v);
|
|
if (tmp == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* float as integer ratio: numerator/denominator */
|
|
n_d = _py_float_as_integer_ratio(tmp, NULL);
|
|
Py_DECREF(tmp);
|
|
if (n_d == NULL) {
|
|
return NULL;
|
|
}
|
|
n = PyTuple_GET_ITEM(n_d, 0);
|
|
d = PyTuple_GET_ITEM(n_d, 1);
|
|
|
|
tmp = _py_long_bit_length(d, NULL);
|
|
if (tmp == NULL) {
|
|
Py_DECREF(n_d);
|
|
return NULL;
|
|
}
|
|
k = PyLong_AsSsize_t(tmp);
|
|
Py_DECREF(tmp);
|
|
if (k == -1 && PyErr_Occurred()) {
|
|
Py_DECREF(n_d);
|
|
return NULL;
|
|
}
|
|
k--;
|
|
|
|
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);
|
|
mpd_del(d2);
|
|
Py_DECREF(dec);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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);
|
|
return NULL;
|
|
}
|
|
/* 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;
|
|
}
|
|
|
|
/* Return a new PyDecObject or a subtype from a Decimal. */
|
|
static PyObject *
|
|
PyDecType_FromDecimalExact(PyTypeObject *type, PyObject *v, PyObject *context)
|
|
{
|
|
PyObject *dec;
|
|
uint32_t status = 0;
|
|
|
|
if (type == &PyDec_Type && PyDec_CheckExact(v)) {
|
|
Py_INCREF(v);
|
|
return v;
|
|
}
|
|
|
|
dec = PyDecType_New(type);
|
|
if (dec == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
mpd_qcopy(MPD(dec), MPD(v), &status);
|
|
if (dec_addstatus(context, status)) {
|
|
Py_DECREF(dec);
|
|
return NULL;
|
|
}
|
|
|
|
return dec;
|
|
}
|
|
|
|
static PyObject *
|
|
sequence_as_tuple(PyObject *v, PyObject *ex, const char *mesg)
|
|
{
|
|
if (PyTuple_Check(v)) {
|
|
Py_INCREF(v);
|
|
return v;
|
|
}
|
|
if (PyList_Check(v)) {
|
|
return PyList_AsTuple(v);
|
|
}
|
|
|
|
PyErr_SetString(ex, mesg);
|
|
return NULL;
|
|
}
|
|
|
|
/* Return a new C string representation of a DecimalTuple. */
|
|
static char *
|
|
dectuple_as_str(PyObject *dectuple)
|
|
{
|
|
PyObject *digits = NULL, *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 is_infinite = 0;
|
|
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 (!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 (sign == -1 && 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 (PyUnicode_Check(tmp)) {
|
|
/* special */
|
|
if (PyUnicode_CompareWithASCIIString(tmp, "F") == 0) {
|
|
strcat(sign_special, "Inf");
|
|
is_infinite = 1;
|
|
}
|
|
else if (PyUnicode_CompareWithASCIIString(tmp, "n") == 0) {
|
|
strcat(sign_special, "NaN");
|
|
}
|
|
else if (PyUnicode_CompareWithASCIIString(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 (!PyLong_Check(tmp)) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"exponent must be an integer");
|
|
goto error;
|
|
}
|
|
exp = PyLong_AsSsize_t(tmp);
|
|
if (exp == -1 && PyErr_Occurred()) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/* coefficient */
|
|
digits = sequence_as_tuple(PyTuple_GET_ITEM(dectuple, 1), PyExc_ValueError,
|
|
"coefficient must be a tuple of digits");
|
|
if (digits == NULL) {
|
|
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 (!PyLong_Check(tmp)) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"coefficient must be a tuple of digits");
|
|
goto error;
|
|
}
|
|
l = PyLong_AsLong(tmp);
|
|
if (l == -1 && PyErr_Occurred()) {
|
|
goto error;
|
|
}
|
|
if (l < 0 || l > 9) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"coefficient must be a tuple of digits");
|
|
goto error;
|
|
}
|
|
if (is_infinite) {
|
|
/* accept but ignore any well-formed coefficient for compatibility
|
|
with decimal.py */
|
|
continue;
|
|
}
|
|
*cp++ = (char)l + '0';
|
|
}
|
|
*cp = '\0';
|
|
|
|
if (sign_special[1] == '\0') {
|
|
/* not a special number */
|
|
*cp++ = 'E';
|
|
n = snprintf(cp, MPD_EXPDIGITS+2, "%" PRI_mpd_ssize_t, exp);
|
|
if (n < 0 || n >= MPD_EXPDIGITS+2) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"internal error in dec_sequence_as_str");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
Py_XDECREF(digits);
|
|
return decstring;
|
|
|
|
|
|
error:
|
|
Py_XDECREF(digits);
|
|
if (decstring) PyMem_Free(decstring);
|
|
return NULL;
|
|
}
|
|
|
|
/* 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, PyExc_TypeError,
|
|
"argument must be a tuple or list");
|
|
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, PyExc_TypeError,
|
|
"argument must be a tuple or list");
|
|
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_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_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 *type, PyObject *pyfloat)
|
|
{
|
|
PyObject *context;
|
|
PyObject *result;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
result = PyDecType_FromFloatExact(&PyDec_Type, pyfloat, context);
|
|
if (type != (PyObject *)&PyDec_Type && result != NULL) {
|
|
Py_SETREF(result, PyObject_CallFunctionObjArgs(type, result, NULL));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* 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)) {
|
|
return PyDecType_FromDecimalExact(type, v, context);
|
|
}
|
|
else if (PyUnicode_Check(v)) {
|
|
return PyDecType_FromUnicodeExactWS(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);
|
|
}
|
|
else if (PyFloat_Check(v)) {
|
|
if (dec_addstatus(context, MPD_Float_operation)) {
|
|
return NULL;
|
|
}
|
|
return PyDecType_FromFloatExact(type, v, context);
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"conversion from %s to Decimal is not supported",
|
|
Py_TYPE(v)->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 (PyUnicode_Check(v)) {
|
|
return PyDec_FromUnicode(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);
|
|
}
|
|
else if (PyFloat_Check(v)) {
|
|
if (dec_addstatus(context, MPD_Float_operation)) {
|
|
return NULL;
|
|
}
|
|
return PyDec_FromFloat(v, context);
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"conversion from %s to Decimal is not supported",
|
|
Py_TYPE(v)->tp_name);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static PyObject *
|
|
dec_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"value", "context", NULL};
|
|
PyObject *v = NULL;
|
|
PyObject *context = Py_None;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
|
|
&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
|
|
Py_LOCAL_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 (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",
|
|
Py_TYPE(v)->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 */
|
|
/******************************************************************************/
|
|
|
|
/* 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,
|
|
"exact conversion for comparison failed");
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/* 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 (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;
|
|
*wcmp = PyDec_FromFloatExact(w, context);
|
|
}
|
|
}
|
|
else if (PyComplex_Check(w) && (op == Py_EQ || op == Py_NE)) {
|
|
Py_complex c = PyComplex_AsCComplex(w);
|
|
if (c.real == -1.0 && 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 {
|
|
int is_rational = PyObject_IsInstance(w, Rational);
|
|
if (is_rational < 0) {
|
|
*wcmp = NULL;
|
|
}
|
|
else if (is_rational > 0) {
|
|
*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);
|
|
}
|
|
}
|
|
}
|
|
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 */
|
|
/******************************************************************************/
|
|
|
|
static PyObject *
|
|
unicode_fromascii(const char *s, Py_ssize_t size)
|
|
{
|
|
PyObject *res;
|
|
|
|
res = PyUnicode_New(size, 127);
|
|
if (res == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(PyUnicode_1BYTE_DATA(res), s, size);
|
|
return res;
|
|
}
|
|
|
|
/* PyDecObject as a string. The default module context is only used for
|
|
the value of 'capitals'. */
|
|
static PyObject *
|
|
dec_str(PyObject *dec)
|
|
{
|
|
PyObject *res, *context;
|
|
mpd_ssize_t size;
|
|
char *cp;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
size = mpd_to_sci_size(&cp, MPD(dec), CtxCaps(context));
|
|
if (size < 0) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
res = unicode_fromascii(cp, size);
|
|
mpd_free(cp);
|
|
return res;
|
|
}
|
|
|
|
/* Representation of a PyDecObject. */
|
|
static PyObject *
|
|
dec_repr(PyObject *dec)
|
|
{
|
|
PyObject *res, *context;
|
|
char *cp;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
cp = mpd_to_sci(MPD(dec), CtxCaps(context));
|
|
if (cp == NULL) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
res = PyUnicode_FromFormat("Decimal('%s')", cp);
|
|
mpd_free(cp);
|
|
return res;
|
|
}
|
|
|
|
/* Return a duplicate of src, copy embedded null characters. */
|
|
static char *
|
|
dec_strdup(const char *src, Py_ssize_t size)
|
|
{
|
|
char *dest = PyMem_Malloc(size+1);
|
|
if (dest == NULL) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(dest, src, size);
|
|
dest[size] = '\0';
|
|
return dest;
|
|
}
|
|
|
|
static void
|
|
dec_replace_fillchar(char *dest)
|
|
{
|
|
while (*dest != '\0') {
|
|
if (*dest == '\xff') *dest = '\0';
|
|
dest++;
|
|
}
|
|
}
|
|
|
|
/* Convert decimal_point or thousands_sep, which may be multibyte or in
|
|
the range [128, 255], to a UTF8 string. */
|
|
static PyObject *
|
|
dotsep_as_utf8(const char *s)
|
|
{
|
|
PyObject *utf8;
|
|
PyObject *tmp;
|
|
wchar_t buf[2];
|
|
size_t n;
|
|
|
|
n = mbstowcs(buf, s, 2);
|
|
if (n != 1) { /* Issue #7442 */
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"invalid decimal point or unsupported "
|
|
"combination of LC_CTYPE and LC_NUMERIC");
|
|
return NULL;
|
|
}
|
|
tmp = PyUnicode_FromWideChar(buf, n);
|
|
if (tmp == NULL) {
|
|
return NULL;
|
|
}
|
|
utf8 = PyUnicode_AsUTF8String(tmp);
|
|
Py_DECREF(tmp);
|
|
return utf8;
|
|
}
|
|
|
|
static int
|
|
dict_get_item_string(PyObject *dict, const char *key, PyObject **valueobj, const char **valuestr)
|
|
{
|
|
*valueobj = NULL;
|
|
PyObject *keyobj = PyUnicode_FromString(key);
|
|
if (keyobj == NULL) {
|
|
return -1;
|
|
}
|
|
PyObject *value = PyDict_GetItemWithError(dict, keyobj);
|
|
Py_DECREF(keyobj);
|
|
if (value == NULL) {
|
|
if (PyErr_Occurred()) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
value = PyUnicode_AsUTF8String(value);
|
|
if (value == NULL) {
|
|
return -1;
|
|
}
|
|
*valueobj = value;
|
|
*valuestr = PyBytes_AS_STRING(value);
|
|
return 0;
|
|
}
|
|
|
|
/* 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 *fmtarg;
|
|
PyObject *context;
|
|
mpd_spec_t spec;
|
|
char *fmt;
|
|
char *decstring = NULL;
|
|
uint32_t status = 0;
|
|
int replace_fillchar = 0;
|
|
Py_ssize_t size;
|
|
|
|
|
|
CURRENT_CONTEXT(context);
|
|
if (!PyArg_ParseTuple(args, "O|O", &fmtarg, &override)) {
|
|
return NULL;
|
|
}
|
|
|
|
if (PyUnicode_Check(fmtarg)) {
|
|
fmt = (char *)PyUnicode_AsUTF8AndSize(fmtarg, &size);
|
|
if (fmt == NULL) {
|
|
return NULL;
|
|
}
|
|
if (size > 0 && fmt[0] == '\0') {
|
|
/* NUL fill character: must be replaced with a valid UTF-8 char
|
|
before calling mpd_parse_fmt_str(). */
|
|
replace_fillchar = 1;
|
|
fmt = dec_strdup(fmt, size);
|
|
if (fmt == NULL) {
|
|
return NULL;
|
|
}
|
|
fmt[0] = '_';
|
|
}
|
|
}
|
|
else {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"format arg must be str");
|
|
return NULL;
|
|
}
|
|
|
|
if (!mpd_parse_fmt_str(&spec, fmt, CtxCaps(context))) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"invalid format string");
|
|
goto finish;
|
|
}
|
|
if (replace_fillchar) {
|
|
/* In order to avoid clobbering parts of UTF-8 thousands separators or
|
|
decimal points when the substitution is reversed later, the actual
|
|
placeholder must be an invalid UTF-8 byte. */
|
|
spec.fill[0] = '\xff';
|
|
spec.fill[1] = '\0';
|
|
}
|
|
|
|
if (override) {
|
|
/* Values for decimal_point, thousands_sep and grouping can
|
|
be explicitly specified in the override dict. These values
|
|
take precedence over the values obtained from localeconv()
|
|
in mpd_parse_fmt_str(). The feature is not documented and
|
|
is only used in test_decimal. */
|
|
if (!PyDict_Check(override)) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"optional argument must be a dict");
|
|
goto finish;
|
|
}
|
|
if (dict_get_item_string(override, "decimal_point", &dot, &spec.dot) ||
|
|
dict_get_item_string(override, "thousands_sep", &sep, &spec.sep) ||
|
|
dict_get_item_string(override, "grouping", &grouping, &spec.grouping))
|
|
{
|
|
goto finish;
|
|
}
|
|
if (mpd_validate_lconv(&spec) < 0) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"invalid override dict");
|
|
goto finish;
|
|
}
|
|
}
|
|
else {
|
|
size_t n = strlen(spec.dot);
|
|
if (n > 1 || (n == 1 && !isascii((unsigned char)spec.dot[0]))) {
|
|
/* fix locale dependent non-ascii characters */
|
|
dot = dotsep_as_utf8(spec.dot);
|
|
if (dot == NULL) {
|
|
goto finish;
|
|
}
|
|
spec.dot = PyBytes_AS_STRING(dot);
|
|
}
|
|
n = strlen(spec.sep);
|
|
if (n > 1 || (n == 1 && !isascii((unsigned char)spec.sep[0]))) {
|
|
/* fix locale dependent non-ascii characters */
|
|
sep = dotsep_as_utf8(spec.sep);
|
|
if (sep == NULL) {
|
|
goto finish;
|
|
}
|
|
spec.sep = PyBytes_AS_STRING(sep);
|
|
}
|
|
}
|
|
|
|
|
|
decstring = mpd_qformat_spec(MPD(dec), &spec, CTX(context), &status);
|
|
if (decstring == NULL) {
|
|
if (status & MPD_Malloc_error) {
|
|
PyErr_NoMemory();
|
|
}
|
|
else {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"format specification exceeds internal limits of _decimal");
|
|
}
|
|
goto finish;
|
|
}
|
|
size = strlen(decstring);
|
|
if (replace_fillchar) {
|
|
dec_replace_fillchar(decstring);
|
|
}
|
|
|
|
result = PyUnicode_DecodeUTF8(decstring, size, NULL);
|
|
|
|
|
|
finish:
|
|
Py_XDECREF(grouping);
|
|
Py_XDECREF(sep);
|
|
Py_XDECREF(dot);
|
|
if (replace_fillchar) PyMem_Free(fmt);
|
|
if (decstring) mpd_free(decstring);
|
|
return result;
|
|
}
|
|
|
|
/* Return a PyLongObject from a PyDecObject, using the specified rounding
|
|
* mode. The context precision is not observed. */
|
|
static PyObject *
|
|
dec_as_long(PyObject *dec, PyObject *context, int round)
|
|
{
|
|
PyLongObject *pylong;
|
|
digit *ob_digit;
|
|
size_t 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;
|
|
}
|
|
|
|
x = mpd_qnew();
|
|
if (x == 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;
|
|
}
|
|
|
|
status = 0;
|
|
ob_digit = NULL;
|
|
#if PYLONG_BITS_IN_DIGIT == 30
|
|
n = mpd_qexport_u32(&ob_digit, 0, PyLong_BASE, x, &status);
|
|
#elif PYLONG_BITS_IN_DIGIT == 15
|
|
n = mpd_qexport_u16(&ob_digit, 0, PyLong_BASE, x, &status);
|
|
#else
|
|
#error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
|
|
#endif
|
|
|
|
if (n == SIZE_MAX) {
|
|
PyErr_NoMemory();
|
|
mpd_del(x);
|
|
return NULL;
|
|
}
|
|
|
|
assert(n > 0);
|
|
pylong = _PyLong_New(n);
|
|
if (pylong == NULL) {
|
|
mpd_free(ob_digit);
|
|
mpd_del(x);
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(pylong->ob_digit, ob_digit, n * sizeof(digit));
|
|
mpd_free(ob_digit);
|
|
|
|
i = n;
|
|
while ((i > 0) && (pylong->ob_digit[i-1] == 0)) {
|
|
i--;
|
|
}
|
|
|
|
Py_SET_SIZE(pylong, i);
|
|
if (mpd_isnegative(x) && !mpd_iszero(x)) {
|
|
Py_SET_SIZE(pylong, -i);
|
|
}
|
|
|
|
mpd_del(x);
|
|
return (PyObject *) pylong;
|
|
}
|
|
|
|
/* Convert a Decimal to its exact integer ratio representation. */
|
|
static PyObject *
|
|
dec_as_integer_ratio(PyObject *self, PyObject *args UNUSED)
|
|
{
|
|
PyObject *numerator = NULL;
|
|
PyObject *denominator = NULL;
|
|
PyObject *exponent = NULL;
|
|
PyObject *result = NULL;
|
|
PyObject *tmp;
|
|
mpd_ssize_t exp;
|
|
PyObject *context;
|
|
uint32_t status = 0;
|
|
|
|
if (mpd_isspecial(MPD(self))) {
|
|
if (mpd_isnan(MPD(self))) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"cannot convert NaN to integer ratio");
|
|
}
|
|
else {
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
"cannot convert Infinity to integer ratio");
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CURRENT_CONTEXT(context);
|
|
|
|
tmp = dec_alloc();
|
|
if (tmp == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (!mpd_qcopy(MPD(tmp), MPD(self), &status)) {
|
|
Py_DECREF(tmp);
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
exp = mpd_iszero(MPD(tmp)) ? 0 : MPD(tmp)->exp;
|
|
MPD(tmp)->exp = 0;
|
|
|
|
/* context and rounding are unused here: the conversion is exact */
|
|
numerator = dec_as_long(tmp, context, MPD_ROUND_FLOOR);
|
|
Py_DECREF(tmp);
|
|
if (numerator == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
exponent = PyLong_FromSsize_t(exp < 0 ? -exp : exp);
|
|
if (exponent == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
tmp = PyLong_FromLong(10);
|
|
if (tmp == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
Py_SETREF(exponent, _py_long_power(tmp, exponent, Py_None));
|
|
Py_DECREF(tmp);
|
|
if (exponent == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
if (exp >= 0) {
|
|
Py_SETREF(numerator, _py_long_multiply(numerator, exponent));
|
|
if (numerator == NULL) {
|
|
goto error;
|
|
}
|
|
denominator = PyLong_FromLong(1);
|
|
if (denominator == NULL) {
|
|
goto error;
|
|
}
|
|
}
|
|
else {
|
|
denominator = exponent;
|
|
exponent = NULL;
|
|
tmp = _PyLong_GCD(numerator, denominator);
|
|
if (tmp == NULL) {
|
|
goto error;
|
|
}
|
|
Py_SETREF(numerator, _py_long_floor_divide(numerator, tmp));
|
|
Py_SETREF(denominator, _py_long_floor_divide(denominator, tmp));
|
|
Py_DECREF(tmp);
|
|
if (numerator == NULL || denominator == NULL) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
result = PyTuple_Pack(2, numerator, denominator);
|
|
|
|
|
|
error:
|
|
Py_XDECREF(exponent);
|
|
Py_XDECREF(denominator);
|
|
Py_XDECREF(numerator);
|
|
return result;
|
|
}
|
|
|
|
static PyObject *
|
|
PyDec_ToIntegralValue(PyObject *dec, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"rounding", "context", NULL};
|
|
PyObject *result;
|
|
PyObject *rounding = Py_None;
|
|
PyObject *context = Py_None;
|
|
uint32_t status = 0;
|
|
mpd_context_t workctx;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
|
|
&rounding, &context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
|
|
workctx = *CTX(context);
|
|
if (rounding != Py_None) {
|
|
int round = getround(rounding);
|
|
if (round < 0) {
|
|
return NULL;
|
|
}
|
|
if (!mpd_qsetround(&workctx, round)) {
|
|
INTERNAL_ERROR_PTR("PyDec_ToIntegralValue"); /* GCOV_NOT_REACHED */
|
|
}
|
|
}
|
|
|
|
result = dec_alloc();
|
|
if (result == 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 *rounding = Py_None;
|
|
PyObject *context = Py_None;
|
|
uint32_t status = 0;
|
|
mpd_context_t workctx;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
|
|
&rounding, &context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
|
|
workctx = *CTX(context);
|
|
if (rounding != Py_None) {
|
|
int round = getround(rounding);
|
|
if (round < 0) {
|
|
return NULL;
|
|
}
|
|
if (!mpd_qsetround(&workctx, round)) {
|
|
INTERNAL_ERROR_PTR("PyDec_ToIntegralExact"); /* GCOV_NOT_REACHED */
|
|
}
|
|
}
|
|
|
|
result = dec_alloc();
|
|
if (result == 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 (mpd_isnan(MPD(dec))) {
|
|
if (mpd_issnan(MPD(dec))) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"cannot convert signaling NaN to float");
|
|
return NULL;
|
|
}
|
|
if (mpd_isnegative(MPD(dec))) {
|
|
s = PyUnicode_FromString("-nan");
|
|
}
|
|
else {
|
|
s = PyUnicode_FromString("nan");
|
|
}
|
|
}
|
|
else {
|
|
s = dec_str(dec);
|
|
}
|
|
|
|
if (s == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
f = PyFloat_FromString(s);
|
|
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 (!PyLong_Check(x)) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"optional arg must be an integer");
|
|
return NULL;
|
|
}
|
|
|
|
y = PyLong_AsSsize_t(x);
|
|
if (y == -1 && PyErr_Occurred()) {
|
|
return NULL;
|
|
}
|
|
result = dec_alloc();
|
|
if (result == 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_long(dec, context, MPD_ROUND_HALF_EVEN);
|
|
}
|
|
}
|
|
|
|
static PyTypeObject *DecimalTuple = NULL;
|
|
/* 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;
|
|
|
|
|
|
x = mpd_qncopy(MPD(dec));
|
|
if (x == NULL) {
|
|
PyErr_NoMemory();
|
|
goto out;
|
|
}
|
|
|
|
sign = PyLong_FromUnsignedLong(mpd_sign(MPD(dec)));
|
|
if (sign == NULL) {
|
|
goto out;
|
|
}
|
|
|
|
if (mpd_isinfinite(x)) {
|
|
expt = PyUnicode_FromString("F");
|
|
if (expt == NULL) {
|
|
goto out;
|
|
}
|
|
/* decimal.py has non-compliant infinity payloads. */
|
|
coeff = Py_BuildValue("(i)", 0);
|
|
if (coeff == NULL) {
|
|
goto out;
|
|
}
|
|
}
|
|
else {
|
|
if (mpd_isnan(x)) {
|
|
expt = PyUnicode_FromString(mpd_isqnan(x)?"n":"N");
|
|
}
|
|
else {
|
|
expt = PyLong_FromSsize_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);
|
|
coeff = PyTuple_New(intlen);
|
|
if (coeff == NULL) {
|
|
goto out;
|
|
}
|
|
|
|
for (i = 0; i < intlen; i++) {
|
|
tmp = PyLong_FromLong(intstring[i]-'0');
|
|
if (tmp == NULL) {
|
|
goto out;
|
|
}
|
|
PyTuple_SET_ITEM(coeff, i, tmp);
|
|
}
|
|
}
|
|
else {
|
|
coeff = PyTuple_New(0);
|
|
if (coeff == NULL) {
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
|
|
result = PyObject_CallFunctionObjArgs((PyObject *)DecimalTuple,
|
|
sign, coeff, expt, NULL);
|
|
|
|
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 *self, PyObject *other) \
|
|
{ \
|
|
PyObject *a, *b; \
|
|
PyObject *result; \
|
|
PyObject *context; \
|
|
uint32_t status = 0; \
|
|
\
|
|
CURRENT_CONTEXT(context) ; \
|
|
CONVERT_BINOP(&a, &b, self, other, 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)) ? incr_true() : incr_false(); \
|
|
}
|
|
|
|
/* Boolean function with an optional context arg. */
|
|
#define Dec_BoolFuncVA(MPDFUNC) \
|
|
static PyObject * \
|
|
dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds) \
|
|
{ \
|
|
static char *kwlist[] = {"context", NULL}; \
|
|
PyObject *context = Py_None; \
|
|
\
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, \
|
|
&context)) { \
|
|
return NULL; \
|
|
} \
|
|
CONTEXT_CHECK_VA(context); \
|
|
\
|
|
return MPDFUNC(MPD(self), CTX(context)) ? incr_true() : incr_false(); \
|
|
}
|
|
|
|
/* Unary function with an optional context arg. */
|
|
#define Dec_UnaryFuncVA(MPDFUNC) \
|
|
static PyObject * \
|
|
dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds) \
|
|
{ \
|
|
static char *kwlist[] = {"context", NULL}; \
|
|
PyObject *result; \
|
|
PyObject *context = Py_None; \
|
|
uint32_t status = 0; \
|
|
\
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, \
|
|
&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 *self, PyObject *args, PyObject *kwds) \
|
|
{ \
|
|
static char *kwlist[] = {"other", "context", NULL}; \
|
|
PyObject *other; \
|
|
PyObject *a, *b; \
|
|
PyObject *result; \
|
|
PyObject *context = Py_None; \
|
|
uint32_t status = 0; \
|
|
\
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, \
|
|
&other, &context)) { \
|
|
return NULL; \
|
|
} \
|
|
CONTEXT_CHECK_VA(context); \
|
|
CONVERT_BINOP_RAISE(&a, &b, self, other, 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. The context is used to record InvalidOperation
|
|
if the second operand cannot be converted exactly. */
|
|
#define Dec_BinaryFuncVA_NO_CTX(MPDFUNC) \
|
|
static PyObject * \
|
|
dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds) \
|
|
{ \
|
|
static char *kwlist[] = {"other", "context", NULL}; \
|
|
PyObject *context = Py_None; \
|
|
PyObject *other; \
|
|
PyObject *a, *b; \
|
|
PyObject *result; \
|
|
\
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, \
|
|
&other, &context)) { \
|
|
return NULL; \
|
|
} \
|
|
CONTEXT_CHECK_VA(context); \
|
|
CONVERT_BINOP_RAISE(&a, &b, self, other, 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 *self, PyObject *args, PyObject *kwds) \
|
|
{ \
|
|
static char *kwlist[] = {"other", "third", "context", NULL}; \
|
|
PyObject *other, *third; \
|
|
PyObject *a, *b, *c; \
|
|
PyObject *result; \
|
|
PyObject *context = Py_None; \
|
|
uint32_t status = 0; \
|
|
\
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist, \
|
|
&other, &third, &context)) { \
|
|
return NULL; \
|
|
} \
|
|
CONTEXT_CHECK_VA(context); \
|
|
CONVERT_TERNOP_RAISE(&a, &b, &c, self, other, third, 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_long(PyObject *dec)
|
|
{
|
|
PyObject *context;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
return dec_as_long(dec, context, MPD_ROUND_DOWN);
|
|
}
|
|
|
|
static int
|
|
nm_nonzero(PyObject *v)
|
|
{
|
|
return !mpd_iszero(MPD(v));
|
|
}
|
|
|
|
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);
|
|
|
|
q = dec_alloc();
|
|
if (q == NULL) {
|
|
Py_DECREF(a);
|
|
Py_DECREF(b);
|
|
return NULL;
|
|
}
|
|
r = dec_alloc();
|
|
if (r == 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;
|
|
}
|
|
}
|
|
|
|
result = dec_alloc();
|
|
if (result == 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 */
|
|
/******************************************************************************/
|
|
|
|
/* Unary arithmetic functions, optional context arg */
|
|
Dec_UnaryFuncVA(mpd_qexp)
|
|
Dec_UnaryFuncVA(mpd_qln)
|
|
Dec_UnaryFuncVA(mpd_qlog10)
|
|
Dec_UnaryFuncVA(mpd_qnext_minus)
|
|
Dec_UnaryFuncVA(mpd_qnext_plus)
|
|
Dec_UnaryFuncVA(mpd_qreduce)
|
|
Dec_UnaryFuncVA(mpd_qsqrt)
|
|
|
|
/* Binary arithmetic functions, optional context arg */
|
|
Dec_BinaryFuncVA(mpd_qcompare)
|
|
Dec_BinaryFuncVA(mpd_qcompare_signal)
|
|
Dec_BinaryFuncVA(mpd_qmax)
|
|
Dec_BinaryFuncVA(mpd_qmax_mag)
|
|
Dec_BinaryFuncVA(mpd_qmin)
|
|
Dec_BinaryFuncVA(mpd_qmin_mag)
|
|
Dec_BinaryFuncVA(mpd_qnext_toward)
|
|
Dec_BinaryFuncVA(mpd_qrem_near)
|
|
|
|
/* Ternary arithmetic functions, optional context arg */
|
|
Dec_TernaryFuncVA(mpd_qfma)
|
|
|
|
/* Boolean functions, no context arg */
|
|
Dec_BoolFunc(mpd_iscanonical)
|
|
Dec_BoolFunc(mpd_isfinite)
|
|
Dec_BoolFunc(mpd_isinfinite)
|
|
Dec_BoolFunc(mpd_isnan)
|
|
Dec_BoolFunc(mpd_isqnan)
|
|
Dec_BoolFunc(mpd_issnan)
|
|
Dec_BoolFunc(mpd_issigned)
|
|
Dec_BoolFunc(mpd_iszero)
|
|
|
|
/* Boolean functions, optional context arg */
|
|
Dec_BoolFuncVA(mpd_isnormal)
|
|
Dec_BoolFuncVA(mpd_issubnormal)
|
|
|
|
/* Unary functions, no context arg */
|
|
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_FromSsize_t(retval);
|
|
}
|
|
|
|
static PyObject *
|
|
dec_canonical(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
Py_INCREF(self);
|
|
return self;
|
|
}
|
|
|
|
static PyObject *
|
|
dec_conjugate(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
Py_INCREF(self);
|
|
return self;
|
|
}
|
|
|
|
static PyObject *
|
|
dec_mpd_radix(PyObject *self UNUSED, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *result;
|
|
|
|
result = dec_alloc();
|
|
if (result == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
_dec_settriple(result, MPD_POS, 10, 0);
|
|
return result;
|
|
}
|
|
|
|
static PyObject *
|
|
dec_mpd_qcopy_abs(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *result;
|
|
uint32_t status = 0;
|
|
|
|
if ((result = dec_alloc()) == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
mpd_qcopy_abs(MPD(result), MPD(self), &status);
|
|
if (status & MPD_Malloc_error) {
|
|
Py_DECREF(result);
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static PyObject *
|
|
dec_mpd_qcopy_negate(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *result;
|
|
uint32_t status = 0;
|
|
|
|
if ((result = dec_alloc()) == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
mpd_qcopy_negate(MPD(result), MPD(self), &status);
|
|
if (status & MPD_Malloc_error) {
|
|
Py_DECREF(result);
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Unary functions, optional context arg */
|
|
Dec_UnaryFuncVA(mpd_qinvert)
|
|
Dec_UnaryFuncVA(mpd_qlogb)
|
|
|
|
static PyObject *
|
|
dec_mpd_class(PyObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"context", NULL};
|
|
PyObject *context = Py_None;
|
|
const char *cp;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist,
|
|
&context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
|
|
cp = mpd_class(MPD(self), CTX(context));
|
|
return PyUnicode_FromString(cp);
|
|
}
|
|
|
|
static PyObject *
|
|
dec_mpd_to_eng(PyObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"context", NULL};
|
|
PyObject *result;
|
|
PyObject *context = Py_None;
|
|
mpd_ssize_t size;
|
|
char *s;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist,
|
|
&context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
|
|
size = mpd_to_eng_size(&s, MPD(self), CtxCaps(context));
|
|
if (size < 0) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
result = unicode_fromascii(s, size);
|
|
mpd_free(s);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Binary functions, optional context arg for conversion errors */
|
|
Dec_BinaryFuncVA_NO_CTX(mpd_compare_total)
|
|
Dec_BinaryFuncVA_NO_CTX(mpd_compare_total_mag)
|
|
|
|
static PyObject *
|
|
dec_mpd_qcopy_sign(PyObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"other", "context", NULL};
|
|
PyObject *other;
|
|
PyObject *a, *b;
|
|
PyObject *result;
|
|
PyObject *context = Py_None;
|
|
uint32_t status = 0;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,
|
|
&other, &context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
CONVERT_BINOP_RAISE(&a, &b, self, other, context);
|
|
|
|
result = dec_alloc();
|
|
if (result == 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;
|
|
}
|
|
|
|
static PyObject *
|
|
dec_mpd_same_quantum(PyObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"other", "context", NULL};
|
|
PyObject *other;
|
|
PyObject *a, *b;
|
|
PyObject *result;
|
|
PyObject *context = Py_None;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,
|
|
&other, &context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
CONVERT_BINOP_RAISE(&a, &b, self, other, context);
|
|
|
|
result = mpd_same_quantum(MPD(a), MPD(b)) ? incr_true() : incr_false();
|
|
Py_DECREF(a);
|
|
Py_DECREF(b);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Binary functions, optional context arg */
|
|
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_qquantize(PyObject *v, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"exp", "rounding", "context", NULL};
|
|
PyObject *rounding = Py_None;
|
|
PyObject *context = Py_None;
|
|
PyObject *w, *a, *b;
|
|
PyObject *result;
|
|
uint32_t status = 0;
|
|
mpd_context_t workctx;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist,
|
|
&w, &rounding, &context)) {
|
|
return NULL;
|
|
}
|
|
CONTEXT_CHECK_VA(context);
|
|
|
|
workctx = *CTX(context);
|
|
if (rounding != Py_None) {
|
|
int round = getround(rounding);
|
|
if (round < 0) {
|
|
return NULL;
|
|
}
|
|
if (!mpd_qsetround(&workctx, round)) {
|
|
INTERNAL_ERROR_PTR("dec_mpd_qquantize"); /* GCOV_NOT_REACHED */
|
|
}
|
|
}
|
|
|
|
CONVERT_BINOP_RAISE(&a, &b, v, w, context);
|
|
|
|
result = dec_alloc();
|
|
if (result == 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;
|
|
}
|
|
|
|
/* Special methods */
|
|
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) ? incr_true() : incr_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);
|
|
}
|
|
|
|
/* __ceil__ */
|
|
static PyObject *
|
|
dec_ceil(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *context;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
return dec_as_long(self, context, MPD_ROUND_CEILING);
|
|
}
|
|
|
|
/* __complex__ */
|
|
static PyObject *
|
|
dec_complex(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *f;
|
|
double x;
|
|
|
|
f = PyDec_AsFloat(self);
|
|
if (f == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
x = PyFloat_AsDouble(f);
|
|
Py_DECREF(f);
|
|
if (x == -1.0 && PyErr_Occurred()) {
|
|
return NULL;
|
|
}
|
|
|
|
return PyComplex_FromDoubles(x, 0);
|
|
}
|
|
|
|
/* __copy__ and __deepcopy__ */
|
|
static PyObject *
|
|
dec_copy(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
Py_INCREF(self);
|
|
return self;
|
|
}
|
|
|
|
/* __floor__ */
|
|
static PyObject *
|
|
dec_floor(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *context;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
return dec_as_long(self, context, MPD_ROUND_FLOOR);
|
|
}
|
|
|
|
/* Always uses the module context */
|
|
static Py_hash_t
|
|
_dec_hash(PyDecObject *v)
|
|
{
|
|
#if defined(CONFIG_64) && _PyHASH_BITS == 61
|
|
/* 2**61 - 1 */
|
|
mpd_uint_t p_data[1] = {2305843009213693951ULL};
|
|
mpd_t p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 19, 1, 1, p_data};
|
|
/* Inverse of 10 modulo p */
|
|
mpd_uint_t inv10_p_data[1] = {2075258708292324556ULL};
|
|
mpd_t inv10_p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA,
|
|
0, 19, 1, 1, inv10_p_data};
|
|
#elif defined(CONFIG_32) && _PyHASH_BITS == 31
|
|
/* 2**31 - 1 */
|
|
mpd_uint_t p_data[2] = {147483647UL, 2};
|
|
mpd_t p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 10, 2, 2, p_data};
|
|
/* Inverse of 10 modulo p */
|
|
mpd_uint_t inv10_p_data[2] = {503238553UL, 1};
|
|
mpd_t inv10_p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA,
|
|
0, 10, 2, 2, inv10_p_data};
|
|
#else
|
|
#error "No valid combination of CONFIG_64, CONFIG_32 and _PyHASH_BITS"
|
|
#endif
|
|
const Py_hash_t py_hash_inf = 314159;
|
|
mpd_uint_t ten_data[1] = {10};
|
|
mpd_t ten = {MPD_POS|MPD_STATIC|MPD_CONST_DATA,
|
|
0, 2, 1, 1, ten_data};
|
|
Py_hash_t result;
|
|
mpd_t *exp_hash = NULL;
|
|
mpd_t *tmp = NULL;
|
|
mpd_ssize_t exp;
|
|
uint32_t status = 0;
|
|
mpd_context_t maxctx;
|
|
|
|
|
|
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 _Py_HashPointer(v);
|
|
}
|
|
else {
|
|
return py_hash_inf * mpd_arith_sign(MPD(v));
|
|
}
|
|
}
|
|
|
|
mpd_maxcontext(&maxctx);
|
|
exp_hash = mpd_qnew();
|
|
if (exp_hash == NULL) {
|
|
goto malloc_error;
|
|
}
|
|
tmp = mpd_qnew();
|
|
if (tmp == NULL) {
|
|
goto malloc_error;
|
|
}
|
|
|
|
/*
|
|
* exp(v): exponent of v
|
|
* int(v): coefficient of v
|
|
*/
|
|
exp = MPD(v)->exp;
|
|
if (exp >= 0) {
|
|
/* 10**exp(v) % p */
|
|
mpd_qsset_ssize(tmp, exp, &maxctx, &status);
|
|
mpd_qpowmod(exp_hash, &ten, tmp, &p, &maxctx, &status);
|
|
}
|
|
else {
|
|
/* inv10_p**(-exp(v)) % p */
|
|
mpd_qsset_ssize(tmp, -exp, &maxctx, &status);
|
|
mpd_qpowmod(exp_hash, &inv10_p, tmp, &p, &maxctx, &status);
|
|
}
|
|
|
|
/* hash = (int(v) * exp_hash) % p */
|
|
if (!mpd_qcopy(tmp, MPD(v), &status)) {
|
|
goto malloc_error;
|
|
}
|
|
tmp->exp = 0;
|
|
mpd_set_positive(tmp);
|
|
|
|
maxctx.prec = MPD_MAX_PREC + 21;
|
|
maxctx.emax = MPD_MAX_EMAX + 21;
|
|
maxctx.emin = MPD_MIN_EMIN - 21;
|
|
|
|
mpd_qmul(tmp, tmp, exp_hash, &maxctx, &status);
|
|
mpd_qrem(tmp, tmp, &p, &maxctx, &status);
|
|
|
|
result = mpd_qget_ssize(tmp, &status);
|
|
result = mpd_ispositive(MPD(v)) ? result : -result;
|
|
result = (result == -1) ? -2 : result;
|
|
|
|
if (status != 0) {
|
|
if (status & MPD_Malloc_error) {
|
|
goto malloc_error;
|
|
}
|
|
else {
|
|
PyErr_SetString(PyExc_RuntimeError, /* GCOV_NOT_REACHED */
|
|
"dec_hash: internal error: please report"); /* GCOV_NOT_REACHED */
|
|
}
|
|
result = -1; /* GCOV_NOT_REACHED */
|
|
}
|
|
|
|
|
|
finish:
|
|
if (exp_hash) mpd_del(exp_hash);
|
|
if (tmp) mpd_del(tmp);
|
|
return result;
|
|
|
|
malloc_error:
|
|
PyErr_NoMemory();
|
|
result = -1;
|
|
goto finish;
|
|
}
|
|
|
|
static Py_hash_t
|
|
dec_hash(PyDecObject *self)
|
|
{
|
|
if (self->hash == -1) {
|
|
self->hash = _dec_hash(self);
|
|
}
|
|
|
|
return self->hash;
|
|
}
|
|
|
|
/* __reduce__ */
|
|
static PyObject *
|
|
dec_reduce(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *result, *str;
|
|
|
|
str = dec_str(self);
|
|
if (str == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
result = Py_BuildValue("O(O)", Py_TYPE(self), str);
|
|
Py_DECREF(str);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* __sizeof__ */
|
|
static PyObject *
|
|
dec_sizeof(PyObject *v, PyObject *dummy UNUSED)
|
|
{
|
|
Py_ssize_t res;
|
|
|
|
res = _PyObject_SIZE(Py_TYPE(v));
|
|
if (mpd_isdynamic_data(MPD(v))) {
|
|
res += MPD(v)->alloc * sizeof(mpd_uint_t);
|
|
}
|
|
return PyLong_FromSsize_t(res);
|
|
}
|
|
|
|
/* __trunc__ */
|
|
static PyObject *
|
|
dec_trunc(PyObject *self, PyObject *dummy UNUSED)
|
|
{
|
|
PyObject *context;
|
|
|
|
CURRENT_CONTEXT(context);
|
|
return dec_as_long(self, context, MPD_ROUND_DOWN);
|
|
}
|
|
|
|
/* real and imag */
|
|
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;
|
|
|
|
result = dec_alloc();
|
|
if (result == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
_dec_settriple(result, MPD_POS, 0, 0);
|
|
return result;
|
|
}
|
|
|
|
|
|
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_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 */
|
|
(unaryfunc) nm_dec_as_long,
|
|
0, /* nb_reserved */
|
|
(unaryfunc) PyDec_AsFloat,
|
|
0, /* binaryfunc nb_inplace_add; */
|
|
0, /* binaryfunc nb_inplace_subtract; */
|
|
0, /* binaryfunc nb_inplace_multiply; */
|
|
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, optional context arg */
|
|
{ "exp", (PyCFunction)(void(*)(void))dec_mpd_qexp, METH_VARARGS|METH_KEYWORDS, doc_exp },
|
|
{ "ln", (PyCFunction)(void(*)(void))dec_mpd_qln, METH_VARARGS|METH_KEYWORDS, doc_ln },
|
|
{ "log10", (PyCFunction)(void(*)(void))dec_mpd_qlog10, METH_VARARGS|METH_KEYWORDS, doc_log10 },
|
|
{ "next_minus", (PyCFunction)(void(*)(void))dec_mpd_qnext_minus, METH_VARARGS|METH_KEYWORDS, doc_next_minus },
|
|
{ "next_plus", (PyCFunction)(void(*)(void))dec_mpd_qnext_plus, METH_VARARGS|METH_KEYWORDS, doc_next_plus },
|
|
{ "normalize", (PyCFunction)(void(*)(void))dec_mpd_qreduce, METH_VARARGS|METH_KEYWORDS, doc_normalize },
|
|
{ "to_integral", (PyCFunction)(void(*)(void))PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral },
|
|
{ "to_integral_exact", (PyCFunction)(void(*)(void))PyDec_ToIntegralExact, METH_VARARGS|METH_KEYWORDS, doc_to_integral_exact },
|
|
{ "to_integral_value", (PyCFunction)(void(*)(void))PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral_value },
|
|
{ "sqrt", (PyCFunction)(void(*)(void))dec_mpd_qsqrt, METH_VARARGS|METH_KEYWORDS, doc_sqrt },
|
|
|
|
/* Binary arithmetic functions, optional context arg */
|
|
{ "compare", (PyCFunction)(void(*)(void))dec_mpd_qcompare, METH_VARARGS|METH_KEYWORDS, doc_compare },
|
|
{ "compare_signal", (PyCFunction)(void(*)(void))dec_mpd_qcompare_signal, METH_VARARGS|METH_KEYWORDS, doc_compare_signal },
|
|
{ "max", (PyCFunction)(void(*)(void))dec_mpd_qmax, METH_VARARGS|METH_KEYWORDS, doc_max },
|
|
{ "max_mag", (PyCFunction)(void(*)(void))dec_mpd_qmax_mag, METH_VARARGS|METH_KEYWORDS, doc_max_mag },
|
|
{ "min", (PyCFunction)(void(*)(void))dec_mpd_qmin, METH_VARARGS|METH_KEYWORDS, doc_min },
|
|
{ "min_mag", (PyCFunction)(void(*)(void))dec_mpd_qmin_mag, METH_VARARGS|METH_KEYWORDS, doc_min_mag },
|
|
{ "next_toward", (PyCFunction)(void(*)(void))dec_mpd_qnext_toward, METH_VARARGS|METH_KEYWORDS, doc_next_toward },
|
|
{ "quantize", (PyCFunction)(void(*)(void))dec_mpd_qquantize, METH_VARARGS|METH_KEYWORDS, doc_quantize },
|
|
{ "remainder_near", (PyCFunction)(void(*)(void))dec_mpd_qrem_near, METH_VARARGS|METH_KEYWORDS, doc_remainder_near },
|
|
|
|
/* Ternary arithmetic functions, optional context arg */
|
|
{ "fma", (PyCFunction)(void(*)(void))dec_mpd_qfma, METH_VARARGS|METH_KEYWORDS, doc_fma },
|
|
|
|
/* 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_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_zero", dec_mpd_iszero, METH_NOARGS, doc_is_zero },
|
|
|
|
/* Boolean functions, optional context arg */
|
|
{ "is_normal", (PyCFunction)(void(*)(void))dec_mpd_isnormal, METH_VARARGS|METH_KEYWORDS, doc_is_normal },
|
|
{ "is_subnormal", (PyCFunction)(void(*)(void))dec_mpd_issubnormal, METH_VARARGS|METH_KEYWORDS, 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 },
|
|
{ "radix", dec_mpd_radix, METH_NOARGS, doc_radix },
|
|
|
|
/* Unary functions, optional context arg for conversion errors */
|
|
{ "copy_abs", dec_mpd_qcopy_abs, METH_NOARGS, doc_copy_abs },
|
|
{ "copy_negate", dec_mpd_qcopy_negate, METH_NOARGS, doc_copy_negate },
|
|
|
|
/* Unary functions, optional context arg */
|
|
{ "logb", (PyCFunction)(void(*)(void))dec_mpd_qlogb, METH_VARARGS|METH_KEYWORDS, doc_logb },
|
|
{ "logical_invert", (PyCFunction)(void(*)(void))dec_mpd_qinvert, METH_VARARGS|METH_KEYWORDS, doc_logical_invert },
|
|
{ "number_class", (PyCFunction)(void(*)(void))dec_mpd_class, METH_VARARGS|METH_KEYWORDS, doc_number_class },
|
|
{ "to_eng_string", (PyCFunction)(void(*)(void))dec_mpd_to_eng, METH_VARARGS|METH_KEYWORDS, doc_to_eng_string },
|
|
|
|
/* Binary functions, optional context arg for conversion errors */
|
|
{ "compare_total", (PyCFunction)(void(*)(void))dec_mpd_compare_total, METH_VARARGS|METH_KEYWORDS, doc_compare_total },
|
|
{ "compare_total_mag", (PyCFunction)(void(*)(void))dec_mpd_compare_total_mag, METH_VARARGS|METH_KEYWORDS, doc_compare_total_mag },
|
|
{ "copy_sign", (PyCFunction)(void(*)(void))dec_mpd_qcopy_sign, METH_VARARGS|METH_KEYWORDS, doc_copy_sign },
|
|
{ "same_quantum", (PyCFunction)(void(*)(void))dec_mpd_same_quantum, METH_VARARGS|METH_KEYWORDS, doc_same_quantum },
|
|
|
|
/* Binary functions, optional context arg */
|
|
{ "logical_and", (PyCFunction)(void(*)(void))dec_mpd_qand, METH_VARARGS|METH_KEYWORDS, doc_logical_and },
|
|
{ "logical_or", (PyCFunction)(void(*)(void))dec_mpd_qor, METH_VARARGS|METH_KEYWORDS, doc_logical_or },
|
|
{ "logical_xor", (PyCFunction)(void(*)(void))dec_mpd_qxor, METH_VARARGS|METH_KEYWORDS, doc_logical_xor },
|
|
{ "rotate", (PyCFunction)(void(*)(void))dec_mpd_qrotate, METH_VARARGS|METH_KEYWORDS, doc_rotate },
|
|
{ "scaleb", (PyCFunction)(void(*)(void))dec_mpd_qscaleb, METH_VARARGS|METH_KEYWORDS, doc_scaleb },
|
|
{ "shift", (PyCFunction)(void(*)(void))dec_mpd_qshift, METH_VARARGS|METH_KEYWORDS, doc_shift },
|
|
|
|
/* Miscellaneous */
|
|
{ "from_float", dec_from_float, METH_O|METH_CLASS, doc_from_float },
|
|
{ "as_tuple", PyDec_AsTuple, METH_NOARGS, doc_as_tuple },
|
|
{ "as_integer_ratio", dec_as_integer_ratio, METH_NOARGS, doc_as_integer_ratio },
|
|
|
|
/* Special methods */
|
|
{ "__copy__", dec_copy, METH_NOARGS, NULL },
|
|
{ "__deepcopy__", dec_copy, METH_O, NULL },
|
|
{ "__format__", dec_format, METH_VARARGS, NULL },
|
|
{ "__reduce__", dec_reduce, METH_NOARGS, NULL },
|
|
{ "__round__", PyDec_Round, METH_VARARGS, NULL },
|
|
{ "__ceil__", dec_ceil, METH_NOARGS, NULL },
|
|
{ "__floor__", dec_floor, METH_NOARGS, NULL },
|
|
{ "__trunc__", dec_trunc, METH_NOARGS, NULL },
|
|
{ "__complex__", dec_complex, METH_NOARGS, NULL },
|
|
{ "__sizeof__", dec_sizeof, METH_NOARGS, NULL },
|
|
|
|
{ NULL, NULL, 1 }
|
|
};
|
|
|
|
static PyTypeObject PyDec_Type =
|
|
{
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"decimal.Decimal", /* tp_name */
|
|
sizeof(PyDecObject), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
(destructor) dec_dealloc, /* tp_dealloc */
|
|
0, /* tp_vectorcall_offset */
|
|
(getattrfunc) 0, /* tp_getattr */
|
|
(setattrfunc) 0, /* tp_setattr */
|
|
0, /* tp_as_async */
|
|
(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_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)) ? incr_true() : incr_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)) ? incr_true() : incr_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; \
|
|
}
|
|
|
|
|
|
/* Unary arithmetic functions */
|
|
DecCtx_UnaryFunc(mpd_qabs)
|
|
DecCtx_UnaryFunc(mpd_qexp)
|
|
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)
|
|
|
|
/* Binary arithmetic functions */
|
|
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_qquantize)
|
|
DecCtx_BinaryFunc(mpd_qrem)
|
|
DecCtx_BinaryFunc(mpd_qrem_near)
|
|
DecCtx_BinaryFunc(mpd_qsub)
|
|
|
|
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);
|
|
|
|
q = dec_alloc();
|
|
if (q == NULL) {
|
|
Py_DECREF(a);
|
|
Py_DECREF(b);
|
|
return NULL;
|
|
}
|
|
r = dec_alloc();
|
|
if (r == 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;
|
|
}
|
|
|
|
/* Binary or ternary arithmetic functions */
|
|
static PyObject *
|
|
ctx_mpd_qpow(PyObject *context, PyObject *args, PyObject *kwds)
|
|
{
|
|
static char *kwlist[] = {"a", "b", "modulo", NULL};
|
|
PyObject *base, *exp, *mod = Py_None;
|
|
PyObject *a, *b, *c = NULL;
|
|
PyObject *result;
|
|
uint32_t status = 0;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist,
|
|
&base, &exp, &mod)) {
|
|
return NULL;
|
|
}
|
|
|
|
CONVERT_BINOP_RAISE(&a, &b, base, exp, context);
|
|
|
|
if (mod != Py_None) {
|
|
if (!convert_op(TYPE_ERR, &c, mod, context)) {
|
|
Py_DECREF(a);
|
|
Py_DECREF(b);
|
|
return c;
|
|
}
|
|
}
|
|
|
|
result = dec_alloc();
|
|
if (result == 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;
|
|
}
|
|
|
|
/* Ternary arithmetic functions */
|
|
DecCtx_TernaryFunc(mpd_qfma)
|
|
|
|
/* No argument */
|
|
static PyObject *
|
|
ctx_mpd_radix(PyObject *context, PyObject *dummy)
|
|
{
|
|
return dec_mpd_radix(context, dummy);
|
|
}
|
|
|
|
/* Boolean functions: single decimal argument */
|
|
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_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)) ? incr_true() : incr_false();
|
|
}
|
|
|
|
/* Functions with a single decimal argument */
|
|
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_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_qcopy_abs(PyObject *context, PyObject *v)
|
|
{
|
|
PyObject *result, *a;
|
|
uint32_t status = 0;
|
|
|
|
CONVERT_OP_RAISE(&a, v, context);
|
|
|
|
result = dec_alloc();
|
|
if (result == 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;
|
|
}
|
|
|
|
static PyObject *
|
|
ctx_copy_decimal(PyObject *context, PyObject *v)
|
|
{
|
|
PyObject *result;
|
|
|
|
CONVERT_OP_RAISE(&result, v, context);
|
|
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);
|
|
|
|
result = dec_alloc();
|
|
if (result == 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_qlogb)
|
|
DecCtx_UnaryFunc(mpd_qinvert)
|
|
|
|
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 PyUnicode_FromString(cp);
|
|
}
|
|
|
|
static PyObject *
|
|
ctx_mpd_to_sci(PyObject *context, PyObject *v)
|
|
{
|
|
PyObject *result;
|
|
PyObject *a;
|
|
mpd_ssize_t size;
|
|
char *s;
|
|
|
|
CONVERT_OP_RAISE(&a, v, context);
|
|
|
|
size = mpd_to_sci_size(&s, MPD(a), CtxCaps(context));
|
|
Py_DECREF(a);
|
|
if (size < 0) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
result = unicode_fromascii(s, size);
|
|
mpd_free(s);
|
|
|
|
return result;
|
|
}
|
|
|
|
static PyObject *
|
|
ctx_mpd_to_eng(PyObject *context, PyObject *v)
|
|
{
|
|
PyObject *result;
|
|
PyObject *a;
|
|
mpd_ssize_t size;
|
|
char *s;
|
|
|
|
CONVERT_OP_RAISE(&a, v, context);
|
|
|
|
size = mpd_to_eng_size(&s, MPD(a), CtxCaps(context));
|
|
Py_DECREF(a);
|
|
if (size < 0) {
|
|
PyErr_NoMemory();
|
|
return NULL;
|
|
}
|
|
|
|
result = unicode_fromascii(s, size);
|
|
mpd_free(s);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Functions with two decimal arguments */
|
|
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);
|
|
|
|
result = dec_alloc();
|
|
if (result == 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_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)) ? incr_true() : incr_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 },
|
|
{ "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 },
|
|
{ "plus", ctx_mpd_qplus, METH_O, doc_ctx_plus },
|
|
{ "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 },
|
|
{ "divide", ctx_mpd_qdiv, METH_VARARGS, doc_ctx_divide },
|
|
{ "divide_int", ctx_mpd_qdivint, METH_VARARGS, doc_ctx_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 },
|
|
{ "multiply", ctx_mpd_qmul, METH_VARARGS, doc_ctx_multiply },
|
|
{ "next_toward", ctx_mpd_qnext_toward, METH_VARARGS, doc_ctx_next_toward },
|
|
{ "quantize", ctx_mpd_qquantize, METH_VARARGS, doc_ctx_quantize },
|
|
{ "remainder", ctx_mpd_qrem, METH_VARARGS, doc_ctx_remainder },
|
|
{ "remainder_near", ctx_mpd_qrem_near, METH_VARARGS, doc_ctx_remainder_near },
|
|
{ "subtract", ctx_mpd_qsub, METH_VARARGS, doc_ctx_subtract },
|
|
|
|
/* Binary or ternary arithmetic functions */
|
|
{ "power", (PyCFunction)(void(*)(void))ctx_mpd_qpow, METH_VARARGS|METH_KEYWORDS, doc_ctx_power },
|
|
|
|
/* Ternary arithmetic functions */
|
|
{ "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma },
|
|
|
|
/* 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 */
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
{ "apply", PyDecContext_Apply, METH_O, doc_ctx_apply },
|
|
#endif
|
|
{ "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_string", ctx_mpd_to_sci, METH_O, doc_ctx_to_sci_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 */
|
|
{ "clear_flags", context_clear_flags, METH_NOARGS, doc_ctx_clear_flags },
|
|
{ "clear_traps", context_clear_traps, METH_NOARGS, doc_ctx_clear_traps },
|
|
|
|
#ifdef CONFIG_32
|
|
/* Unsafe set functions with relaxed 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 },
|
|
#endif
|
|
|
|
/* 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 =
|
|
{
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"decimal.Context", /* tp_name */
|
|
sizeof(PyDecContextObject), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
(destructor) context_dealloc, /* tp_dealloc */
|
|
0, /* tp_vectorcall_offset */
|
|
(getattrfunc) 0, /* tp_getattr */
|
|
(setattrfunc) 0, /* tp_setattr */
|
|
0, /* tp_as_async */
|
|
(reprfunc) context_repr, /* tp_repr */
|
|
0, /* tp_as_number */
|
|
0, /* tp_as_sequence */
|
|
0, /* tp_as_mapping */
|
|
(hashfunc) 0, /* tp_hash */
|
|
0, /* tp_call */
|
|
0, /* tp_str */
|
|
(getattrofunc) context_getattr, /* tp_getattro */
|
|
(setattrofunc) context_setattr, /* tp_setattro */
|
|
(PyBufferProcs *) 0, /* tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* 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 */
|
|
PyObject_Del, /* tp_free */
|
|
};
|
|
|
|
|
|
static PyMethodDef _decimal_methods [] =
|
|
{
|
|
{ "getcontext", (PyCFunction)PyDec_GetCurrentContext, METH_NOARGS, doc_getcontext},
|
|
{ "setcontext", (PyCFunction)PyDec_SetCurrentContext, METH_O, doc_setcontext},
|
|
{ "localcontext", (PyCFunction)(void(*)(void))ctxmanager_new, METH_VARARGS|METH_KEYWORDS, doc_localcontext},
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
{ "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context},
|
|
#endif
|
|
{ NULL, NULL, 1, NULL }
|
|
};
|
|
|
|
static struct PyModuleDef _decimal_module = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"decimal",
|
|
doc__decimal,
|
|
-1,
|
|
_decimal_methods,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
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 */
|
|
#ifdef EXTRA_FUNCTIONALITY
|
|
{"DECIMAL32", MPD_DECIMAL32},
|
|
{"DECIMAL64", MPD_DECIMAL64},
|
|
{"DECIMAL128", MPD_DECIMAL128},
|
|
{"IEEE_CONTEXT_MAX_BITS", MPD_IEEE_CONTEXT_MAX_BITS},
|
|
/* 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},
|
|
#endif
|
|
{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)
|
|
|
|
|
|
static PyCFunction
|
|
cfunc_noargs(PyTypeObject *t, const char *name)
|
|
{
|
|
struct PyMethodDef *m;
|
|
|
|
if (t->tp_methods == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
for (m = t->tp_methods; m->ml_name != NULL; m++) {
|
|
if (strcmp(name, m->ml_name) == 0) {
|
|
if (!(m->ml_flags & METH_NOARGS)) {
|
|
goto error;
|
|
}
|
|
return m->ml_meth;
|
|
}
|
|
}
|
|
|
|
error:
|
|
PyErr_Format(PyExc_RuntimeError,
|
|
"internal error: could not find method %s", name);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit__decimal(void)
|
|
{
|
|
PyObject *m = NULL;
|
|
PyObject *numbers = NULL;
|
|
PyObject *Number = NULL;
|
|
PyObject *collections = NULL;
|
|
PyObject *collections_abc = NULL;
|
|
PyObject *MutableMapping = NULL;
|
|
PyObject *obj = NULL;
|
|
DecCondMap *cm;
|
|
struct ssize_constmap *ssize_cm;
|
|
struct int_constmap *int_cm;
|
|
int i;
|
|
|
|
|
|
/* 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(_Py_DEC_MINALLOC);
|
|
|
|
|
|
/* Init external C-API functions */
|
|
_py_long_multiply = PyLong_Type.tp_as_number->nb_multiply;
|
|
_py_long_floor_divide = PyLong_Type.tp_as_number->nb_floor_divide;
|
|
_py_long_power = PyLong_Type.tp_as_number->nb_power;
|
|
_py_float_abs = PyFloat_Type.tp_as_number->nb_absolute;
|
|
ASSIGN_PTR(_py_float_as_integer_ratio, cfunc_noargs(&PyFloat_Type,
|
|
"as_integer_ratio"));
|
|
ASSIGN_PTR(_py_long_bit_length, cfunc_noargs(&PyLong_Type, "bit_length"));
|
|
|
|
|
|
/* Init types */
|
|
PyDec_Type.tp_base = &PyBaseObject_Type;
|
|
PyDecContext_Type.tp_base = &PyBaseObject_Type;
|
|
PyDecContextManager_Type.tp_base = &PyBaseObject_Type;
|
|
PyDecSignalDictMixin_Type.tp_base = &PyBaseObject_Type;
|
|
|
|
CHECK_INT(PyType_Ready(&PyDec_Type));
|
|
CHECK_INT(PyType_Ready(&PyDecContext_Type));
|
|
CHECK_INT(PyType_Ready(&PyDecSignalDictMixin_Type));
|
|
CHECK_INT(PyType_Ready(&PyDecContextManager_Type));
|
|
|
|
ASSIGN_PTR(obj, PyUnicode_FromString("decimal"));
|
|
CHECK_INT(PyDict_SetItemString(PyDec_Type.tp_dict, "__module__", obj));
|
|
CHECK_INT(PyDict_SetItemString(PyDecContext_Type.tp_dict,
|
|
"__module__", obj));
|
|
Py_CLEAR(obj);
|
|
|
|
|
|
/* Numeric abstract base classes */
|
|
ASSIGN_PTR(numbers, PyImport_ImportModule("numbers"));
|
|
ASSIGN_PTR(Number, PyObject_GetAttrString(numbers, "Number"));
|
|
/* Register Decimal with the Number abstract base class */
|
|
ASSIGN_PTR(obj, PyObject_CallMethod(Number, "register", "(O)",
|
|
(PyObject *)&PyDec_Type));
|
|
Py_CLEAR(obj);
|
|
/* Rational is a global variable used for fraction comparisons. */
|
|
ASSIGN_PTR(Rational, PyObject_GetAttrString(numbers, "Rational"));
|
|
/* Done with numbers, Number */
|
|
Py_CLEAR(numbers);
|
|
Py_CLEAR(Number);
|
|
|
|
/* DecimalTuple */
|
|
ASSIGN_PTR(collections, PyImport_ImportModule("collections"));
|
|
ASSIGN_PTR(DecimalTuple, (PyTypeObject *)PyObject_CallMethod(collections,
|
|
"namedtuple", "(ss)", "DecimalTuple",
|
|
"sign digits exponent"));
|
|
|
|
ASSIGN_PTR(obj, PyUnicode_FromString("decimal"));
|
|
CHECK_INT(PyDict_SetItemString(DecimalTuple->tp_dict, "__module__", obj));
|
|
Py_CLEAR(obj);
|
|
|
|
/* MutableMapping */
|
|
ASSIGN_PTR(collections_abc, PyImport_ImportModule("collections.abc"));
|
|
ASSIGN_PTR(MutableMapping, PyObject_GetAttrString(collections_abc,
|
|
"MutableMapping"));
|
|
/* Create SignalDict type */
|
|
ASSIGN_PTR(PyDecSignalDict_Type,
|
|
(PyTypeObject *)PyObject_CallFunction(
|
|
(PyObject *)&PyType_Type, "s(OO){}",
|
|
"SignalDict", &PyDecSignalDictMixin_Type,
|
|
MutableMapping));
|
|
|
|
/* Done with collections, MutableMapping */
|
|
Py_CLEAR(collections);
|
|
Py_CLEAR(collections_abc);
|
|
Py_CLEAR(MutableMapping);
|
|
|
|
|
|
/* Create the module */
|
|
ASSIGN_PTR(m, PyModule_Create(&_decimal_module));
|
|
|
|
|
|
/* 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));
|
|
Py_INCREF(DecimalTuple);
|
|
CHECK_INT(PyModule_AddObject(m, "DecimalTuple", (PyObject *)DecimalTuple));
|
|
|
|
|
|
/* Create top level exception */
|
|
ASSIGN_PTR(DecimalException, PyErr_NewException(
|
|
"decimal.DecimalException",
|
|
PyExc_ArithmeticError, NULL));
|
|
Py_INCREF(DecimalException);
|
|
CHECK_INT(PyModule_AddObject(m, "DecimalException", DecimalException));
|
|
|
|
/* Create signal tuple */
|
|
ASSIGN_PTR(SignalTuple, PyTuple_New(SIGNAL_MAP_LEN));
|
|
|
|
/* Add exceptions that correspond to IEEE signals */
|
|
for (i = SIGNAL_MAP_LEN-1; i >= 0; i--) {
|
|
PyObject *base;
|
|
|
|
cm = signal_map + i;
|
|
|
|
switch (cm->flag) {
|
|
case MPD_Float_operation:
|
|
base = PyTuple_Pack(2, DecimalException, PyExc_TypeError);
|
|
break;
|
|
case MPD_Division_by_zero:
|
|
base = PyTuple_Pack(2, DecimalException, PyExc_ZeroDivisionError);
|
|
break;
|
|
case MPD_Overflow:
|
|
base = PyTuple_Pack(2, signal_map[INEXACT].ex,
|
|
signal_map[ROUNDED].ex);
|
|
break;
|
|
case MPD_Underflow:
|
|
base = PyTuple_Pack(3, signal_map[INEXACT].ex,
|
|
signal_map[ROUNDED].ex,
|
|
signal_map[SUBNORMAL].ex);
|
|
break;
|
|
default:
|
|
base = PyTuple_Pack(1, DecimalException);
|
|
break;
|
|
}
|
|
|
|
if (base == NULL) {
|
|
goto error; /* GCOV_NOT_REACHED */
|
|
}
|
|
|
|
ASSIGN_PTR(cm->ex, PyErr_NewException(cm->fqname, base, NULL));
|
|
Py_DECREF(base);
|
|
|
|
/* add to module */
|
|
Py_INCREF(cm->ex);
|
|
CHECK_INT(PyModule_AddObject(m, cm->name, cm->ex));
|
|
|
|
/* add to signal tuple */
|
|
Py_INCREF(cm->ex);
|
|
PyTuple_SET_ITEM(SignalTuple, i, cm->ex);
|
|
}
|
|
|
|
/*
|
|
* Unfortunately, InvalidOperation is a signal that comprises
|
|
* several conditions, including InvalidOperation! Naming the
|
|
* signal IEEEInvalidOperation would prevent the confusion.
|
|
*/
|
|
cond_map[0].ex = signal_map[0].ex;
|
|
|
|
/* Add remaining exceptions, inherit from InvalidOperation */
|
|
for (cm = cond_map+1; cm->name != NULL; cm++) {
|
|
PyObject *base;
|
|
if (cm->flag == MPD_Division_undefined) {
|
|
base = PyTuple_Pack(2, signal_map[0].ex, PyExc_ZeroDivisionError);
|
|
}
|
|
else {
|
|
base = PyTuple_Pack(1, signal_map[0].ex);
|
|
}
|
|
if (base == NULL) {
|
|
goto error; /* GCOV_NOT_REACHED */
|
|
}
|
|
|
|
ASSIGN_PTR(cm->ex, PyErr_NewException(cm->fqname, base, NULL));
|
|
Py_DECREF(base);
|
|
|
|
Py_INCREF(cm->ex);
|
|
CHECK_INT(PyModule_AddObject(m, cm->name, cm->ex));
|
|
}
|
|
|
|
|
|
/* 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));
|
|
|
|
#ifndef WITH_DECIMAL_CONTEXTVAR
|
|
ASSIGN_PTR(tls_context_key, PyUnicode_FromString("___DECIMAL_CTX__"));
|
|
Py_INCREF(Py_False);
|
|
CHECK_INT(PyModule_AddObject(m, "HAVE_CONTEXTVAR", Py_False));
|
|
#else
|
|
ASSIGN_PTR(current_context_var, PyContextVar_New("decimal_context", NULL));
|
|
Py_INCREF(Py_True);
|
|
CHECK_INT(PyModule_AddObject(m, "HAVE_CONTEXTVAR", Py_True));
|
|
#endif
|
|
Py_INCREF(Py_True);
|
|
CHECK_INT(PyModule_AddObject(m, "HAVE_THREADS", Py_True));
|
|
|
|
/* 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, PyLong_FromSsize_t(ssize_cm->val));
|
|
CHECK_INT(PyModule_AddObject(m, ssize_cm->name, obj));
|
|
obj = NULL;
|
|
}
|
|
|
|
/* 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));
|
|
}
|
|
|
|
/* Init string constants */
|
|
for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {
|
|
ASSIGN_PTR(round_map[i], PyUnicode_InternFromString(mpd_round_string[i]));
|
|
Py_INCREF(round_map[i]);
|
|
CHECK_INT(PyModule_AddObject(m, mpd_round_string[i], round_map[i]));
|
|
}
|
|
|
|
/* Add specification version number */
|
|
CHECK_INT(PyModule_AddStringConstant(m, "__version__", "1.70"));
|
|
CHECK_INT(PyModule_AddStringConstant(m, "__libmpdec_version__", mpd_version()));
|
|
|
|
|
|
return m;
|
|
|
|
|
|
error:
|
|
Py_CLEAR(obj); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(numbers); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(Number); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(Rational); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(collections); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(collections_abc); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(MutableMapping); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(SignalTuple); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(DecimalTuple); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(default_context_template); /* GCOV_NOT_REACHED */
|
|
#ifndef WITH_DECIMAL_CONTEXTVAR
|
|
Py_CLEAR(tls_context_key); /* GCOV_NOT_REACHED */
|
|
#else
|
|
Py_CLEAR(current_context_var); /* GCOV_NOT_REACHED */
|
|
#endif
|
|
Py_CLEAR(basic_context_template); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(extended_context_template); /* GCOV_NOT_REACHED */
|
|
Py_CLEAR(m); /* GCOV_NOT_REACHED */
|
|
|
|
return NULL; /* GCOV_NOT_REACHED */
|
|
}
|