LCOV - code coverage report
Current view: top level - Modules/_decimal - _decimal.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 479 2163 22.1 %
Date: 2023-03-20 08:15:36 Functions: 41 247 16.6 %
Branches: 217 2171 10.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 2008-2012 Stefan Krah. All rights reserved.
       3                 :            :  *
       4                 :            :  * Redistribution and use in source and binary forms, with or without
       5                 :            :  * modification, are permitted provided that the following conditions
       6                 :            :  * are met:
       7                 :            :  *
       8                 :            :  * 1. Redistributions of source code must retain the above copyright
       9                 :            :  *    notice, this list of conditions and the following disclaimer.
      10                 :            :  *
      11                 :            :  * 2. Redistributions in binary form must reproduce the above copyright
      12                 :            :  *    notice, this list of conditions and the following disclaimer in the
      13                 :            :  *    documentation and/or other materials provided with the distribution.
      14                 :            :  *
      15                 :            :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
      16                 :            :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      17                 :            :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      18                 :            :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
      19                 :            :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      20                 :            :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      21                 :            :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      22                 :            :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      23                 :            :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      24                 :            :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      25                 :            :  * SUCH DAMAGE.
      26                 :            :  */
      27                 :            : 
      28                 :            : #ifndef Py_BUILD_CORE_BUILTIN
      29                 :            : #  define Py_BUILD_CORE_MODULE 1
      30                 :            : #endif
      31                 :            : 
      32                 :            : #include <Python.h>
      33                 :            : #include "pycore_pystate.h"       // _PyThreadState_GET()
      34                 :            : #include "complexobject.h"
      35                 :            : #include "mpdecimal.h"
      36                 :            : 
      37                 :            : #include <stdlib.h>
      38                 :            : 
      39                 :            : #include "docstrings.h"
      40                 :            : 
      41                 :            : 
      42                 :            : #if !defined(MPD_VERSION_HEX) || MPD_VERSION_HEX < 0x02050000
      43                 :            :   #error "libmpdec version >= 2.5.0 required"
      44                 :            : #endif
      45                 :            : 
      46                 :            : 
      47                 :            : /*
      48                 :            :  * Type sizes with assertions in mpdecimal.h and pyport.h:
      49                 :            :  *    sizeof(size_t) == sizeof(Py_ssize_t)
      50                 :            :  *    sizeof(size_t) == sizeof(mpd_uint_t) == sizeof(mpd_ssize_t)
      51                 :            :  */
      52                 :            : 
      53                 :            : #ifdef TEST_COVERAGE
      54                 :            :   #undef Py_LOCAL_INLINE
      55                 :            :   #define Py_LOCAL_INLINE Py_LOCAL
      56                 :            : #endif
      57                 :            : 
      58                 :            : #define MPD_Float_operation MPD_Not_implemented
      59                 :            : 
      60                 :            : #define BOUNDS_CHECK(x, MIN, MAX) x = (x < MIN || MAX < x) ? MAX : x
      61                 :            : 
      62                 :            : #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
      63                 :            :   #define UNUSED __attribute__((unused))
      64                 :            : #else
      65                 :            :   #define UNUSED
      66                 :            : #endif
      67                 :            : 
      68                 :            : /* _Py_DEC_MINALLOC >= MPD_MINALLOC */
      69                 :            : #define _Py_DEC_MINALLOC 4
      70                 :            : 
      71                 :            : typedef struct {
      72                 :            :     PyObject_HEAD
      73                 :            :     Py_hash_t hash;
      74                 :            :     mpd_t dec;
      75                 :            :     mpd_uint_t data[_Py_DEC_MINALLOC];
      76                 :            : } PyDecObject;
      77                 :            : 
      78                 :            : typedef struct {
      79                 :            :     PyObject_HEAD
      80                 :            :     uint32_t *flags;
      81                 :            : } PyDecSignalDictObject;
      82                 :            : 
      83                 :            : typedef struct {
      84                 :            :     PyObject_HEAD
      85                 :            :     mpd_context_t ctx;
      86                 :            :     PyObject *traps;
      87                 :            :     PyObject *flags;
      88                 :            :     int capitals;
      89                 :            :     PyThreadState *tstate;
      90                 :            : } PyDecContextObject;
      91                 :            : 
      92                 :            : typedef struct {
      93                 :            :     PyObject_HEAD
      94                 :            :     PyObject *local;
      95                 :            :     PyObject *global;
      96                 :            : } PyDecContextManagerObject;
      97                 :            : 
      98                 :            : 
      99                 :            : #undef MPD
     100                 :            : #undef CTX
     101                 :            : static PyTypeObject PyDec_Type;
     102                 :            : static PyTypeObject *PyDecSignalDict_Type;
     103                 :            : static PyTypeObject PyDecContext_Type;
     104                 :            : static PyTypeObject PyDecContextManager_Type;
     105                 :            : #define PyDec_CheckExact(v) Py_IS_TYPE(v, &PyDec_Type)
     106                 :            : #define PyDec_Check(v) PyObject_TypeCheck(v, &PyDec_Type)
     107                 :            : #define PyDecSignalDict_Check(v) Py_IS_TYPE(v, PyDecSignalDict_Type)
     108                 :            : #define PyDecContext_Check(v) PyObject_TypeCheck(v, &PyDecContext_Type)
     109                 :            : #define MPD(v) (&((PyDecObject *)v)->dec)
     110                 :            : #define SdFlagAddr(v) (((PyDecSignalDictObject *)v)->flags)
     111                 :            : #define SdFlags(v) (*((PyDecSignalDictObject *)v)->flags)
     112                 :            : #define CTX(v) (&((PyDecContextObject *)v)->ctx)
     113                 :            : #define CtxCaps(v) (((PyDecContextObject *)v)->capitals)
     114                 :            : 
     115                 :            : 
     116                 :            : Py_LOCAL_INLINE(PyObject *)
     117                 :          0 : incr_true(void)
     118                 :            : {
     119                 :          0 :     return Py_NewRef(Py_True);
     120                 :            : }
     121                 :            : 
     122                 :            : Py_LOCAL_INLINE(PyObject *)
     123                 :          0 : incr_false(void)
     124                 :            : {
     125                 :          0 :     return Py_NewRef(Py_False);
     126                 :            : }
     127                 :            : 
     128                 :            : 
     129                 :            : #ifndef WITH_DECIMAL_CONTEXTVAR
     130                 :            : /* Key for thread state dictionary */
     131                 :            : static PyObject *tls_context_key = NULL;
     132                 :            : /* Invariant: NULL or the most recently accessed thread local context */
     133                 :            : static PyDecContextObject *cached_context = NULL;
     134                 :            : #else
     135                 :            : static PyObject *current_context_var = NULL;
     136                 :            : #endif
     137                 :            : 
     138                 :            : /* Template for creating new thread contexts, calling Context() without
     139                 :            :  * arguments and initializing the module_context on first access. */
     140                 :            : static PyObject *default_context_template = NULL;
     141                 :            : /* Basic and extended context templates */
     142                 :            : static PyObject *basic_context_template = NULL;
     143                 :            : static PyObject *extended_context_template = NULL;
     144                 :            : 
     145                 :            : 
     146                 :            : /* Error codes for functions that return signals or conditions */
     147                 :            : #define DEC_INVALID_SIGNALS (MPD_Max_status+1U)
     148                 :            : #define DEC_ERR_OCCURRED (DEC_INVALID_SIGNALS<<1)
     149                 :            : #define DEC_ERRORS (DEC_INVALID_SIGNALS|DEC_ERR_OCCURRED)
     150                 :            : 
     151                 :            : typedef struct {
     152                 :            :     const char *name;   /* condition or signal name */
     153                 :            :     const char *fqname; /* fully qualified name */
     154                 :            :     uint32_t flag;      /* libmpdec flag */
     155                 :            :     PyObject *ex;       /* corresponding exception */
     156                 :            : } DecCondMap;
     157                 :            : 
     158                 :            : /* Top level Exception; inherits from ArithmeticError */
     159                 :            : static PyObject *DecimalException = NULL;
     160                 :            : 
     161                 :            : /* Exceptions that correspond to IEEE signals */
     162                 :            : #define SUBNORMAL 5
     163                 :            : #define INEXACT 6
     164                 :            : #define ROUNDED 7
     165                 :            : #define SIGNAL_MAP_LEN 9
     166                 :            : static DecCondMap signal_map[] = {
     167                 :            :   {"InvalidOperation", "decimal.InvalidOperation", MPD_IEEE_Invalid_operation, NULL},
     168                 :            :   {"FloatOperation", "decimal.FloatOperation", MPD_Float_operation, NULL},
     169                 :            :   {"DivisionByZero", "decimal.DivisionByZero", MPD_Division_by_zero, NULL},
     170                 :            :   {"Overflow", "decimal.Overflow", MPD_Overflow, NULL},
     171                 :            :   {"Underflow", "decimal.Underflow", MPD_Underflow, NULL},
     172                 :            :   {"Subnormal", "decimal.Subnormal", MPD_Subnormal, NULL},
     173                 :            :   {"Inexact", "decimal.Inexact", MPD_Inexact, NULL},
     174                 :            :   {"Rounded", "decimal.Rounded", MPD_Rounded, NULL},
     175                 :            :   {"Clamped", "decimal.Clamped", MPD_Clamped, NULL},
     176                 :            :   {NULL}
     177                 :            : };
     178                 :            : 
     179                 :            : /* Exceptions that inherit from InvalidOperation */
     180                 :            : static DecCondMap cond_map[] = {
     181                 :            :   {"InvalidOperation", "decimal.InvalidOperation", MPD_Invalid_operation, NULL},
     182                 :            :   {"ConversionSyntax", "decimal.ConversionSyntax", MPD_Conversion_syntax, NULL},
     183                 :            :   {"DivisionImpossible", "decimal.DivisionImpossible", MPD_Division_impossible, NULL},
     184                 :            :   {"DivisionUndefined", "decimal.DivisionUndefined", MPD_Division_undefined, NULL},
     185                 :            :   {"InvalidContext", "decimal.InvalidContext", MPD_Invalid_context, NULL},
     186                 :            : #ifdef EXTRA_FUNCTIONALITY
     187                 :            :   {"MallocError", "decimal.MallocError", MPD_Malloc_error, NULL},
     188                 :            : #endif
     189                 :            :   {NULL}
     190                 :            : };
     191                 :            : 
     192                 :            : static const char *dec_signal_string[MPD_NUM_FLAGS] = {
     193                 :            :     "Clamped",
     194                 :            :     "InvalidOperation",
     195                 :            :     "DivisionByZero",
     196                 :            :     "InvalidOperation",
     197                 :            :     "InvalidOperation",
     198                 :            :     "InvalidOperation",
     199                 :            :     "Inexact",
     200                 :            :     "InvalidOperation",
     201                 :            :     "InvalidOperation",
     202                 :            :     "InvalidOperation",
     203                 :            :     "FloatOperation",
     204                 :            :     "Overflow",
     205                 :            :     "Rounded",
     206                 :            :     "Subnormal",
     207                 :            :     "Underflow",
     208                 :            : };
     209                 :            : 
     210                 :            : #ifdef EXTRA_FUNCTIONALITY
     211                 :            :   #define _PY_DEC_ROUND_GUARD MPD_ROUND_GUARD
     212                 :            : #else
     213                 :            :   #define _PY_DEC_ROUND_GUARD (MPD_ROUND_GUARD-1)
     214                 :            : #endif
     215                 :            : static PyObject *round_map[_PY_DEC_ROUND_GUARD];
     216                 :            : 
     217                 :            : static const char *invalid_rounding_err =
     218                 :            : "valid values for rounding are:\n\
     219                 :            :   [ROUND_CEILING, ROUND_FLOOR, ROUND_UP, ROUND_DOWN,\n\
     220                 :            :    ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN,\n\
     221                 :            :    ROUND_05UP]";
     222                 :            : 
     223                 :            : static const char *invalid_signals_err =
     224                 :            : "valid values for signals are:\n\
     225                 :            :   [InvalidOperation, FloatOperation, DivisionByZero,\n\
     226                 :            :    Overflow, Underflow, Subnormal, Inexact, Rounded,\n\
     227                 :            :    Clamped]";
     228                 :            : 
     229                 :            : #ifdef EXTRA_FUNCTIONALITY
     230                 :            : static const char *invalid_flags_err =
     231                 :            : "valid values for _flags or _traps are:\n\
     232                 :            :   signals:\n\
     233                 :            :     [DecIEEEInvalidOperation, DecFloatOperation, DecDivisionByZero,\n\
     234                 :            :      DecOverflow, DecUnderflow, DecSubnormal, DecInexact, DecRounded,\n\
     235                 :            :      DecClamped]\n\
     236                 :            :   conditions which trigger DecIEEEInvalidOperation:\n\
     237                 :            :     [DecInvalidOperation, DecConversionSyntax, DecDivisionImpossible,\n\
     238                 :            :      DecDivisionUndefined, DecFpuError, DecInvalidContext, DecMallocError]";
     239                 :            : #endif
     240                 :            : 
     241                 :            : static int
     242                 :          0 : value_error_int(const char *mesg)
     243                 :            : {
     244                 :          0 :     PyErr_SetString(PyExc_ValueError, mesg);
     245                 :          0 :     return -1;
     246                 :            : }
     247                 :            : 
     248                 :            : #ifdef CONFIG_32
     249                 :            : static PyObject *
     250                 :            : value_error_ptr(const char *mesg)
     251                 :            : {
     252                 :            :     PyErr_SetString(PyExc_ValueError, mesg);
     253                 :            :     return NULL;
     254                 :            : }
     255                 :            : #endif
     256                 :            : 
     257                 :            : static int
     258                 :          0 : type_error_int(const char *mesg)
     259                 :            : {
     260                 :          0 :     PyErr_SetString(PyExc_TypeError, mesg);
     261                 :          0 :     return -1;
     262                 :            : }
     263                 :            : 
     264                 :            : static int
     265                 :          0 : runtime_error_int(const char *mesg)
     266                 :            : {
     267                 :          0 :     PyErr_SetString(PyExc_RuntimeError, mesg);
     268                 :          0 :     return -1;
     269                 :            : }
     270                 :            : #define INTERNAL_ERROR_INT(funcname) \
     271                 :            :     return runtime_error_int("internal error in " funcname)
     272                 :            : 
     273                 :            : static PyObject *
     274                 :          0 : runtime_error_ptr(const char *mesg)
     275                 :            : {
     276                 :          0 :     PyErr_SetString(PyExc_RuntimeError, mesg);
     277                 :          0 :     return NULL;
     278                 :            : }
     279                 :            : #define INTERNAL_ERROR_PTR(funcname) \
     280                 :            :     return runtime_error_ptr("internal error in " funcname)
     281                 :            : 
     282                 :            : static void
     283                 :          0 : dec_traphandler(mpd_context_t *ctx UNUSED) /* GCOV_NOT_REACHED */
     284                 :            : { /* GCOV_NOT_REACHED */
     285                 :          0 :     return; /* GCOV_NOT_REACHED */
     286                 :            : }
     287                 :            : 
     288                 :            : static PyObject *
     289                 :          0 : flags_as_exception(uint32_t flags)
     290                 :            : {
     291                 :            :     DecCondMap *cm;
     292                 :            : 
     293         [ #  # ]:          0 :     for (cm = signal_map; cm->name != NULL; cm++) {
     294         [ #  # ]:          0 :         if (flags&cm->flag) {
     295                 :          0 :             return cm->ex;
     296                 :            :         }
     297                 :            :     }
     298                 :            : 
     299                 :          0 :     INTERNAL_ERROR_PTR("flags_as_exception"); /* GCOV_NOT_REACHED */
     300                 :            : }
     301                 :            : 
     302                 :            : Py_LOCAL_INLINE(uint32_t)
     303                 :          0 : exception_as_flag(PyObject *ex)
     304                 :            : {
     305                 :            :     DecCondMap *cm;
     306                 :            : 
     307         [ #  # ]:          0 :     for (cm = signal_map; cm->name != NULL; cm++) {
     308         [ #  # ]:          0 :         if (cm->ex == ex) {
     309                 :          0 :             return cm->flag;
     310                 :            :         }
     311                 :            :     }
     312                 :            : 
     313                 :          0 :     PyErr_SetString(PyExc_KeyError, invalid_signals_err);
     314                 :          0 :     return DEC_INVALID_SIGNALS;
     315                 :            : }
     316                 :            : 
     317                 :            : static PyObject *
     318                 :          0 : flags_as_list(uint32_t flags)
     319                 :            : {
     320                 :            :     PyObject *list;
     321                 :            :     DecCondMap *cm;
     322                 :            : 
     323                 :          0 :     list = PyList_New(0);
     324         [ #  # ]:          0 :     if (list == NULL) {
     325                 :          0 :         return NULL;
     326                 :            :     }
     327                 :            : 
     328         [ #  # ]:          0 :     for (cm = cond_map; cm->name != NULL; cm++) {
     329         [ #  # ]:          0 :         if (flags&cm->flag) {
     330         [ #  # ]:          0 :             if (PyList_Append(list, cm->ex) < 0) {
     331                 :          0 :                 goto error;
     332                 :            :             }
     333                 :            :         }
     334                 :            :     }
     335         [ #  # ]:          0 :     for (cm = signal_map+1; cm->name != NULL; cm++) {
     336         [ #  # ]:          0 :         if (flags&cm->flag) {
     337         [ #  # ]:          0 :             if (PyList_Append(list, cm->ex) < 0) {
     338                 :          0 :                 goto error;
     339                 :            :             }
     340                 :            :         }
     341                 :            :     }
     342                 :            : 
     343                 :          0 :     return list;
     344                 :            : 
     345                 :          0 : error:
     346                 :          0 :     Py_DECREF(list);
     347                 :          0 :     return NULL;
     348                 :            : }
     349                 :            : 
     350                 :            : static PyObject *
     351                 :          0 : signals_as_list(uint32_t flags)
     352                 :            : {
     353                 :            :     PyObject *list;
     354                 :            :     DecCondMap *cm;
     355                 :            : 
     356                 :          0 :     list = PyList_New(0);
     357         [ #  # ]:          0 :     if (list == NULL) {
     358                 :          0 :         return NULL;
     359                 :            :     }
     360                 :            : 
     361         [ #  # ]:          0 :     for (cm = signal_map; cm->name != NULL; cm++) {
     362         [ #  # ]:          0 :         if (flags&cm->flag) {
     363         [ #  # ]:          0 :             if (PyList_Append(list, cm->ex) < 0) {
     364                 :          0 :                 Py_DECREF(list);
     365                 :          0 :                 return NULL;
     366                 :            :             }
     367                 :            :         }
     368                 :            :     }
     369                 :            : 
     370                 :          0 :     return list;
     371                 :            : }
     372                 :            : 
     373                 :            : static uint32_t
     374                 :          0 : list_as_flags(PyObject *list)
     375                 :            : {
     376                 :            :     PyObject *item;
     377                 :            :     uint32_t flags, x;
     378                 :            :     Py_ssize_t n, j;
     379                 :            : 
     380                 :            :     assert(PyList_Check(list));
     381                 :            : 
     382                 :          0 :     n = PyList_Size(list);
     383                 :          0 :     flags = 0;
     384         [ #  # ]:          0 :     for (j = 0; j < n; j++) {
     385                 :          0 :         item = PyList_GetItem(list, j);
     386                 :          0 :         x = exception_as_flag(item);
     387         [ #  # ]:          0 :         if (x & DEC_ERRORS) {
     388                 :          0 :             return x;
     389                 :            :         }
     390                 :          0 :         flags |= x;
     391                 :            :     }
     392                 :            : 
     393                 :          0 :     return flags;
     394                 :            : }
     395                 :            : 
     396                 :            : static PyObject *
     397                 :          0 : flags_as_dict(uint32_t flags)
     398                 :            : {
     399                 :            :     DecCondMap *cm;
     400                 :            :     PyObject *dict;
     401                 :            : 
     402                 :          0 :     dict = PyDict_New();
     403         [ #  # ]:          0 :     if (dict == NULL) {
     404                 :          0 :         return NULL;
     405                 :            :     }
     406                 :            : 
     407         [ #  # ]:          0 :     for (cm = signal_map; cm->name != NULL; cm++) {
     408         [ #  # ]:          0 :         PyObject *b = flags&cm->flag ? Py_True : Py_False;
     409         [ #  # ]:          0 :         if (PyDict_SetItem(dict, cm->ex, b) < 0) {
     410                 :          0 :             Py_DECREF(dict);
     411                 :          0 :             return NULL;
     412                 :            :         }
     413                 :            :     }
     414                 :            : 
     415                 :          0 :     return dict;
     416                 :            : }
     417                 :            : 
     418                 :            : static uint32_t
     419                 :          0 : dict_as_flags(PyObject *val)
     420                 :            : {
     421                 :            :     PyObject *b;
     422                 :            :     DecCondMap *cm;
     423                 :          0 :     uint32_t flags = 0;
     424                 :            :     int x;
     425                 :            : 
     426         [ #  # ]:          0 :     if (!PyDict_Check(val)) {
     427                 :          0 :         PyErr_SetString(PyExc_TypeError,
     428                 :            :             "argument must be a signal dict");
     429                 :          0 :         return DEC_INVALID_SIGNALS;
     430                 :            :     }
     431                 :            : 
     432         [ #  # ]:          0 :     if (PyDict_Size(val) != SIGNAL_MAP_LEN) {
     433                 :          0 :         PyErr_SetString(PyExc_KeyError,
     434                 :            :             "invalid signal dict");
     435                 :          0 :         return DEC_INVALID_SIGNALS;
     436                 :            :     }
     437                 :            : 
     438         [ #  # ]:          0 :     for (cm = signal_map; cm->name != NULL; cm++) {
     439                 :          0 :         b = PyDict_GetItemWithError(val, cm->ex);
     440         [ #  # ]:          0 :         if (b == NULL) {
     441         [ #  # ]:          0 :             if (PyErr_Occurred()) {
     442                 :          0 :                 return DEC_ERR_OCCURRED;
     443                 :            :             }
     444                 :          0 :             PyErr_SetString(PyExc_KeyError,
     445                 :            :                 "invalid signal dict");
     446                 :          0 :             return DEC_INVALID_SIGNALS;
     447                 :            :         }
     448                 :            : 
     449                 :          0 :         x = PyObject_IsTrue(b);
     450         [ #  # ]:          0 :         if (x < 0) {
     451                 :          0 :             return DEC_ERR_OCCURRED;
     452                 :            :         }
     453         [ #  # ]:          0 :         if (x == 1) {
     454                 :          0 :             flags |= cm->flag;
     455                 :            :         }
     456                 :            :     }
     457                 :            : 
     458                 :          0 :     return flags;
     459                 :            : }
     460                 :            : 
     461                 :            : #ifdef EXTRA_FUNCTIONALITY
     462                 :            : static uint32_t
     463                 :            : long_as_flags(PyObject *v)
     464                 :            : {
     465                 :            :     long x;
     466                 :            : 
     467                 :            :     x = PyLong_AsLong(v);
     468                 :            :     if (x == -1 && PyErr_Occurred()) {
     469                 :            :         return DEC_ERR_OCCURRED;
     470                 :            :     }
     471                 :            :     if (x < 0 || x > (long)MPD_Max_status) {
     472                 :            :         PyErr_SetString(PyExc_TypeError, invalid_flags_err);
     473                 :            :         return DEC_INVALID_SIGNALS;
     474                 :            :     }
     475                 :            : 
     476                 :            :     return x;
     477                 :            : }
     478                 :            : #endif
     479                 :            : 
     480                 :            : static int
     481                 :        523 : dec_addstatus(PyObject *context, uint32_t status)
     482                 :            : {
     483                 :        523 :     mpd_context_t *ctx = CTX(context);
     484                 :            : 
     485                 :        523 :     ctx->status |= status;
     486         [ -  + ]:        523 :     if (status & (ctx->traps|MPD_Malloc_error)) {
     487                 :            :         PyObject *ex, *siglist;
     488                 :            : 
     489         [ #  # ]:          0 :         if (status & MPD_Malloc_error) {
     490                 :          0 :             PyErr_NoMemory();
     491                 :          0 :             return 1;
     492                 :            :         }
     493                 :            : 
     494                 :          0 :         ex = flags_as_exception(ctx->traps&status);
     495         [ #  # ]:          0 :         if (ex == NULL) {
     496                 :          0 :             return 1; /* GCOV_NOT_REACHED */
     497                 :            :         }
     498                 :          0 :         siglist = flags_as_list(ctx->traps&status);
     499         [ #  # ]:          0 :         if (siglist == NULL) {
     500                 :          0 :             return 1;
     501                 :            :         }
     502                 :            : 
     503                 :          0 :         PyErr_SetObject(ex, siglist);
     504                 :          0 :         Py_DECREF(siglist);
     505                 :          0 :         return 1;
     506                 :            :     }
     507                 :        523 :     return 0;
     508                 :            : }
     509                 :            : 
     510                 :            : static int
     511                 :          0 : getround(PyObject *v)
     512                 :            : {
     513                 :            :     int i;
     514                 :            : 
     515         [ #  # ]:          0 :     if (PyUnicode_Check(v)) {
     516         [ #  # ]:          0 :         for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {
     517         [ #  # ]:          0 :             if (v == round_map[i]) {
     518                 :          0 :                 return i;
     519                 :            :             }
     520                 :            :         }
     521         [ #  # ]:          0 :         for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {
     522         [ #  # ]:          0 :             if (PyUnicode_Compare(v, round_map[i]) == 0) {
     523                 :          0 :                 return i;
     524                 :            :             }
     525                 :            :         }
     526                 :            :     }
     527                 :            : 
     528                 :          0 :     return type_error_int(invalid_rounding_err);
     529                 :            : }
     530                 :            : 
     531                 :            : 
     532                 :            : /******************************************************************************/
     533                 :            : /*                            SignalDict Object                               */
     534                 :            : /******************************************************************************/
     535                 :            : 
     536                 :            : /* The SignalDict is a MutableMapping that provides access to the
     537                 :            :    mpd_context_t flags, which reside in the context object. When a
     538                 :            :    new context is created, context.traps and context.flags are
     539                 :            :    initialized to new SignalDicts. Once a SignalDict is tied to
     540                 :            :    a context, it cannot be deleted. */
     541                 :            : 
     542                 :            : static int
     543                 :         76 : signaldict_init(PyObject *self, PyObject *args UNUSED, PyObject *kwds UNUSED)
     544                 :            : {
     545                 :         76 :     SdFlagAddr(self) = NULL;
     546                 :         76 :     return 0;
     547                 :            : }
     548                 :            : 
     549                 :            : static Py_ssize_t
     550                 :          0 : signaldict_len(PyObject *self UNUSED)
     551                 :            : {
     552                 :          0 :     return SIGNAL_MAP_LEN;
     553                 :            : }
     554                 :            : 
     555                 :            : static PyObject *SignalTuple;
     556                 :            : static PyObject *
     557                 :          0 : signaldict_iter(PyObject *self UNUSED)
     558                 :            : {
     559                 :          0 :     return PyTuple_Type.tp_iter(SignalTuple);
     560                 :            : }
     561                 :            : 
     562                 :            : static PyObject *
     563                 :          0 : signaldict_getitem(PyObject *self, PyObject *key)
     564                 :            : {
     565                 :            :     uint32_t flag;
     566                 :            : 
     567                 :          0 :     flag = exception_as_flag(key);
     568         [ #  # ]:          0 :     if (flag & DEC_ERRORS) {
     569                 :          0 :         return NULL;
     570                 :            :     }
     571                 :            : 
     572         [ #  # ]:          0 :     return SdFlags(self)&flag ? incr_true() : incr_false();
     573                 :            : }
     574                 :            : 
     575                 :            : static int
     576                 :          0 : signaldict_setitem(PyObject *self, PyObject *key, PyObject *value)
     577                 :            : {
     578                 :            :     uint32_t flag;
     579                 :            :     int x;
     580                 :            : 
     581         [ #  # ]:          0 :     if (value == NULL) {
     582                 :          0 :         return value_error_int("signal keys cannot be deleted");
     583                 :            :     }
     584                 :            : 
     585                 :          0 :     flag = exception_as_flag(key);
     586         [ #  # ]:          0 :     if (flag & DEC_ERRORS) {
     587                 :          0 :         return -1;
     588                 :            :     }
     589                 :            : 
     590                 :          0 :     x = PyObject_IsTrue(value);
     591         [ #  # ]:          0 :     if (x < 0) {
     592                 :          0 :         return -1;
     593                 :            :     }
     594                 :            : 
     595         [ #  # ]:          0 :     if (x == 1) {
     596                 :          0 :         SdFlags(self) |= flag;
     597                 :            :     }
     598                 :            :     else {
     599                 :          0 :         SdFlags(self) &= ~flag;
     600                 :            :     }
     601                 :            : 
     602                 :          0 :     return 0;
     603                 :            : }
     604                 :            : 
     605                 :            : static PyObject *
     606                 :          0 : signaldict_repr(PyObject *self)
     607                 :            : {
     608                 :            :     DecCondMap *cm;
     609                 :            :     const char *n[SIGNAL_MAP_LEN]; /* name */
     610                 :            :     const char *b[SIGNAL_MAP_LEN]; /* bool */
     611                 :            :     int i;
     612                 :            : 
     613                 :            :     assert(SIGNAL_MAP_LEN == 9);
     614                 :            : 
     615         [ #  # ]:          0 :     for (cm=signal_map, i=0; cm->name != NULL; cm++, i++) {
     616                 :          0 :         n[i] = cm->fqname;
     617         [ #  # ]:          0 :         b[i] = SdFlags(self)&cm->flag ? "True" : "False";
     618                 :            :     }
     619                 :          0 :     return PyUnicode_FromFormat(
     620                 :            :         "{<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s, "
     621                 :            :          "<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s, "
     622                 :            :          "<class '%s'>:%s, <class '%s'>:%s, <class '%s'>:%s}",
     623                 :            :             n[0], b[0], n[1], b[1], n[2], b[2],
     624                 :            :             n[3], b[3], n[4], b[4], n[5], b[5],
     625                 :            :             n[6], b[6], n[7], b[7], n[8], b[8]);
     626                 :            : }
     627                 :            : 
     628                 :            : static PyObject *
     629                 :          0 : signaldict_richcompare(PyObject *v, PyObject *w, int op)
     630                 :            : {
     631                 :          0 :     PyObject *res = Py_NotImplemented;
     632                 :            : 
     633                 :            :     assert(PyDecSignalDict_Check(v));
     634                 :            : 
     635   [ #  #  #  # ]:          0 :     if (op == Py_EQ || op == Py_NE) {
     636         [ #  # ]:          0 :         if (PyDecSignalDict_Check(w)) {
     637         [ #  # ]:          0 :             res = (SdFlags(v)==SdFlags(w)) ^ (op==Py_NE) ? Py_True : Py_False;
     638                 :            :         }
     639         [ #  # ]:          0 :         else if (PyDict_Check(w)) {
     640                 :          0 :             uint32_t flags = dict_as_flags(w);
     641         [ #  # ]:          0 :             if (flags & DEC_ERRORS) {
     642         [ #  # ]:          0 :                 if (flags & DEC_INVALID_SIGNALS) {
     643                 :            :                     /* non-comparable: Py_NotImplemented */
     644                 :          0 :                     PyErr_Clear();
     645                 :            :                 }
     646                 :            :                 else {
     647                 :          0 :                     return NULL;
     648                 :            :                 }
     649                 :            :             }
     650                 :            :             else {
     651         [ #  # ]:          0 :                 res = (SdFlags(v)==flags) ^ (op==Py_NE) ? Py_True : Py_False;
     652                 :            :             }
     653                 :            :         }
     654                 :            :     }
     655                 :            : 
     656                 :          0 :     return Py_NewRef(res);
     657                 :            : }
     658                 :            : 
     659                 :            : static PyObject *
     660                 :          0 : signaldict_copy(PyObject *self, PyObject *args UNUSED)
     661                 :            : {
     662                 :          0 :     return flags_as_dict(SdFlags(self));
     663                 :            : }
     664                 :            : 
     665                 :            : 
     666                 :            : static PyMappingMethods signaldict_as_mapping = {
     667                 :            :     (lenfunc)signaldict_len,          /* mp_length */
     668                 :            :     (binaryfunc)signaldict_getitem,   /* mp_subscript */
     669                 :            :     (objobjargproc)signaldict_setitem /* mp_ass_subscript */
     670                 :            : };
     671                 :            : 
     672                 :            : static PyMethodDef signaldict_methods[] = {
     673                 :            :     { "copy", (PyCFunction)signaldict_copy, METH_NOARGS, NULL},
     674                 :            :     {NULL, NULL}
     675                 :            : };
     676                 :            : 
     677                 :            : 
     678                 :            : static PyTypeObject PyDecSignalDictMixin_Type =
     679                 :            : {
     680                 :            :     PyVarObject_HEAD_INIT(0, 0)
     681                 :            :     "decimal.SignalDictMixin",                /* tp_name */
     682                 :            :     sizeof(PyDecSignalDictObject),            /* tp_basicsize */
     683                 :            :     0,                                        /* tp_itemsize */
     684                 :            :     0,                                        /* tp_dealloc */
     685                 :            :     0,                                        /* tp_vectorcall_offset */
     686                 :            :     (getattrfunc) 0,                          /* tp_getattr */
     687                 :            :     (setattrfunc) 0,                          /* tp_setattr */
     688                 :            :     0,                                        /* tp_as_async */
     689                 :            :     (reprfunc) signaldict_repr,               /* tp_repr */
     690                 :            :     0,                                        /* tp_as_number */
     691                 :            :     0,                                        /* tp_as_sequence */
     692                 :            :     &signaldict_as_mapping,                   /* tp_as_mapping */
     693                 :            :     PyObject_HashNotImplemented,              /* tp_hash */
     694                 :            :     0,                                        /* tp_call */
     695                 :            :     (reprfunc) 0,                             /* tp_str */
     696                 :            :     PyObject_GenericGetAttr,                  /* tp_getattro */
     697                 :            :     (setattrofunc) 0,                         /* tp_setattro */
     698                 :            :     (PyBufferProcs *) 0,                      /* tp_as_buffer */
     699                 :            :     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,   /* tp_flags */
     700                 :            :     0,                                        /* tp_doc */
     701                 :            :     0,                                        /* tp_traverse */
     702                 :            :     0,                                        /* tp_clear */
     703                 :            :     signaldict_richcompare,                   /* tp_richcompare */
     704                 :            :     0,                                        /* tp_weaklistoffset */
     705                 :            :     (getiterfunc)signaldict_iter,             /* tp_iter */
     706                 :            :     0,                                        /* tp_iternext */
     707                 :            :     signaldict_methods,                       /* tp_methods */
     708                 :            :     0,                                        /* tp_members */
     709                 :            :     0,                                        /* tp_getset */
     710                 :            :     0,                                        /* tp_base */
     711                 :            :     0,                                        /* tp_dict */
     712                 :            :     0,                                        /* tp_descr_get */
     713                 :            :     0,                                        /* tp_descr_set */
     714                 :            :     0,                                        /* tp_dictoffset */
     715                 :            :     (initproc)signaldict_init,                /* tp_init */
     716                 :            :     0,                                        /* tp_alloc */
     717                 :            :     PyType_GenericNew,                        /* tp_new */
     718                 :            : };
     719                 :            : 
     720                 :            : 
     721                 :            : /******************************************************************************/
     722                 :            : /*                         Context Object, Part 1                             */
     723                 :            : /******************************************************************************/
     724                 :            : 
     725                 :            : #define Dec_CONTEXT_GET_SSIZE(mem) \
     726                 :            : static PyObject *                                       \
     727                 :            : context_get##mem(PyObject *self, void *closure UNUSED)  \
     728                 :            : {                                                       \
     729                 :            :     return PyLong_FromSsize_t(mpd_get##mem(CTX(self))); \
     730                 :            : }
     731                 :            : 
     732                 :            : #define Dec_CONTEXT_GET_ULONG(mem) \
     733                 :            : static PyObject *                                            \
     734                 :            : context_get##mem(PyObject *self, void *closure UNUSED)       \
     735                 :            : {                                                            \
     736                 :            :     return PyLong_FromUnsignedLong(mpd_get##mem(CTX(self))); \
     737                 :            : }
     738                 :            : 
     739                 :          0 : Dec_CONTEXT_GET_SSIZE(prec)
     740                 :          0 : Dec_CONTEXT_GET_SSIZE(emax)
     741                 :          0 : Dec_CONTEXT_GET_SSIZE(emin)
     742                 :          0 : Dec_CONTEXT_GET_SSIZE(clamp)
     743                 :            : 
     744                 :            : #ifdef EXTRA_FUNCTIONALITY
     745                 :            : Dec_CONTEXT_GET_ULONG(traps)
     746                 :            : Dec_CONTEXT_GET_ULONG(status)
     747                 :            : #endif
     748                 :            : 
     749                 :            : static PyObject *
     750                 :          0 : context_getround(PyObject *self, void *closure UNUSED)
     751                 :            : {
     752                 :          0 :     int i = mpd_getround(CTX(self));
     753                 :            : 
     754                 :          0 :     return Py_NewRef(round_map[i]);
     755                 :            : }
     756                 :            : 
     757                 :            : static PyObject *
     758                 :          0 : context_getcapitals(PyObject *self, void *closure UNUSED)
     759                 :            : {
     760                 :          0 :     return PyLong_FromLong(CtxCaps(self));
     761                 :            : }
     762                 :            : 
     763                 :            : #ifdef EXTRA_FUNCTIONALITY
     764                 :            : static PyObject *
     765                 :            : context_getallcr(PyObject *self, void *closure UNUSED)
     766                 :            : {
     767                 :            :     return PyLong_FromLong(mpd_getcr(CTX(self)));
     768                 :            : }
     769                 :            : #endif
     770                 :            : 
     771                 :            : static PyObject *
     772                 :          0 : context_getetiny(PyObject *self, PyObject *dummy UNUSED)
     773                 :            : {
     774                 :          0 :     return PyLong_FromSsize_t(mpd_etiny(CTX(self)));
     775                 :            : }
     776                 :            : 
     777                 :            : static PyObject *
     778                 :          0 : context_getetop(PyObject *self, PyObject *dummy UNUSED)
     779                 :            : {
     780                 :          0 :     return PyLong_FromSsize_t(mpd_etop(CTX(self)));
     781                 :            : }
     782                 :            : 
     783                 :            : static int
     784                 :          1 : context_setprec(PyObject *self, PyObject *value, void *closure UNUSED)
     785                 :            : {
     786                 :            :     mpd_context_t *ctx;
     787                 :            :     mpd_ssize_t x;
     788                 :            : 
     789                 :          1 :     x = PyLong_AsSsize_t(value);
     790   [ -  +  -  - ]:          1 :     if (x == -1 && PyErr_Occurred()) {
     791                 :          0 :         return -1;
     792                 :            :     }
     793                 :            : 
     794                 :          1 :     ctx = CTX(self);
     795         [ -  + ]:          1 :     if (!mpd_qsetprec(ctx, x)) {
     796                 :          0 :         return value_error_int(
     797                 :            :             "valid range for prec is [1, MAX_PREC]");
     798                 :            :     }
     799                 :            : 
     800                 :          1 :     return 0;
     801                 :            : }
     802                 :            : 
     803                 :            : static int
     804                 :          0 : context_setemin(PyObject *self, PyObject *value, void *closure UNUSED)
     805                 :            : {
     806                 :            :     mpd_context_t *ctx;
     807                 :            :     mpd_ssize_t x;
     808                 :            : 
     809                 :          0 :     x = PyLong_AsSsize_t(value);
     810   [ #  #  #  # ]:          0 :     if (x == -1 && PyErr_Occurred()) {
     811                 :          0 :         return -1;
     812                 :            :     }
     813                 :            : 
     814                 :          0 :     ctx = CTX(self);
     815         [ #  # ]:          0 :     if (!mpd_qsetemin(ctx, x)) {
     816                 :          0 :         return value_error_int(
     817                 :            :             "valid range for Emin is [MIN_EMIN, 0]");
     818                 :            :     }
     819                 :            : 
     820                 :          0 :     return 0;
     821                 :            : }
     822                 :            : 
     823                 :            : static int
     824                 :          0 : context_setemax(PyObject *self, PyObject *value, void *closure UNUSED)
     825                 :            : {
     826                 :            :     mpd_context_t *ctx;
     827                 :            :     mpd_ssize_t x;
     828                 :            : 
     829                 :          0 :     x = PyLong_AsSsize_t(value);
     830   [ #  #  #  # ]:          0 :     if (x == -1 && PyErr_Occurred()) {
     831                 :          0 :         return -1;
     832                 :            :     }
     833                 :            : 
     834                 :          0 :     ctx = CTX(self);
     835         [ #  # ]:          0 :     if (!mpd_qsetemax(ctx, x)) {
     836                 :          0 :         return value_error_int(
     837                 :            :             "valid range for Emax is [0, MAX_EMAX]");
     838                 :            :     }
     839                 :            : 
     840                 :          0 :     return 0;
     841                 :            : }
     842                 :            : 
     843                 :            : #ifdef CONFIG_32
     844                 :            : static PyObject *
     845                 :            : context_unsafe_setprec(PyObject *self, PyObject *value)
     846                 :            : {
     847                 :            :     mpd_context_t *ctx = CTX(self);
     848                 :            :     mpd_ssize_t x;
     849                 :            : 
     850                 :            :     x = PyLong_AsSsize_t(value);
     851                 :            :     if (x == -1 && PyErr_Occurred()) {
     852                 :            :         return NULL;
     853                 :            :     }
     854                 :            : 
     855                 :            :     if (x < 1 || x > 1070000000L) {
     856                 :            :         return value_error_ptr(
     857                 :            :             "valid range for unsafe prec is [1, 1070000000]");
     858                 :            :     }
     859                 :            : 
     860                 :            :     ctx->prec = x;
     861                 :            :     Py_RETURN_NONE;
     862                 :            : }
     863                 :            : 
     864                 :            : static PyObject *
     865                 :            : context_unsafe_setemin(PyObject *self, PyObject *value)
     866                 :            : {
     867                 :            :     mpd_context_t *ctx = CTX(self);
     868                 :            :     mpd_ssize_t x;
     869                 :            : 
     870                 :            :     x = PyLong_AsSsize_t(value);
     871                 :            :     if (x == -1 && PyErr_Occurred()) {
     872                 :            :         return NULL;
     873                 :            :     }
     874                 :            : 
     875                 :            :     if (x < -1070000000L || x > 0) {
     876                 :            :         return value_error_ptr(
     877                 :            :             "valid range for unsafe emin is [-1070000000, 0]");
     878                 :            :     }
     879                 :            : 
     880                 :            :     ctx->emin = x;
     881                 :            :     Py_RETURN_NONE;
     882                 :            : }
     883                 :            : 
     884                 :            : static PyObject *
     885                 :            : context_unsafe_setemax(PyObject *self, PyObject *value)
     886                 :            : {
     887                 :            :     mpd_context_t *ctx = CTX(self);
     888                 :            :     mpd_ssize_t x;
     889                 :            : 
     890                 :            :     x = PyLong_AsSsize_t(value);
     891                 :            :     if (x == -1 && PyErr_Occurred()) {
     892                 :            :         return NULL;
     893                 :            :     }
     894                 :            : 
     895                 :            :     if (x < 0 || x > 1070000000L) {
     896                 :            :         return value_error_ptr(
     897                 :            :             "valid range for unsafe emax is [0, 1070000000]");
     898                 :            :     }
     899                 :            : 
     900                 :            :     ctx->emax = x;
     901                 :            :     Py_RETURN_NONE;
     902                 :            : }
     903                 :            : #endif
     904                 :            : 
     905                 :            : static int
     906                 :          0 : context_setround(PyObject *self, PyObject *value, void *closure UNUSED)
     907                 :            : {
     908                 :            :     mpd_context_t *ctx;
     909                 :            :     int x;
     910                 :            : 
     911                 :          0 :     x = getround(value);
     912         [ #  # ]:          0 :     if (x == -1) {
     913                 :          0 :         return -1;
     914                 :            :     }
     915                 :            : 
     916                 :          0 :     ctx = CTX(self);
     917         [ #  # ]:          0 :     if (!mpd_qsetround(ctx, x)) {
     918                 :          0 :         INTERNAL_ERROR_INT("context_setround"); /* GCOV_NOT_REACHED */
     919                 :            :     }
     920                 :            : 
     921                 :          0 :     return 0;
     922                 :            : }
     923                 :            : 
     924                 :            : static int
     925                 :          0 : context_setcapitals(PyObject *self, PyObject *value, void *closure UNUSED)
     926                 :            : {
     927                 :            :     mpd_ssize_t x;
     928                 :            : 
     929                 :          0 :     x = PyLong_AsSsize_t(value);
     930   [ #  #  #  # ]:          0 :     if (x == -1 && PyErr_Occurred()) {
     931                 :          0 :         return -1;
     932                 :            :     }
     933                 :            : 
     934   [ #  #  #  # ]:          0 :     if (x != 0 && x != 1) {
     935                 :          0 :         return value_error_int(
     936                 :            :             "valid values for capitals are 0 or 1");
     937                 :            :     }
     938                 :          0 :     CtxCaps(self) = (int)x;
     939                 :            : 
     940                 :          0 :     return 0;
     941                 :            : }
     942                 :            : 
     943                 :            : #ifdef EXTRA_FUNCTIONALITY
     944                 :            : static int
     945                 :            : context_settraps(PyObject *self, PyObject *value, void *closure UNUSED)
     946                 :            : {
     947                 :            :     mpd_context_t *ctx;
     948                 :            :     uint32_t flags;
     949                 :            : 
     950                 :            :     flags = long_as_flags(value);
     951                 :            :     if (flags & DEC_ERRORS) {
     952                 :            :         return -1;
     953                 :            :     }
     954                 :            : 
     955                 :            :     ctx = CTX(self);
     956                 :            :     if (!mpd_qsettraps(ctx, flags)) {
     957                 :            :         INTERNAL_ERROR_INT("context_settraps");
     958                 :            :     }
     959                 :            : 
     960                 :            :     return 0;
     961                 :            : }
     962                 :            : #endif
     963                 :            : 
     964                 :            : static int
     965                 :          0 : context_settraps_list(PyObject *self, PyObject *value)
     966                 :            : {
     967                 :            :     mpd_context_t *ctx;
     968                 :            :     uint32_t flags;
     969                 :            : 
     970                 :          0 :     flags = list_as_flags(value);
     971         [ #  # ]:          0 :     if (flags & DEC_ERRORS) {
     972                 :          0 :         return -1;
     973                 :            :     }
     974                 :            : 
     975                 :          0 :     ctx = CTX(self);
     976         [ #  # ]:          0 :     if (!mpd_qsettraps(ctx, flags)) {
     977                 :          0 :         INTERNAL_ERROR_INT("context_settraps_list");
     978                 :            :     }
     979                 :            : 
     980                 :          0 :     return 0;
     981                 :            : }
     982                 :            : 
     983                 :            : static int
     984                 :          0 : context_settraps_dict(PyObject *self, PyObject *value)
     985                 :            : {
     986                 :            :     mpd_context_t *ctx;
     987                 :            :     uint32_t flags;
     988                 :            : 
     989         [ #  # ]:          0 :     if (PyDecSignalDict_Check(value)) {
     990                 :          0 :         flags = SdFlags(value);
     991                 :            :     }
     992                 :            :     else {
     993                 :          0 :         flags = dict_as_flags(value);
     994         [ #  # ]:          0 :         if (flags & DEC_ERRORS) {
     995                 :          0 :             return -1;
     996                 :            :         }
     997                 :            :     }
     998                 :            : 
     999                 :          0 :     ctx = CTX(self);
    1000         [ #  # ]:          0 :     if (!mpd_qsettraps(ctx, flags)) {
    1001                 :          0 :         INTERNAL_ERROR_INT("context_settraps_dict");
    1002                 :            :     }
    1003                 :            : 
    1004                 :          0 :     return 0;
    1005                 :            : }
    1006                 :            : 
    1007                 :            : #ifdef EXTRA_FUNCTIONALITY
    1008                 :            : static int
    1009                 :            : context_setstatus(PyObject *self, PyObject *value, void *closure UNUSED)
    1010                 :            : {
    1011                 :            :     mpd_context_t *ctx;
    1012                 :            :     uint32_t flags;
    1013                 :            : 
    1014                 :            :     flags = long_as_flags(value);
    1015                 :            :     if (flags & DEC_ERRORS) {
    1016                 :            :         return -1;
    1017                 :            :     }
    1018                 :            : 
    1019                 :            :     ctx = CTX(self);
    1020                 :            :     if (!mpd_qsetstatus(ctx, flags)) {
    1021                 :            :         INTERNAL_ERROR_INT("context_setstatus");
    1022                 :            :     }
    1023                 :            : 
    1024                 :            :     return 0;
    1025                 :            : }
    1026                 :            : #endif
    1027                 :            : 
    1028                 :            : static int
    1029                 :          0 : context_setstatus_list(PyObject *self, PyObject *value)
    1030                 :            : {
    1031                 :            :     mpd_context_t *ctx;
    1032                 :            :     uint32_t flags;
    1033                 :            : 
    1034                 :          0 :     flags = list_as_flags(value);
    1035         [ #  # ]:          0 :     if (flags & DEC_ERRORS) {
    1036                 :          0 :         return -1;
    1037                 :            :     }
    1038                 :            : 
    1039                 :          0 :     ctx = CTX(self);
    1040         [ #  # ]:          0 :     if (!mpd_qsetstatus(ctx, flags)) {
    1041                 :          0 :         INTERNAL_ERROR_INT("context_setstatus_list");
    1042                 :            :     }
    1043                 :            : 
    1044                 :          0 :     return 0;
    1045                 :            : }
    1046                 :            : 
    1047                 :            : static int
    1048                 :          0 : context_setstatus_dict(PyObject *self, PyObject *value)
    1049                 :            : {
    1050                 :            :     mpd_context_t *ctx;
    1051                 :            :     uint32_t flags;
    1052                 :            : 
    1053         [ #  # ]:          0 :     if (PyDecSignalDict_Check(value)) {
    1054                 :          0 :         flags = SdFlags(value);
    1055                 :            :     }
    1056                 :            :     else {
    1057                 :          0 :         flags = dict_as_flags(value);
    1058         [ #  # ]:          0 :         if (flags & DEC_ERRORS) {
    1059                 :          0 :             return -1;
    1060                 :            :         }
    1061                 :            :     }
    1062                 :            : 
    1063                 :          0 :     ctx = CTX(self);
    1064         [ #  # ]:          0 :     if (!mpd_qsetstatus(ctx, flags)) {
    1065                 :          0 :         INTERNAL_ERROR_INT("context_setstatus_dict");
    1066                 :            :     }
    1067                 :            : 
    1068                 :          0 :     return 0;
    1069                 :            : }
    1070                 :            : 
    1071                 :            : static int
    1072                 :          0 : context_setclamp(PyObject *self, PyObject *value, void *closure UNUSED)
    1073                 :            : {
    1074                 :            :     mpd_context_t *ctx;
    1075                 :            :     mpd_ssize_t x;
    1076                 :            : 
    1077                 :          0 :     x = PyLong_AsSsize_t(value);
    1078   [ #  #  #  # ]:          0 :     if (x == -1 && PyErr_Occurred()) {
    1079                 :          0 :         return -1;
    1080                 :            :     }
    1081   [ #  #  #  # ]:          0 :     BOUNDS_CHECK(x, INT_MIN, INT_MAX);
    1082                 :            : 
    1083                 :          0 :     ctx = CTX(self);
    1084         [ #  # ]:          0 :     if (!mpd_qsetclamp(ctx, (int)x)) {
    1085                 :          0 :         return value_error_int("valid values for clamp are 0 or 1");
    1086                 :            :     }
    1087                 :            : 
    1088                 :          0 :     return 0;
    1089                 :            : }
    1090                 :            : 
    1091                 :            : #ifdef EXTRA_FUNCTIONALITY
    1092                 :            : static int
    1093                 :            : context_setallcr(PyObject *self, PyObject *value, void *closure UNUSED)
    1094                 :            : {
    1095                 :            :     mpd_context_t *ctx;
    1096                 :            :     mpd_ssize_t x;
    1097                 :            : 
    1098                 :            :     x = PyLong_AsSsize_t(value);
    1099                 :            :     if (x == -1 && PyErr_Occurred()) {
    1100                 :            :         return -1;
    1101                 :            :     }
    1102                 :            :     BOUNDS_CHECK(x, INT_MIN, INT_MAX);
    1103                 :            : 
    1104                 :            :     ctx = CTX(self);
    1105                 :            :     if (!mpd_qsetcr(ctx, (int)x)) {
    1106                 :            :         return value_error_int("valid values for _allcr are 0 or 1");
    1107                 :            :     }
    1108                 :            : 
    1109                 :            :     return 0;
    1110                 :            : }
    1111                 :            : #endif
    1112                 :            : 
    1113                 :            : static PyObject *
    1114                 :          0 : context_getattr(PyObject *self, PyObject *name)
    1115                 :            : {
    1116                 :            :     PyObject *retval;
    1117                 :            : 
    1118         [ #  # ]:          0 :     if (PyUnicode_Check(name)) {
    1119         [ #  # ]:          0 :         if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
    1120                 :          0 :             retval = ((PyDecContextObject *)self)->traps;
    1121                 :          0 :             return Py_NewRef(retval);
    1122                 :            :         }
    1123         [ #  # ]:          0 :         if (PyUnicode_CompareWithASCIIString(name, "flags") == 0) {
    1124                 :          0 :             retval = ((PyDecContextObject *)self)->flags;
    1125                 :          0 :             return Py_NewRef(retval);
    1126                 :            :         }
    1127                 :            :     }
    1128                 :            : 
    1129                 :          0 :     return PyObject_GenericGetAttr(self, name);
    1130                 :            : }
    1131                 :            : 
    1132                 :            : static int
    1133                 :          0 : context_setattr(PyObject *self, PyObject *name, PyObject *value)
    1134                 :            : {
    1135         [ #  # ]:          0 :     if (value == NULL) {
    1136                 :          0 :         PyErr_SetString(PyExc_AttributeError,
    1137                 :            :             "context attributes cannot be deleted");
    1138                 :          0 :         return -1;
    1139                 :            :     }
    1140                 :            : 
    1141         [ #  # ]:          0 :     if (PyUnicode_Check(name)) {
    1142         [ #  # ]:          0 :         if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
    1143                 :          0 :             return context_settraps_dict(self, value);
    1144                 :            :         }
    1145         [ #  # ]:          0 :         if (PyUnicode_CompareWithASCIIString(name, "flags") == 0) {
    1146                 :          0 :             return context_setstatus_dict(self, value);
    1147                 :            :         }
    1148                 :            :     }
    1149                 :            : 
    1150                 :          0 :     return PyObject_GenericSetAttr(self, name, value);
    1151                 :            : }
    1152                 :            : 
    1153                 :            : static int
    1154                 :         68 : context_setattrs(PyObject *self, PyObject *prec, PyObject *rounding,
    1155                 :            :                  PyObject *emin, PyObject *emax, PyObject *capitals,
    1156                 :            :                  PyObject *clamp, PyObject *status, PyObject *traps) {
    1157                 :            : 
    1158                 :            :     int ret;
    1159   [ +  +  -  + ]:         68 :     if (prec != Py_None && context_setprec(self, prec, NULL) < 0) {
    1160                 :          0 :         return -1;
    1161                 :            :     }
    1162   [ -  +  -  - ]:         68 :     if (rounding != Py_None && context_setround(self, rounding, NULL) < 0) {
    1163                 :          0 :         return -1;
    1164                 :            :     }
    1165   [ -  +  -  - ]:         68 :     if (emin != Py_None && context_setemin(self, emin, NULL) < 0) {
    1166                 :          0 :         return -1;
    1167                 :            :     }
    1168   [ -  +  -  - ]:         68 :     if (emax != Py_None && context_setemax(self, emax, NULL) < 0) {
    1169                 :          0 :         return -1;
    1170                 :            :     }
    1171   [ -  +  -  - ]:         68 :     if (capitals != Py_None && context_setcapitals(self, capitals, NULL) < 0) {
    1172                 :          0 :         return -1;
    1173                 :            :     }
    1174   [ -  +  -  - ]:         68 :     if (clamp != Py_None && context_setclamp(self, clamp, NULL) < 0) {
    1175                 :          0 :        return -1;
    1176                 :            :     }
    1177                 :            : 
    1178         [ -  + ]:         68 :     if (traps != Py_None) {
    1179         [ #  # ]:          0 :         if (PyList_Check(traps)) {
    1180                 :          0 :             ret = context_settraps_list(self, traps);
    1181                 :            :         }
    1182                 :            : #ifdef EXTRA_FUNCTIONALITY
    1183                 :            :         else if (PyLong_Check(traps)) {
    1184                 :            :             ret = context_settraps(self, traps, NULL);
    1185                 :            :         }
    1186                 :            : #endif
    1187                 :            :         else {
    1188                 :          0 :             ret = context_settraps_dict(self, traps);
    1189                 :            :         }
    1190         [ #  # ]:          0 :         if (ret < 0) {
    1191                 :          0 :             return ret;
    1192                 :            :         }
    1193                 :            :     }
    1194         [ -  + ]:         68 :     if (status != Py_None) {
    1195         [ #  # ]:          0 :         if (PyList_Check(status)) {
    1196                 :          0 :             ret = context_setstatus_list(self, status);
    1197                 :            :         }
    1198                 :            : #ifdef EXTRA_FUNCTIONALITY
    1199                 :            :         else if (PyLong_Check(status)) {
    1200                 :            :             ret = context_setstatus(self, status, NULL);
    1201                 :            :         }
    1202                 :            : #endif
    1203                 :            :         else {
    1204                 :          0 :             ret = context_setstatus_dict(self, status);
    1205                 :            :         }
    1206         [ #  # ]:          0 :         if (ret < 0) {
    1207                 :          0 :             return ret;
    1208                 :            :         }
    1209                 :            :     }
    1210                 :            : 
    1211                 :         68 :     return 0;
    1212                 :            : }
    1213                 :            : 
    1214                 :            : static PyObject *
    1215                 :          0 : context_clear_traps(PyObject *self, PyObject *dummy UNUSED)
    1216                 :            : {
    1217                 :          0 :     CTX(self)->traps = 0;
    1218                 :          0 :     Py_RETURN_NONE;
    1219                 :            : }
    1220                 :            : 
    1221                 :            : static PyObject *
    1222                 :          0 : context_clear_flags(PyObject *self, PyObject *dummy UNUSED)
    1223                 :            : {
    1224                 :          0 :     CTX(self)->status = 0;
    1225                 :          0 :     Py_RETURN_NONE;
    1226                 :            : }
    1227                 :            : 
    1228                 :            : #define DEC_DFLT_EMAX 999999
    1229                 :            : #define DEC_DFLT_EMIN -999999
    1230                 :            : 
    1231                 :            : static mpd_context_t dflt_ctx = {
    1232                 :            :   28, DEC_DFLT_EMAX, DEC_DFLT_EMIN,
    1233                 :            :   MPD_IEEE_Invalid_operation|MPD_Division_by_zero|MPD_Overflow,
    1234                 :            :   0, 0, MPD_ROUND_HALF_EVEN, 0, 1
    1235                 :            : };
    1236                 :            : 
    1237                 :            : static PyObject *
    1238                 :         38 : context_new(PyTypeObject *type, PyObject *args UNUSED, PyObject *kwds UNUSED)
    1239                 :            : {
    1240                 :         38 :     PyDecContextObject *self = NULL;
    1241                 :            :     mpd_context_t *ctx;
    1242                 :            : 
    1243         [ +  - ]:         38 :     if (type == &PyDecContext_Type) {
    1244                 :         38 :         self = PyObject_New(PyDecContextObject, &PyDecContext_Type);
    1245                 :            :     }
    1246                 :            :     else {
    1247                 :          0 :         self = (PyDecContextObject *)type->tp_alloc(type, 0);
    1248                 :            :     }
    1249                 :            : 
    1250         [ -  + ]:         38 :     if (self == NULL) {
    1251                 :          0 :         return NULL;
    1252                 :            :     }
    1253                 :            : 
    1254                 :         38 :     self->traps = PyObject_CallObject((PyObject *)PyDecSignalDict_Type, NULL);
    1255         [ -  + ]:         38 :     if (self->traps == NULL) {
    1256                 :          0 :         self->flags = NULL;
    1257                 :          0 :         Py_DECREF(self);
    1258                 :          0 :         return NULL;
    1259                 :            :     }
    1260                 :         38 :     self->flags = PyObject_CallObject((PyObject *)PyDecSignalDict_Type, NULL);
    1261         [ -  + ]:         38 :     if (self->flags == NULL) {
    1262                 :          0 :         Py_DECREF(self);
    1263                 :          0 :         return NULL;
    1264                 :            :     }
    1265                 :            : 
    1266                 :         38 :     ctx = CTX(self);
    1267                 :            : 
    1268         [ +  + ]:         38 :     if (default_context_template) {
    1269                 :         36 :         *ctx = *CTX(default_context_template);
    1270                 :            :     }
    1271                 :            :     else {
    1272                 :          2 :         *ctx = dflt_ctx;
    1273                 :            :     }
    1274                 :            : 
    1275                 :         38 :     SdFlagAddr(self->traps) = &ctx->traps;
    1276                 :         38 :     SdFlagAddr(self->flags) = &ctx->status;
    1277                 :            : 
    1278                 :         38 :     CtxCaps(self) = 1;
    1279                 :         38 :     self->tstate = NULL;
    1280                 :            : 
    1281                 :         38 :     return (PyObject *)self;
    1282                 :            : }
    1283                 :            : 
    1284                 :            : static void
    1285                 :         32 : context_dealloc(PyDecContextObject *self)
    1286                 :            : {
    1287                 :            : #ifndef WITH_DECIMAL_CONTEXTVAR
    1288                 :            :     if (self == cached_context) {
    1289                 :            :         cached_context = NULL;
    1290                 :            :     }
    1291                 :            : #endif
    1292                 :            : 
    1293                 :         32 :     Py_XDECREF(self->traps);
    1294                 :         32 :     Py_XDECREF(self->flags);
    1295                 :         32 :     Py_TYPE(self)->tp_free(self);
    1296                 :         32 : }
    1297                 :            : 
    1298                 :            : static int
    1299                 :         38 : context_init(PyObject *self, PyObject *args, PyObject *kwds)
    1300                 :            : {
    1301                 :            :     static char *kwlist[] = {
    1302                 :            :       "prec", "rounding", "Emin", "Emax", "capitals", "clamp",
    1303                 :            :       "flags", "traps", NULL
    1304                 :            :     };
    1305                 :         38 :     PyObject *prec = Py_None;
    1306                 :         38 :     PyObject *rounding = Py_None;
    1307                 :         38 :     PyObject *emin = Py_None;
    1308                 :         38 :     PyObject *emax = Py_None;
    1309                 :         38 :     PyObject *capitals = Py_None;
    1310                 :         38 :     PyObject *clamp = Py_None;
    1311                 :         38 :     PyObject *status = Py_None;
    1312                 :         38 :     PyObject *traps = Py_None;
    1313                 :            : 
    1314                 :            :     assert(PyTuple_Check(args));
    1315                 :            : 
    1316         [ -  + ]:         38 :     if (!PyArg_ParseTupleAndKeywords(
    1317                 :            :             args, kwds,
    1318                 :            :             "|OOOOOOOO", kwlist,
    1319                 :            :             &prec, &rounding, &emin, &emax, &capitals, &clamp, &status, &traps
    1320                 :            :          )) {
    1321                 :          0 :         return -1;
    1322                 :            :     }
    1323                 :            : 
    1324                 :         38 :     return context_setattrs(
    1325                 :            :         self, prec, rounding,
    1326                 :            :         emin, emax, capitals,
    1327                 :            :         clamp, status, traps
    1328                 :            :     );
    1329                 :            : }
    1330                 :            : 
    1331                 :            : static PyObject *
    1332                 :          0 : context_repr(PyDecContextObject *self)
    1333                 :            : {
    1334                 :            :     mpd_context_t *ctx;
    1335                 :            :     char flags[MPD_MAX_SIGNAL_LIST];
    1336                 :            :     char traps[MPD_MAX_SIGNAL_LIST];
    1337                 :            :     int n, mem;
    1338                 :            : 
    1339                 :            :     assert(PyDecContext_Check(self));
    1340                 :          0 :     ctx = CTX(self);
    1341                 :            : 
    1342                 :          0 :     mem = MPD_MAX_SIGNAL_LIST;
    1343                 :          0 :     n = mpd_lsnprint_signals(flags, mem, ctx->status, dec_signal_string);
    1344   [ #  #  #  # ]:          0 :     if (n < 0 || n >= mem) {
    1345                 :          0 :         INTERNAL_ERROR_PTR("context_repr");
    1346                 :            :     }
    1347                 :            : 
    1348                 :          0 :     n = mpd_lsnprint_signals(traps, mem, ctx->traps, dec_signal_string);
    1349   [ #  #  #  # ]:          0 :     if (n < 0 || n >= mem) {
    1350                 :          0 :         INTERNAL_ERROR_PTR("context_repr");
    1351                 :            :     }
    1352                 :            : 
    1353                 :          0 :     return PyUnicode_FromFormat(
    1354                 :            :         "Context(prec=%zd, rounding=%s, Emin=%zd, Emax=%zd, "
    1355                 :            :                 "capitals=%d, clamp=%d, flags=%s, traps=%s)",
    1356                 :          0 :          ctx->prec, mpd_round_string[ctx->round], ctx->emin, ctx->emax,
    1357                 :            :          self->capitals, ctx->clamp, flags, traps);
    1358                 :            : }
    1359                 :            : 
    1360                 :            : static void
    1361                 :          2 : init_basic_context(PyObject *v)
    1362                 :            : {
    1363                 :          2 :     mpd_context_t ctx = dflt_ctx;
    1364                 :            : 
    1365                 :          2 :     ctx.prec = 9;
    1366                 :          2 :     ctx.traps |= (MPD_Underflow|MPD_Clamped);
    1367                 :          2 :     ctx.round = MPD_ROUND_HALF_UP;
    1368                 :            : 
    1369                 :          2 :     *CTX(v) = ctx;
    1370                 :          2 :     CtxCaps(v) = 1;
    1371                 :          2 : }
    1372                 :            : 
    1373                 :            : static void
    1374                 :          2 : init_extended_context(PyObject *v)
    1375                 :            : {
    1376                 :          2 :     mpd_context_t ctx = dflt_ctx;
    1377                 :            : 
    1378                 :          2 :     ctx.prec = 9;
    1379                 :          2 :     ctx.traps = 0;
    1380                 :            : 
    1381                 :          2 :     *CTX(v) = ctx;
    1382                 :          2 :     CtxCaps(v) = 1;
    1383                 :          2 : }
    1384                 :            : 
    1385                 :            : #ifdef EXTRA_FUNCTIONALITY
    1386                 :            : /* Factory function for creating IEEE interchange format contexts */
    1387                 :            : static PyObject *
    1388                 :            : ieee_context(PyObject *dummy UNUSED, PyObject *v)
    1389                 :            : {
    1390                 :            :     PyObject *context;
    1391                 :            :     mpd_ssize_t bits;
    1392                 :            :     mpd_context_t ctx;
    1393                 :            : 
    1394                 :            :     bits = PyLong_AsSsize_t(v);
    1395                 :            :     if (bits == -1 && PyErr_Occurred()) {
    1396                 :            :         return NULL;
    1397                 :            :     }
    1398                 :            :     if (bits <= 0 || bits > INT_MAX) {
    1399                 :            :         goto error;
    1400                 :            :     }
    1401                 :            :     if (mpd_ieee_context(&ctx, (int)bits) < 0) {
    1402                 :            :         goto error;
    1403                 :            :     }
    1404                 :            : 
    1405                 :            :     context = PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL);
    1406                 :            :     if (context == NULL) {
    1407                 :            :         return NULL;
    1408                 :            :     }
    1409                 :            :     *CTX(context) = ctx;
    1410                 :            : 
    1411                 :            :     return context;
    1412                 :            : 
    1413                 :            : error:
    1414                 :            :     PyErr_Format(PyExc_ValueError,
    1415                 :            :         "argument must be a multiple of 32, with a maximum of %d",
    1416                 :            :         MPD_IEEE_CONTEXT_MAX_BITS);
    1417                 :            : 
    1418                 :            :     return NULL;
    1419                 :            : }
    1420                 :            : #endif
    1421                 :            : 
    1422                 :            : static PyObject *
    1423                 :         31 : context_copy(PyObject *self, PyObject *args UNUSED)
    1424                 :            : {
    1425                 :            :     PyObject *copy;
    1426                 :            : 
    1427                 :         31 :     copy = PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL);
    1428         [ -  + ]:         31 :     if (copy == NULL) {
    1429                 :          0 :         return NULL;
    1430                 :            :     }
    1431                 :            : 
    1432                 :         31 :     *CTX(copy) = *CTX(self);
    1433                 :         31 :     CTX(copy)->newtrap = 0;
    1434                 :         31 :     CtxCaps(copy) = CtxCaps(self);
    1435                 :            : 
    1436                 :         31 :     return copy;
    1437                 :            : }
    1438                 :            : 
    1439                 :            : static PyObject *
    1440                 :          0 : context_reduce(PyObject *self, PyObject *args UNUSED)
    1441                 :            : {
    1442                 :            :     PyObject *flags;
    1443                 :            :     PyObject *traps;
    1444                 :            :     PyObject *ret;
    1445                 :            :     mpd_context_t *ctx;
    1446                 :            : 
    1447                 :          0 :     ctx = CTX(self);
    1448                 :            : 
    1449                 :          0 :     flags = signals_as_list(ctx->status);
    1450         [ #  # ]:          0 :     if (flags == NULL) {
    1451                 :          0 :         return NULL;
    1452                 :            :     }
    1453                 :          0 :     traps = signals_as_list(ctx->traps);
    1454         [ #  # ]:          0 :     if (traps == NULL) {
    1455                 :          0 :         Py_DECREF(flags);
    1456                 :          0 :         return NULL;
    1457                 :            :     }
    1458                 :            : 
    1459                 :          0 :     ret = Py_BuildValue(
    1460                 :            :             "O(nsnniiOO)",
    1461                 :            :             Py_TYPE(self),
    1462                 :          0 :             ctx->prec, mpd_round_string[ctx->round], ctx->emin, ctx->emax,
    1463                 :            :             CtxCaps(self), ctx->clamp, flags, traps
    1464                 :            :     );
    1465                 :            : 
    1466                 :          0 :     Py_DECREF(flags);
    1467                 :          0 :     Py_DECREF(traps);
    1468                 :          0 :     return ret;
    1469                 :            : }
    1470                 :            : 
    1471                 :            : 
    1472                 :            : static PyGetSetDef context_getsets [] =
    1473                 :            : {
    1474                 :            :   { "prec", (getter)context_getprec, (setter)context_setprec, NULL, NULL},
    1475                 :            :   { "Emax", (getter)context_getemax, (setter)context_setemax, NULL, NULL},
    1476                 :            :   { "Emin", (getter)context_getemin, (setter)context_setemin, NULL, NULL},
    1477                 :            :   { "rounding", (getter)context_getround, (setter)context_setround, NULL, NULL},
    1478                 :            :   { "capitals", (getter)context_getcapitals, (setter)context_setcapitals, NULL, NULL},
    1479                 :            :   { "clamp", (getter)context_getclamp, (setter)context_setclamp, NULL, NULL},
    1480                 :            : #ifdef EXTRA_FUNCTIONALITY
    1481                 :            :   { "_allcr", (getter)context_getallcr, (setter)context_setallcr, NULL, NULL},
    1482                 :            :   { "_traps", (getter)context_gettraps, (setter)context_settraps, NULL, NULL},
    1483                 :            :   { "_flags", (getter)context_getstatus, (setter)context_setstatus, NULL, NULL},
    1484                 :            : #endif
    1485                 :            :   {NULL}
    1486                 :            : };
    1487                 :            : 
    1488                 :            : 
    1489                 :            : #define CONTEXT_CHECK(obj) \
    1490                 :            :     if (!PyDecContext_Check(obj)) {        \
    1491                 :            :         PyErr_SetString(PyExc_TypeError,   \
    1492                 :            :             "argument must be a context"); \
    1493                 :            :         return NULL;                       \
    1494                 :            :     }
    1495                 :            : 
    1496                 :            : #define CONTEXT_CHECK_VA(obj) \
    1497                 :            :     if (obj == Py_None) {                           \
    1498                 :            :         CURRENT_CONTEXT(obj);                       \
    1499                 :            :     }                                               \
    1500                 :            :     else if (!PyDecContext_Check(obj)) {            \
    1501                 :            :         PyErr_SetString(PyExc_TypeError,            \
    1502                 :            :             "optional argument must be a context"); \
    1503                 :            :         return NULL;                                \
    1504                 :            :     }
    1505                 :            : 
    1506                 :            : 
    1507                 :            : /******************************************************************************/
    1508                 :            : /*                Global, thread local and temporary contexts                 */
    1509                 :            : /******************************************************************************/
    1510                 :            : 
    1511                 :            : /*
    1512                 :            :  * Thread local storage currently has a speed penalty of about 4%.
    1513                 :            :  * All functions that map Python's arithmetic operators to mpdecimal
    1514                 :            :  * functions have to look up the current context for each and every
    1515                 :            :  * operation.
    1516                 :            :  */
    1517                 :            : 
    1518                 :            : #ifndef WITH_DECIMAL_CONTEXTVAR
    1519                 :            : /* Get the context from the thread state dictionary. */
    1520                 :            : static PyObject *
    1521                 :            : current_context_from_dict(void)
    1522                 :            : {
    1523                 :            :     PyThreadState *tstate = _PyThreadState_GET();
    1524                 :            : #ifdef Py_DEBUG
    1525                 :            :     // The caller must hold the GIL
    1526                 :            :     _Py_EnsureTstateNotNULL(tstate);
    1527                 :            : #endif
    1528                 :            : 
    1529                 :            :     PyObject *dict = _PyThreadState_GetDict(tstate);
    1530                 :            :     if (dict == NULL) {
    1531                 :            :         PyErr_SetString(PyExc_RuntimeError,
    1532                 :            :             "cannot get thread state");
    1533                 :            :         return NULL;
    1534                 :            :     }
    1535                 :            : 
    1536                 :            :     PyObject *tl_context = PyDict_GetItemWithError(dict, tls_context_key);
    1537                 :            :     if (tl_context != NULL) {
    1538                 :            :         /* We already have a thread local context. */
    1539                 :            :         CONTEXT_CHECK(tl_context);
    1540                 :            :     }
    1541                 :            :     else {
    1542                 :            :         if (PyErr_Occurred()) {
    1543                 :            :             return NULL;
    1544                 :            :         }
    1545                 :            : 
    1546                 :            :         /* Set up a new thread local context. */
    1547                 :            :         tl_context = context_copy(default_context_template, NULL);
    1548                 :            :         if (tl_context == NULL) {
    1549                 :            :             return NULL;
    1550                 :            :         }
    1551                 :            :         CTX(tl_context)->status = 0;
    1552                 :            : 
    1553                 :            :         if (PyDict_SetItem(dict, tls_context_key, tl_context) < 0) {
    1554                 :            :             Py_DECREF(tl_context);
    1555                 :            :             return NULL;
    1556                 :            :         }
    1557                 :            :         Py_DECREF(tl_context);
    1558                 :            :     }
    1559                 :            : 
    1560                 :            :     /* Cache the context of the current thread, assuming that it
    1561                 :            :      * will be accessed several times before a thread switch. */
    1562                 :            :     cached_context = (PyDecContextObject *)tl_context;
    1563                 :            :     cached_context->tstate = tstate;
    1564                 :            : 
    1565                 :            :     /* Borrowed reference with refcount==1 */
    1566                 :            :     return tl_context;
    1567                 :            : }
    1568                 :            : 
    1569                 :            : /* Return borrowed reference to thread local context. */
    1570                 :            : static PyObject *
    1571                 :            : current_context(void)
    1572                 :            : {
    1573                 :            :     PyThreadState *tstate = _PyThreadState_GET();
    1574                 :            :     if (cached_context && cached_context->tstate == tstate) {
    1575                 :            :         return (PyObject *)cached_context;
    1576                 :            :     }
    1577                 :            : 
    1578                 :            :     return current_context_from_dict();
    1579                 :            : }
    1580                 :            : 
    1581                 :            : /* ctxobj := borrowed reference to the current context */
    1582                 :            : #define CURRENT_CONTEXT(ctxobj) \
    1583                 :            :     ctxobj = current_context(); \
    1584                 :            :     if (ctxobj == NULL) {       \
    1585                 :            :         return NULL;            \
    1586                 :            :     }
    1587                 :            : 
    1588                 :            : /* Return a new reference to the current context */
    1589                 :            : static PyObject *
    1590                 :            : PyDec_GetCurrentContext(PyObject *self UNUSED, PyObject *args UNUSED)
    1591                 :            : {
    1592                 :            :     PyObject *context;
    1593                 :            : 
    1594                 :            :     context = current_context();
    1595                 :            :     if (context == NULL) {
    1596                 :            :         return NULL;
    1597                 :            :     }
    1598                 :            : 
    1599                 :            :     return Py_NewRef(context);
    1600                 :            : }
    1601                 :            : 
    1602                 :            : /* Set the thread local context to a new context, decrement old reference */
    1603                 :            : static PyObject *
    1604                 :            : PyDec_SetCurrentContext(PyObject *self UNUSED, PyObject *v)
    1605                 :            : {
    1606                 :            :     PyObject *dict;
    1607                 :            : 
    1608                 :            :     CONTEXT_CHECK(v);
    1609                 :            : 
    1610                 :            :     dict = PyThreadState_GetDict();
    1611                 :            :     if (dict == NULL) {
    1612                 :            :         PyErr_SetString(PyExc_RuntimeError,
    1613                 :            :             "cannot get thread state");
    1614                 :            :         return NULL;
    1615                 :            :     }
    1616                 :            : 
    1617                 :            :     /* If the new context is one of the templates, make a copy.
    1618                 :            :      * This is the current behavior of decimal.py. */
    1619                 :            :     if (v == default_context_template ||
    1620                 :            :         v == basic_context_template ||
    1621                 :            :         v == extended_context_template) {
    1622                 :            :         v = context_copy(v, NULL);
    1623                 :            :         if (v == NULL) {
    1624                 :            :             return NULL;
    1625                 :            :         }
    1626                 :            :         CTX(v)->status = 0;
    1627                 :            :     }
    1628                 :            :     else {
    1629                 :            :         Py_INCREF(v);
    1630                 :            :     }
    1631                 :            : 
    1632                 :            :     cached_context = NULL;
    1633                 :            :     if (PyDict_SetItem(dict, tls_context_key, v) < 0) {
    1634                 :            :         Py_DECREF(v);
    1635                 :            :         return NULL;
    1636                 :            :     }
    1637                 :            : 
    1638                 :            :     Py_DECREF(v);
    1639                 :            :     Py_RETURN_NONE;
    1640                 :            : }
    1641                 :            : #else
    1642                 :            : static PyObject *
    1643                 :          1 : init_current_context(void)
    1644                 :            : {
    1645                 :          1 :     PyObject *tl_context = context_copy(default_context_template, NULL);
    1646         [ -  + ]:          1 :     if (tl_context == NULL) {
    1647                 :          0 :         return NULL;
    1648                 :            :     }
    1649                 :          1 :     CTX(tl_context)->status = 0;
    1650                 :            : 
    1651                 :          1 :     PyObject *tok = PyContextVar_Set(current_context_var, tl_context);
    1652         [ -  + ]:          1 :     if (tok == NULL) {
    1653                 :          0 :         Py_DECREF(tl_context);
    1654                 :          0 :         return NULL;
    1655                 :            :     }
    1656                 :          1 :     Py_DECREF(tok);
    1657                 :            : 
    1658                 :          1 :     return tl_context;
    1659                 :            : }
    1660                 :            : 
    1661                 :            : static inline PyObject *
    1662                 :        342 : current_context(void)
    1663                 :            : {
    1664                 :            :     PyObject *tl_context;
    1665         [ -  + ]:        342 :     if (PyContextVar_Get(current_context_var, NULL, &tl_context) < 0) {
    1666                 :          0 :         return NULL;
    1667                 :            :     }
    1668                 :            : 
    1669         [ +  + ]:        342 :     if (tl_context != NULL) {
    1670                 :        341 :         return tl_context;
    1671                 :            :     }
    1672                 :            : 
    1673                 :          1 :     return init_current_context();
    1674                 :            : }
    1675                 :            : 
    1676                 :            : /* ctxobj := borrowed reference to the current context */
    1677                 :            : #define CURRENT_CONTEXT(ctxobj) \
    1678                 :            :     ctxobj = current_context(); \
    1679                 :            :     if (ctxobj == NULL) {       \
    1680                 :            :         return NULL;            \
    1681                 :            :     }                           \
    1682                 :            :     Py_DECREF(ctxobj);
    1683                 :            : 
    1684                 :            : /* Return a new reference to the current context */
    1685                 :            : static PyObject *
    1686                 :          0 : PyDec_GetCurrentContext(PyObject *self UNUSED, PyObject *args UNUSED)
    1687                 :            : {
    1688                 :          0 :     return current_context();
    1689                 :            : }
    1690                 :            : 
    1691                 :            : /* Set the thread local context to a new context, decrement old reference */
    1692                 :            : static PyObject *
    1693                 :         60 : PyDec_SetCurrentContext(PyObject *self UNUSED, PyObject *v)
    1694                 :            : {
    1695         [ -  + ]:         60 :     CONTEXT_CHECK(v);
    1696                 :            : 
    1697                 :            :     /* If the new context is one of the templates, make a copy.
    1698                 :            :      * This is the current behavior of decimal.py. */
    1699         [ +  - ]:         60 :     if (v == default_context_template ||
    1700         [ +  - ]:         60 :         v == basic_context_template ||
    1701         [ -  + ]:         60 :         v == extended_context_template) {
    1702                 :          0 :         v = context_copy(v, NULL);
    1703         [ #  # ]:          0 :         if (v == NULL) {
    1704                 :          0 :             return NULL;
    1705                 :            :         }
    1706                 :          0 :         CTX(v)->status = 0;
    1707                 :            :     }
    1708                 :            :     else {
    1709                 :         60 :         Py_INCREF(v);
    1710                 :            :     }
    1711                 :            : 
    1712                 :         60 :     PyObject *tok = PyContextVar_Set(current_context_var, v);
    1713                 :         60 :     Py_DECREF(v);
    1714         [ -  + ]:         60 :     if (tok == NULL) {
    1715                 :          0 :         return NULL;
    1716                 :            :     }
    1717                 :         60 :     Py_DECREF(tok);
    1718                 :            : 
    1719                 :         60 :     Py_RETURN_NONE;
    1720                 :            : }
    1721                 :            : #endif
    1722                 :            : 
    1723                 :            : /* Context manager object for the 'with' statement. The manager
    1724                 :            :  * owns one reference to the global (outer) context and one
    1725                 :            :  * to the local (inner) context. */
    1726                 :            : static PyObject *
    1727                 :         30 : ctxmanager_new(PyTypeObject *type UNUSED, PyObject *args, PyObject *kwds)
    1728                 :            : {
    1729                 :            :     static char *kwlist[] = {
    1730                 :            :       "ctx", "prec", "rounding",
    1731                 :            :       "Emin", "Emax", "capitals",
    1732                 :            :       "clamp", "flags", "traps",
    1733                 :            :       NULL
    1734                 :            :     };
    1735                 :            :     PyDecContextManagerObject *self;
    1736                 :         30 :     PyObject *local = Py_None;
    1737                 :            :     PyObject *global;
    1738                 :            : 
    1739                 :         30 :     PyObject *prec = Py_None;
    1740                 :         30 :     PyObject *rounding = Py_None;
    1741                 :         30 :     PyObject *Emin = Py_None;
    1742                 :         30 :     PyObject *Emax = Py_None;
    1743                 :         30 :     PyObject *capitals = Py_None;
    1744                 :         30 :     PyObject *clamp = Py_None;
    1745                 :         30 :     PyObject *flags = Py_None;
    1746                 :         30 :     PyObject *traps = Py_None;
    1747                 :            : 
    1748         [ -  + ]:         30 :     CURRENT_CONTEXT(global);
    1749         [ -  + ]:         30 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOOOOOOO", kwlist, &local,
    1750                 :            :           &prec, &rounding, &Emin, &Emax, &capitals, &clamp, &flags, &traps)) {
    1751                 :          0 :         return NULL;
    1752                 :            :     }
    1753         [ -  + ]:         30 :     if (local == Py_None) {
    1754                 :          0 :         local = global;
    1755                 :            :     }
    1756         [ -  + ]:         30 :     else if (!PyDecContext_Check(local)) {
    1757                 :          0 :         PyErr_SetString(PyExc_TypeError,
    1758                 :            :             "optional argument must be a context");
    1759                 :          0 :         return NULL;
    1760                 :            :     }
    1761                 :            : 
    1762                 :         30 :     self = PyObject_New(PyDecContextManagerObject,
    1763                 :            :                         &PyDecContextManager_Type);
    1764         [ -  + ]:         30 :     if (self == NULL) {
    1765                 :          0 :         return NULL;
    1766                 :            :     }
    1767                 :            : 
    1768                 :         30 :     self->local = context_copy(local, NULL);
    1769         [ -  + ]:         30 :     if (self->local == NULL) {
    1770                 :          0 :         self->global = NULL;
    1771                 :          0 :         Py_DECREF(self);
    1772                 :          0 :         return NULL;
    1773                 :            :     }
    1774                 :         30 :     self->global = Py_NewRef(global);
    1775                 :            : 
    1776                 :         30 :     int ret = context_setattrs(
    1777                 :            :         self->local, prec, rounding,
    1778                 :            :         Emin, Emax, capitals,
    1779                 :            :         clamp, flags, traps
    1780                 :            :     );
    1781                 :            : 
    1782         [ -  + ]:         30 :     if (ret < 0) {
    1783                 :          0 :         Py_DECREF(self);
    1784                 :          0 :         return NULL;
    1785                 :            :     }
    1786                 :            : 
    1787                 :         30 :     return (PyObject *)self;
    1788                 :            : }
    1789                 :            : 
    1790                 :            : static void
    1791                 :         30 : ctxmanager_dealloc(PyDecContextManagerObject *self)
    1792                 :            : {
    1793                 :         30 :     Py_XDECREF(self->local);
    1794                 :         30 :     Py_XDECREF(self->global);
    1795                 :         30 :     PyObject_Free(self);
    1796                 :         30 : }
    1797                 :            : 
    1798                 :            : static PyObject *
    1799                 :         30 : ctxmanager_set_local(PyDecContextManagerObject *self, PyObject *args UNUSED)
    1800                 :            : {
    1801                 :            :     PyObject *ret;
    1802                 :            : 
    1803                 :         30 :     ret = PyDec_SetCurrentContext(NULL, self->local);
    1804         [ -  + ]:         30 :     if (ret == NULL) {
    1805                 :          0 :         return NULL;
    1806                 :            :     }
    1807                 :         30 :     Py_DECREF(ret);
    1808                 :            : 
    1809                 :         30 :     return Py_NewRef(self->local);
    1810                 :            : }
    1811                 :            : 
    1812                 :            : static PyObject *
    1813                 :         30 : ctxmanager_restore_global(PyDecContextManagerObject *self,
    1814                 :            :                           PyObject *args UNUSED)
    1815                 :            : {
    1816                 :            :     PyObject *ret;
    1817                 :            : 
    1818                 :         30 :     ret = PyDec_SetCurrentContext(NULL, self->global);
    1819         [ -  + ]:         30 :     if (ret == NULL) {
    1820                 :          0 :         return NULL;
    1821                 :            :     }
    1822                 :         30 :     Py_DECREF(ret);
    1823                 :            : 
    1824                 :         30 :     Py_RETURN_NONE;
    1825                 :            : }
    1826                 :            : 
    1827                 :            : 
    1828                 :            : static PyMethodDef ctxmanager_methods[] = {
    1829                 :            :   {"__enter__", (PyCFunction)ctxmanager_set_local, METH_NOARGS, NULL},
    1830                 :            :   {"__exit__", (PyCFunction)ctxmanager_restore_global, METH_VARARGS, NULL},
    1831                 :            :   {NULL, NULL}
    1832                 :            : };
    1833                 :            : 
    1834                 :            : static PyTypeObject PyDecContextManager_Type =
    1835                 :            : {
    1836                 :            :     PyVarObject_HEAD_INIT(NULL, 0)
    1837                 :            :     "decimal.ContextManager",               /* tp_name */
    1838                 :            :     sizeof(PyDecContextManagerObject),      /* tp_basicsize */
    1839                 :            :     0,                                      /* tp_itemsize */
    1840                 :            :     (destructor) ctxmanager_dealloc,        /* tp_dealloc */
    1841                 :            :     0,                                      /* tp_vectorcall_offset */
    1842                 :            :     (getattrfunc) 0,                        /* tp_getattr */
    1843                 :            :     (setattrfunc) 0,                        /* tp_setattr */
    1844                 :            :     0,                                      /* tp_as_async */
    1845                 :            :     (reprfunc) 0,                           /* tp_repr */
    1846                 :            :     0,                                      /* tp_as_number */
    1847                 :            :     0,                                      /* tp_as_sequence */
    1848                 :            :     0,                                      /* tp_as_mapping */
    1849                 :            :     0,                                      /* tp_hash */
    1850                 :            :     0,                                      /* tp_call */
    1851                 :            :     0,                                      /* tp_str */
    1852                 :            :     (getattrofunc) PyObject_GenericGetAttr, /* tp_getattro */
    1853                 :            :     (setattrofunc) 0,                       /* tp_setattro */
    1854                 :            :     (PyBufferProcs *) 0,                    /* tp_as_buffer */
    1855                 :            :     Py_TPFLAGS_DEFAULT,                     /* tp_flags */
    1856                 :            :     0,                                      /* tp_doc */
    1857                 :            :     0,                                      /* tp_traverse */
    1858                 :            :     0,                                      /* tp_clear */
    1859                 :            :     0,                                      /* tp_richcompare */
    1860                 :            :     0,                                      /* tp_weaklistoffset */
    1861                 :            :     0,                                      /* tp_iter */
    1862                 :            :     0,                                      /* tp_iternext */
    1863                 :            :     ctxmanager_methods,                     /* tp_methods */
    1864                 :            : };
    1865                 :            : 
    1866                 :            : 
    1867                 :            : /******************************************************************************/
    1868                 :            : /*                           New Decimal Object                               */
    1869                 :            : /******************************************************************************/
    1870                 :            : 
    1871                 :            : static PyObject *
    1872                 :        317 : PyDecType_New(PyTypeObject *type)
    1873                 :            : {
    1874                 :            :     PyDecObject *dec;
    1875                 :            : 
    1876         [ +  - ]:        317 :     if (type == &PyDec_Type) {
    1877                 :        317 :         dec = PyObject_New(PyDecObject, &PyDec_Type);
    1878                 :            :     }
    1879                 :            :     else {
    1880                 :          0 :         dec = (PyDecObject *)type->tp_alloc(type, 0);
    1881                 :            :     }
    1882         [ -  + ]:        317 :     if (dec == NULL) {
    1883                 :          0 :         return NULL;
    1884                 :            :     }
    1885                 :            : 
    1886                 :        317 :     dec->hash = -1;
    1887                 :            : 
    1888                 :        317 :     MPD(dec)->flags = MPD_STATIC|MPD_STATIC_DATA;
    1889                 :        317 :     MPD(dec)->exp = 0;
    1890                 :        317 :     MPD(dec)->digits = 0;
    1891                 :        317 :     MPD(dec)->len = 0;
    1892                 :        317 :     MPD(dec)->alloc = _Py_DEC_MINALLOC;
    1893                 :        317 :     MPD(dec)->data = dec->data;
    1894                 :            : 
    1895                 :        317 :     return (PyObject *)dec;
    1896                 :            : }
    1897                 :            : #define dec_alloc() PyDecType_New(&PyDec_Type)
    1898                 :            : 
    1899                 :            : static void
    1900                 :        317 : dec_dealloc(PyObject *dec)
    1901                 :            : {
    1902                 :        317 :     mpd_del(MPD(dec));
    1903                 :        317 :     Py_TYPE(dec)->tp_free(dec);
    1904                 :        317 : }
    1905                 :            : 
    1906                 :            : 
    1907                 :            : /******************************************************************************/
    1908                 :            : /*                           Conversions to Decimal                           */
    1909                 :            : /******************************************************************************/
    1910                 :            : 
    1911                 :            : Py_LOCAL_INLINE(int)
    1912                 :         22 : is_space(int kind, const void *data, Py_ssize_t pos)
    1913                 :            : {
    1914                 :         22 :     Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
    1915                 :         22 :     return Py_UNICODE_ISSPACE(ch);
    1916                 :            : }
    1917                 :            : 
    1918                 :            : /* Return the ASCII representation of a numeric Unicode string. The numeric
    1919                 :            :    string may contain ascii characters in the range [1, 127], any Unicode
    1920                 :            :    space and any unicode digit. If strip_ws is true, leading and trailing
    1921                 :            :    whitespace is stripped. If ignore_underscores is true, underscores are
    1922                 :            :    ignored.
    1923                 :            : 
    1924                 :            :    Return NULL if malloc fails and an empty string if invalid characters
    1925                 :            :    are found. */
    1926                 :            : static char *
    1927                 :         11 : numeric_as_ascii(PyObject *u, int strip_ws, int ignore_underscores)
    1928                 :            : {
    1929                 :            :     int kind;
    1930                 :            :     const void *data;
    1931                 :            :     Py_UCS4 ch;
    1932                 :            :     char *res, *cp;
    1933                 :            :     Py_ssize_t j, len;
    1934                 :            :     int d;
    1935                 :            : 
    1936         [ -  + ]:         11 :     if (PyUnicode_READY(u) == -1) {
    1937                 :          0 :         return NULL;
    1938                 :            :     }
    1939                 :            : 
    1940                 :         11 :     kind = PyUnicode_KIND(u);
    1941                 :         11 :     data = PyUnicode_DATA(u);
    1942                 :         11 :     len =  PyUnicode_GET_LENGTH(u);
    1943                 :            : 
    1944                 :         11 :     cp = res = PyMem_Malloc(len+1);
    1945         [ -  + ]:         11 :     if (res == NULL) {
    1946                 :          0 :         PyErr_NoMemory();
    1947                 :          0 :         return NULL;
    1948                 :            :     }
    1949                 :            : 
    1950                 :         11 :     j = 0;
    1951         [ +  - ]:         11 :     if (strip_ws) {
    1952   [ +  -  -  + ]:         11 :         while (len > 0 && is_space(kind, data, len-1)) {
    1953                 :          0 :             len--;
    1954                 :            :         }
    1955   [ +  -  -  + ]:         11 :         while (j < len && is_space(kind, data, j)) {
    1956                 :          0 :             j++;
    1957                 :            :         }
    1958                 :            :     }
    1959                 :            : 
    1960         [ +  + ]:         94 :     for (; j < len; j++) {
    1961                 :         83 :         ch = PyUnicode_READ(kind, data, j);
    1962   [ +  -  -  + ]:         83 :         if (ignore_underscores && ch == '_') {
    1963                 :          0 :             continue;
    1964                 :            :         }
    1965   [ +  -  +  - ]:         83 :         if (0 < ch && ch <= 127) {
    1966                 :         83 :             *cp++ = ch;
    1967                 :         83 :             continue;
    1968                 :            :         }
    1969         [ #  # ]:          0 :         if (Py_UNICODE_ISSPACE(ch)) {
    1970                 :          0 :             *cp++ = ' ';
    1971                 :          0 :             continue;
    1972                 :            :         }
    1973                 :          0 :         d = Py_UNICODE_TODECIMAL(ch);
    1974         [ #  # ]:          0 :         if (d < 0) {
    1975                 :            :             /* empty string triggers ConversionSyntax */
    1976                 :          0 :             *res = '\0';
    1977                 :          0 :             return res;
    1978                 :            :         }
    1979                 :          0 :         *cp++ = '0' + d;
    1980                 :            :     }
    1981                 :         11 :     *cp = '\0';
    1982                 :         11 :     return res;
    1983                 :            : }
    1984                 :            : 
    1985                 :            : /* Return a new PyDecObject or a subtype from a C string. Use the context
    1986                 :            :    during conversion. */
    1987                 :            : static PyObject *
    1988                 :          0 : PyDecType_FromCString(PyTypeObject *type, const char *s,
    1989                 :            :                       PyObject *context)
    1990                 :            : {
    1991                 :            :     PyObject *dec;
    1992                 :          0 :     uint32_t status = 0;
    1993                 :            : 
    1994                 :          0 :     dec = PyDecType_New(type);
    1995         [ #  # ]:          0 :     if (dec == NULL) {
    1996                 :          0 :         return NULL;
    1997                 :            :     }
    1998                 :            : 
    1999                 :          0 :     mpd_qset_string(MPD(dec), s, CTX(context), &status);
    2000         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2001                 :          0 :         Py_DECREF(dec);
    2002                 :          0 :         return NULL;
    2003                 :            :     }
    2004                 :          0 :     return dec;
    2005                 :            : }
    2006                 :            : 
    2007                 :            : /* Return a new PyDecObject or a subtype from a C string. Attempt exact
    2008                 :            :    conversion. If the operand cannot be converted exactly, set
    2009                 :            :    InvalidOperation. */
    2010                 :            : static PyObject *
    2011                 :         11 : PyDecType_FromCStringExact(PyTypeObject *type, const char *s,
    2012                 :            :                            PyObject *context)
    2013                 :            : {
    2014                 :            :     PyObject *dec;
    2015                 :         11 :     uint32_t status = 0;
    2016                 :            :     mpd_context_t maxctx;
    2017                 :            : 
    2018                 :         11 :     dec = PyDecType_New(type);
    2019         [ -  + ]:         11 :     if (dec == NULL) {
    2020                 :          0 :         return NULL;
    2021                 :            :     }
    2022                 :            : 
    2023                 :         11 :     mpd_maxcontext(&maxctx);
    2024                 :            : 
    2025                 :         11 :     mpd_qset_string(MPD(dec), s, &maxctx, &status);
    2026         [ -  + ]:         11 :     if (status & (MPD_Inexact|MPD_Rounded|MPD_Clamped)) {
    2027                 :            :         /* we want exact results */
    2028                 :          0 :         mpd_seterror(MPD(dec), MPD_Invalid_operation, &status);
    2029                 :            :     }
    2030                 :         11 :     status &= MPD_Errors;
    2031         [ -  + ]:         11 :     if (dec_addstatus(context, status)) {
    2032                 :          0 :         Py_DECREF(dec);
    2033                 :          0 :         return NULL;
    2034                 :            :     }
    2035                 :            : 
    2036                 :         11 :     return dec;
    2037                 :            : }
    2038                 :            : 
    2039                 :            : /* Return a new PyDecObject or a subtype from a PyUnicodeObject. */
    2040                 :            : static PyObject *
    2041                 :          0 : PyDecType_FromUnicode(PyTypeObject *type, PyObject *u,
    2042                 :            :                       PyObject *context)
    2043                 :            : {
    2044                 :            :     PyObject *dec;
    2045                 :            :     char *s;
    2046                 :            : 
    2047                 :          0 :     s = numeric_as_ascii(u, 0, 0);
    2048         [ #  # ]:          0 :     if (s == NULL) {
    2049                 :          0 :         return NULL;
    2050                 :            :     }
    2051                 :            : 
    2052                 :          0 :     dec = PyDecType_FromCString(type, s, context);
    2053                 :          0 :     PyMem_Free(s);
    2054                 :          0 :     return dec;
    2055                 :            : }
    2056                 :            : 
    2057                 :            : /* Return a new PyDecObject or a subtype from a PyUnicodeObject. Attempt exact
    2058                 :            :  * conversion. If the conversion is not exact, fail with InvalidOperation.
    2059                 :            :  * Allow leading and trailing whitespace in the input operand. */
    2060                 :            : static PyObject *
    2061                 :         11 : PyDecType_FromUnicodeExactWS(PyTypeObject *type, PyObject *u,
    2062                 :            :                              PyObject *context)
    2063                 :            : {
    2064                 :            :     PyObject *dec;
    2065                 :            :     char *s;
    2066                 :            : 
    2067                 :         11 :     s = numeric_as_ascii(u, 1, 1);
    2068         [ -  + ]:         11 :     if (s == NULL) {
    2069                 :          0 :         return NULL;
    2070                 :            :     }
    2071                 :            : 
    2072                 :         11 :     dec = PyDecType_FromCStringExact(type, s, context);
    2073                 :         11 :     PyMem_Free(s);
    2074                 :         11 :     return dec;
    2075                 :            : }
    2076                 :            : 
    2077                 :            : /* Set PyDecObject from triple without any error checking. */
    2078                 :            : Py_LOCAL_INLINE(void)
    2079                 :         93 : _dec_settriple(PyObject *dec, uint8_t sign, uint32_t v, mpd_ssize_t exp)
    2080                 :            : {
    2081                 :            : 
    2082                 :            : #ifdef CONFIG_64
    2083                 :         93 :     MPD(dec)->data[0] = v;
    2084                 :         93 :     MPD(dec)->len = 1;
    2085                 :            : #else
    2086                 :            :     uint32_t q, r;
    2087                 :            :     q = v / MPD_RADIX;
    2088                 :            :     r = v - q * MPD_RADIX;
    2089                 :            :     MPD(dec)->data[1] = q;
    2090                 :            :     MPD(dec)->data[0] = r;
    2091                 :            :     MPD(dec)->len = q ? 2 : 1;
    2092                 :            : #endif
    2093                 :         93 :     mpd_set_flags(MPD(dec), sign);
    2094                 :         93 :     MPD(dec)->exp = exp;
    2095                 :         93 :     mpd_setdigits(MPD(dec));
    2096                 :         93 : }
    2097                 :            : 
    2098                 :            : /* Return a new PyDecObject from an mpd_ssize_t. */
    2099                 :            : static PyObject *
    2100                 :          0 : PyDecType_FromSsize(PyTypeObject *type, mpd_ssize_t v, PyObject *context)
    2101                 :            : {
    2102                 :            :     PyObject *dec;
    2103                 :          0 :     uint32_t status = 0;
    2104                 :            : 
    2105                 :          0 :     dec = PyDecType_New(type);
    2106         [ #  # ]:          0 :     if (dec == NULL) {
    2107                 :          0 :         return NULL;
    2108                 :            :     }
    2109                 :            : 
    2110                 :          0 :     mpd_qset_ssize(MPD(dec), v, CTX(context), &status);
    2111         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2112                 :          0 :         Py_DECREF(dec);
    2113                 :          0 :         return NULL;
    2114                 :            :     }
    2115                 :          0 :     return dec;
    2116                 :            : }
    2117                 :            : 
    2118                 :            : /* Return a new PyDecObject from an mpd_ssize_t. Conversion is exact. */
    2119                 :            : static PyObject *
    2120                 :          0 : PyDecType_FromSsizeExact(PyTypeObject *type, mpd_ssize_t v, PyObject *context)
    2121                 :            : {
    2122                 :            :     PyObject *dec;
    2123                 :          0 :     uint32_t status = 0;
    2124                 :            :     mpd_context_t maxctx;
    2125                 :            : 
    2126                 :          0 :     dec = PyDecType_New(type);
    2127         [ #  # ]:          0 :     if (dec == NULL) {
    2128                 :          0 :         return NULL;
    2129                 :            :     }
    2130                 :            : 
    2131                 :          0 :     mpd_maxcontext(&maxctx);
    2132                 :            : 
    2133                 :          0 :     mpd_qset_ssize(MPD(dec), v, &maxctx, &status);
    2134         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2135                 :          0 :         Py_DECREF(dec);
    2136                 :          0 :         return NULL;
    2137                 :            :     }
    2138                 :          0 :     return dec;
    2139                 :            : }
    2140                 :            : 
    2141                 :            : /* Convert from a PyLongObject. The context is not modified; flags set
    2142                 :            :    during conversion are accumulated in the status parameter. */
    2143                 :            : static PyObject *
    2144                 :        153 : dec_from_long(PyTypeObject *type, PyObject *v,
    2145                 :            :               const mpd_context_t *ctx, uint32_t *status)
    2146                 :            : {
    2147                 :            :     PyObject *dec;
    2148                 :        153 :     PyLongObject *l = (PyLongObject *)v;
    2149                 :            :     Py_ssize_t ob_size;
    2150                 :            :     size_t len;
    2151                 :            :     uint8_t sign;
    2152                 :            : 
    2153                 :        153 :     dec = PyDecType_New(type);
    2154         [ -  + ]:        153 :     if (dec == NULL) {
    2155                 :          0 :         return NULL;
    2156                 :            :     }
    2157                 :            : 
    2158                 :        153 :     ob_size = Py_SIZE(l);
    2159         [ +  + ]:        153 :     if (ob_size == 0) {
    2160                 :          6 :         _dec_settriple(dec, MPD_POS, 0, 0);
    2161                 :          6 :         return dec;
    2162                 :            :     }
    2163                 :            : 
    2164         [ +  + ]:        147 :     if (ob_size < 0) {
    2165                 :          1 :         len = -ob_size;
    2166                 :          1 :         sign = MPD_NEG;
    2167                 :            :     }
    2168                 :            :     else {
    2169                 :        146 :         len = ob_size;
    2170                 :        146 :         sign = MPD_POS;
    2171                 :            :     }
    2172                 :            : 
    2173         [ +  + ]:        147 :     if (len == 1) {
    2174                 :         87 :         _dec_settriple(dec, sign, *l->long_value.ob_digit, 0);
    2175                 :         87 :         mpd_qfinalize(MPD(dec), ctx, status);
    2176                 :         87 :         return dec;
    2177                 :            :     }
    2178                 :            : 
    2179                 :            : #if PYLONG_BITS_IN_DIGIT == 30
    2180                 :         60 :     mpd_qimport_u32(MPD(dec), l->long_value.ob_digit, len, sign, PyLong_BASE,
    2181                 :            :                     ctx, status);
    2182                 :            : #elif PYLONG_BITS_IN_DIGIT == 15
    2183                 :            :     mpd_qimport_u16(MPD(dec), l->long_value.ob_digit, len, sign, PyLong_BASE,
    2184                 :            :                     ctx, status);
    2185                 :            : #else
    2186                 :            :   #error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
    2187                 :            : #endif
    2188                 :            : 
    2189                 :         60 :     return dec;
    2190                 :            : }
    2191                 :            : 
    2192                 :            : /* Return a new PyDecObject from a PyLongObject. Use the context for
    2193                 :            :    conversion. */
    2194                 :            : static PyObject *
    2195                 :          0 : PyDecType_FromLong(PyTypeObject *type, PyObject *v, PyObject *context)
    2196                 :            : {
    2197                 :            :     PyObject *dec;
    2198                 :          0 :     uint32_t status = 0;
    2199                 :            : 
    2200         [ #  # ]:          0 :     if (!PyLong_Check(v)) {
    2201                 :          0 :         PyErr_SetString(PyExc_TypeError, "argument must be an integer");
    2202                 :          0 :         return NULL;
    2203                 :            :     }
    2204                 :            : 
    2205                 :          0 :     dec = dec_from_long(type, v, CTX(context), &status);
    2206         [ #  # ]:          0 :     if (dec == NULL) {
    2207                 :          0 :         return NULL;
    2208                 :            :     }
    2209                 :            : 
    2210         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2211                 :          0 :         Py_DECREF(dec);
    2212                 :          0 :         return NULL;
    2213                 :            :     }
    2214                 :            : 
    2215                 :          0 :     return dec;
    2216                 :            : }
    2217                 :            : 
    2218                 :            : /* Return a new PyDecObject from a PyLongObject. Use a maximum context
    2219                 :            :    for conversion. If the conversion is not exact, set InvalidOperation. */
    2220                 :            : static PyObject *
    2221                 :        153 : PyDecType_FromLongExact(PyTypeObject *type, PyObject *v,
    2222                 :            :                         PyObject *context)
    2223                 :            : {
    2224                 :            :     PyObject *dec;
    2225                 :        153 :     uint32_t status = 0;
    2226                 :            :     mpd_context_t maxctx;
    2227                 :            : 
    2228         [ -  + ]:        153 :     if (!PyLong_Check(v)) {
    2229                 :          0 :         PyErr_SetString(PyExc_TypeError, "argument must be an integer");
    2230                 :          0 :         return NULL;
    2231                 :            :     }
    2232                 :            : 
    2233                 :        153 :     mpd_maxcontext(&maxctx);
    2234                 :        153 :     dec = dec_from_long(type, v, &maxctx, &status);
    2235         [ -  + ]:        153 :     if (dec == NULL) {
    2236                 :          0 :         return NULL;
    2237                 :            :     }
    2238                 :            : 
    2239         [ -  + ]:        153 :     if (status & (MPD_Inexact|MPD_Rounded|MPD_Clamped)) {
    2240                 :            :         /* we want exact results */
    2241                 :          0 :         mpd_seterror(MPD(dec), MPD_Invalid_operation, &status);
    2242                 :            :     }
    2243                 :        153 :     status &= MPD_Errors;
    2244         [ -  + ]:        153 :     if (dec_addstatus(context, status)) {
    2245                 :          0 :         Py_DECREF(dec);
    2246                 :          0 :         return NULL;
    2247                 :            :     }
    2248                 :            : 
    2249                 :        153 :     return dec;
    2250                 :            : }
    2251                 :            : 
    2252                 :            : /* External C-API functions */
    2253                 :            : static binaryfunc _py_long_multiply;
    2254                 :            : static binaryfunc _py_long_floor_divide;
    2255                 :            : static ternaryfunc _py_long_power;
    2256                 :            : static unaryfunc _py_float_abs;
    2257                 :            : static PyCFunction _py_long_bit_length;
    2258                 :            : static PyCFunction _py_float_as_integer_ratio;
    2259                 :            : 
    2260                 :            : /* Return a PyDecObject or a subtype from a PyFloatObject.
    2261                 :            :    Conversion is exact. */
    2262                 :            : static PyObject *
    2263                 :         69 : PyDecType_FromFloatExact(PyTypeObject *type, PyObject *v,
    2264                 :            :                          PyObject *context)
    2265                 :            : {
    2266                 :            :     PyObject *dec, *tmp;
    2267                 :            :     PyObject *n, *d, *n_d;
    2268                 :            :     mpd_ssize_t k;
    2269                 :            :     double x;
    2270                 :            :     int sign;
    2271                 :            :     mpd_t *d1, *d2;
    2272                 :         69 :     uint32_t status = 0;
    2273                 :            :     mpd_context_t maxctx;
    2274                 :            : 
    2275                 :            : 
    2276                 :            :     assert(PyType_IsSubtype(type, &PyDec_Type));
    2277                 :            : 
    2278         [ -  + ]:         69 :     if (PyLong_Check(v)) {
    2279                 :          0 :         return PyDecType_FromLongExact(type, v, context);
    2280                 :            :     }
    2281         [ -  + ]:         69 :     if (!PyFloat_Check(v)) {
    2282                 :          0 :         PyErr_SetString(PyExc_TypeError,
    2283                 :            :             "argument must be int or float");
    2284                 :          0 :         return NULL;
    2285                 :            :     }
    2286                 :            : 
    2287                 :         69 :     x = PyFloat_AsDouble(v);
    2288   [ -  +  -  - ]:         69 :     if (x == -1.0 && PyErr_Occurred()) {
    2289                 :          0 :         return NULL;
    2290                 :            :     }
    2291                 :         69 :     sign = (copysign(1.0, x) == 1.0) ? 0 : 1;
    2292                 :            : 
    2293   [ +  -  -  + ]:         69 :     if (Py_IS_NAN(x) || Py_IS_INFINITY(x)) {
    2294                 :          0 :         dec = PyDecType_New(type);
    2295         [ #  # ]:          0 :         if (dec == NULL) {
    2296                 :          0 :             return NULL;
    2297                 :            :         }
    2298         [ #  # ]:          0 :         if (Py_IS_NAN(x)) {
    2299                 :            :             /* decimal.py calls repr(float(+-nan)),
    2300                 :            :              * which always gives a positive result. */
    2301                 :          0 :             mpd_setspecial(MPD(dec), MPD_POS, MPD_NAN);
    2302                 :            :         }
    2303                 :            :         else {
    2304                 :          0 :             mpd_setspecial(MPD(dec), sign, MPD_INF);
    2305                 :            :         }
    2306                 :          0 :         return dec;
    2307                 :            :     }
    2308                 :            : 
    2309                 :            :     /* absolute value of the float */
    2310                 :         69 :     tmp = _py_float_abs(v);
    2311         [ -  + ]:         69 :     if (tmp == NULL) {
    2312                 :          0 :         return NULL;
    2313                 :            :     }
    2314                 :            : 
    2315                 :            :     /* float as integer ratio: numerator/denominator */
    2316                 :         69 :     n_d = _py_float_as_integer_ratio(tmp, NULL);
    2317                 :         69 :     Py_DECREF(tmp);
    2318         [ -  + ]:         69 :     if (n_d == NULL) {
    2319                 :          0 :         return NULL;
    2320                 :            :     }
    2321                 :         69 :     n = PyTuple_GET_ITEM(n_d, 0);
    2322                 :         69 :     d = PyTuple_GET_ITEM(n_d, 1);
    2323                 :            : 
    2324                 :         69 :     tmp = _py_long_bit_length(d, NULL);
    2325         [ -  + ]:         69 :     if (tmp == NULL) {
    2326                 :          0 :         Py_DECREF(n_d);
    2327                 :          0 :         return NULL;
    2328                 :            :     }
    2329                 :         69 :     k = PyLong_AsSsize_t(tmp);
    2330                 :         69 :     Py_DECREF(tmp);
    2331   [ -  +  -  - ]:         69 :     if (k == -1 && PyErr_Occurred()) {
    2332                 :          0 :         Py_DECREF(n_d);
    2333                 :          0 :         return NULL;
    2334                 :            :     }
    2335                 :         69 :     k--;
    2336                 :            : 
    2337                 :         69 :     dec = PyDecType_FromLongExact(type, n, context);
    2338                 :         69 :     Py_DECREF(n_d);
    2339         [ -  + ]:         69 :     if (dec == NULL) {
    2340                 :          0 :         return NULL;
    2341                 :            :     }
    2342                 :            : 
    2343                 :         69 :     d1 = mpd_qnew();
    2344         [ -  + ]:         69 :     if (d1 == NULL) {
    2345                 :          0 :         Py_DECREF(dec);
    2346                 :          0 :         PyErr_NoMemory();
    2347                 :          0 :         return NULL;
    2348                 :            :     }
    2349                 :         69 :     d2 = mpd_qnew();
    2350         [ -  + ]:         69 :     if (d2 == NULL) {
    2351                 :          0 :         mpd_del(d1);
    2352                 :          0 :         Py_DECREF(dec);
    2353                 :          0 :         PyErr_NoMemory();
    2354                 :          0 :         return NULL;
    2355                 :            :     }
    2356                 :            : 
    2357                 :         69 :     mpd_maxcontext(&maxctx);
    2358                 :         69 :     mpd_qset_uint(d1, 5, &maxctx, &status);
    2359                 :         69 :     mpd_qset_ssize(d2, k, &maxctx, &status);
    2360                 :         69 :     mpd_qpow(d1, d1, d2, &maxctx, &status);
    2361         [ -  + ]:         69 :     if (dec_addstatus(context, status)) {
    2362                 :          0 :         mpd_del(d1);
    2363                 :          0 :         mpd_del(d2);
    2364                 :          0 :         Py_DECREF(dec);
    2365                 :          0 :         return NULL;
    2366                 :            :     }
    2367                 :            : 
    2368                 :            :     /* result = n * 5**k */
    2369                 :         69 :     mpd_qmul(MPD(dec), MPD(dec), d1, &maxctx, &status);
    2370                 :         69 :     mpd_del(d1);
    2371                 :         69 :     mpd_del(d2);
    2372         [ -  + ]:         69 :     if (dec_addstatus(context, status)) {
    2373                 :          0 :         Py_DECREF(dec);
    2374                 :          0 :         return NULL;
    2375                 :            :     }
    2376                 :            :     /* result = +- n * 5**k * 10**-k */
    2377                 :         69 :     mpd_set_sign(MPD(dec), sign);
    2378                 :         69 :     MPD(dec)->exp = -k;
    2379                 :            : 
    2380                 :         69 :     return dec;
    2381                 :            : }
    2382                 :            : 
    2383                 :            : static PyObject *
    2384                 :          0 : PyDecType_FromFloat(PyTypeObject *type, PyObject *v,
    2385                 :            :                     PyObject *context)
    2386                 :            : {
    2387                 :            :     PyObject *dec;
    2388                 :          0 :     uint32_t status = 0;
    2389                 :            : 
    2390                 :          0 :     dec = PyDecType_FromFloatExact(type, v, context);
    2391         [ #  # ]:          0 :     if (dec == NULL) {
    2392                 :          0 :         return NULL;
    2393                 :            :     }
    2394                 :            : 
    2395                 :          0 :     mpd_qfinalize(MPD(dec), CTX(context), &status);
    2396         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2397                 :          0 :         Py_DECREF(dec);
    2398                 :          0 :         return NULL;
    2399                 :            :     }
    2400                 :            : 
    2401                 :          0 :     return dec;
    2402                 :            : }
    2403                 :            : 
    2404                 :            : /* Return a new PyDecObject or a subtype from a Decimal. */
    2405                 :            : static PyObject *
    2406                 :          0 : PyDecType_FromDecimalExact(PyTypeObject *type, PyObject *v, PyObject *context)
    2407                 :            : {
    2408                 :            :     PyObject *dec;
    2409                 :          0 :     uint32_t status = 0;
    2410                 :            : 
    2411   [ #  #  #  # ]:          0 :     if (type == &PyDec_Type && PyDec_CheckExact(v)) {
    2412                 :          0 :         return Py_NewRef(v);
    2413                 :            :     }
    2414                 :            : 
    2415                 :          0 :     dec = PyDecType_New(type);
    2416         [ #  # ]:          0 :     if (dec == NULL) {
    2417                 :          0 :         return NULL;
    2418                 :            :     }
    2419                 :            : 
    2420                 :          0 :     mpd_qcopy(MPD(dec), MPD(v), &status);
    2421         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2422                 :          0 :         Py_DECREF(dec);
    2423                 :          0 :         return NULL;
    2424                 :            :     }
    2425                 :            : 
    2426                 :          0 :     return dec;
    2427                 :            : }
    2428                 :            : 
    2429                 :            : static PyObject *
    2430                 :          0 : sequence_as_tuple(PyObject *v, PyObject *ex, const char *mesg)
    2431                 :            : {
    2432         [ #  # ]:          0 :     if (PyTuple_Check(v)) {
    2433                 :          0 :         return Py_NewRef(v);
    2434                 :            :     }
    2435         [ #  # ]:          0 :     if (PyList_Check(v)) {
    2436                 :          0 :         return PyList_AsTuple(v);
    2437                 :            :     }
    2438                 :            : 
    2439                 :          0 :     PyErr_SetString(ex, mesg);
    2440                 :          0 :     return NULL;
    2441                 :            : }
    2442                 :            : 
    2443                 :            : /* Return a new C string representation of a DecimalTuple. */
    2444                 :            : static char *
    2445                 :          0 : dectuple_as_str(PyObject *dectuple)
    2446                 :            : {
    2447                 :          0 :     PyObject *digits = NULL, *tmp;
    2448                 :          0 :     char *decstring = NULL;
    2449                 :            :     char sign_special[6];
    2450                 :            :     char *cp;
    2451                 :            :     long sign, l;
    2452                 :          0 :     mpd_ssize_t exp = 0;
    2453                 :            :     Py_ssize_t i, mem, tsize;
    2454                 :          0 :     int is_infinite = 0;
    2455                 :            :     int n;
    2456                 :            : 
    2457                 :            :     assert(PyTuple_Check(dectuple));
    2458                 :            : 
    2459         [ #  # ]:          0 :     if (PyTuple_Size(dectuple) != 3) {
    2460                 :          0 :         PyErr_SetString(PyExc_ValueError,
    2461                 :            :             "argument must be a sequence of length 3");
    2462                 :          0 :         goto error;
    2463                 :            :     }
    2464                 :            : 
    2465                 :            :     /* sign */
    2466                 :          0 :     tmp = PyTuple_GET_ITEM(dectuple, 0);
    2467         [ #  # ]:          0 :     if (!PyLong_Check(tmp)) {
    2468                 :          0 :         PyErr_SetString(PyExc_ValueError,
    2469                 :            :             "sign must be an integer with the value 0 or 1");
    2470                 :          0 :         goto error;
    2471                 :            :     }
    2472                 :          0 :     sign = PyLong_AsLong(tmp);
    2473   [ #  #  #  # ]:          0 :     if (sign == -1 && PyErr_Occurred()) {
    2474                 :          0 :         goto error;
    2475                 :            :     }
    2476   [ #  #  #  # ]:          0 :     if (sign != 0 && sign != 1) {
    2477                 :          0 :         PyErr_SetString(PyExc_ValueError,
    2478                 :            :             "sign must be an integer with the value 0 or 1");
    2479                 :          0 :         goto error;
    2480                 :            :     }
    2481         [ #  # ]:          0 :     sign_special[0] = sign ? '-' : '+';
    2482                 :          0 :     sign_special[1] = '\0';
    2483                 :            : 
    2484                 :            :     /* exponent or encoding for a special number */
    2485                 :          0 :     tmp = PyTuple_GET_ITEM(dectuple, 2);
    2486         [ #  # ]:          0 :     if (PyUnicode_Check(tmp)) {
    2487                 :            :         /* special */
    2488         [ #  # ]:          0 :         if (PyUnicode_CompareWithASCIIString(tmp, "F") == 0) {
    2489                 :          0 :             strcat(sign_special, "Inf");
    2490                 :          0 :             is_infinite = 1;
    2491                 :            :         }
    2492         [ #  # ]:          0 :         else if (PyUnicode_CompareWithASCIIString(tmp, "n") == 0) {
    2493                 :          0 :             strcat(sign_special, "NaN");
    2494                 :            :         }
    2495         [ #  # ]:          0 :         else if (PyUnicode_CompareWithASCIIString(tmp, "N") == 0) {
    2496                 :          0 :             strcat(sign_special, "sNaN");
    2497                 :            :         }
    2498                 :            :         else {
    2499                 :          0 :             PyErr_SetString(PyExc_ValueError,
    2500                 :            :                 "string argument in the third position "
    2501                 :            :                 "must be 'F', 'n' or 'N'");
    2502                 :          0 :             goto error;
    2503                 :            :         }
    2504                 :            :     }
    2505                 :            :     else {
    2506                 :            :         /* exponent */
    2507         [ #  # ]:          0 :         if (!PyLong_Check(tmp)) {
    2508                 :          0 :             PyErr_SetString(PyExc_ValueError,
    2509                 :            :                 "exponent must be an integer");
    2510                 :          0 :             goto error;
    2511                 :            :         }
    2512                 :          0 :         exp = PyLong_AsSsize_t(tmp);
    2513   [ #  #  #  # ]:          0 :         if (exp == -1 && PyErr_Occurred()) {
    2514                 :          0 :             goto error;
    2515                 :            :         }
    2516                 :            :     }
    2517                 :            : 
    2518                 :            :     /* coefficient */
    2519                 :          0 :     digits = sequence_as_tuple(PyTuple_GET_ITEM(dectuple, 1), PyExc_ValueError,
    2520                 :            :                                "coefficient must be a tuple of digits");
    2521         [ #  # ]:          0 :     if (digits == NULL) {
    2522                 :          0 :         goto error;
    2523                 :            :     }
    2524                 :            : 
    2525                 :          0 :     tsize = PyTuple_Size(digits);
    2526                 :            :     /* [sign][coeffdigits+1][E][-][expdigits+1]['\0'] */
    2527                 :          0 :     mem = 1 + tsize + 3 + MPD_EXPDIGITS + 2;
    2528                 :          0 :     cp = decstring = PyMem_Malloc(mem);
    2529         [ #  # ]:          0 :     if (decstring == NULL) {
    2530                 :          0 :         PyErr_NoMemory();
    2531                 :          0 :         goto error;
    2532                 :            :     }
    2533                 :            : 
    2534                 :          0 :     n = snprintf(cp, mem, "%s", sign_special);
    2535   [ #  #  #  # ]:          0 :     if (n < 0 || n >= mem) {
    2536                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
    2537                 :            :             "internal error in dec_sequence_as_str");
    2538                 :          0 :         goto error;
    2539                 :            :     }
    2540                 :          0 :     cp += n;
    2541                 :            : 
    2542   [ #  #  #  # ]:          0 :     if (tsize == 0 && sign_special[1] == '\0') {
    2543                 :            :         /* empty tuple: zero coefficient, except for special numbers */
    2544                 :          0 :         *cp++ = '0';
    2545                 :            :     }
    2546         [ #  # ]:          0 :     for (i = 0; i < tsize; i++) {
    2547                 :          0 :         tmp = PyTuple_GET_ITEM(digits, i);
    2548         [ #  # ]:          0 :         if (!PyLong_Check(tmp)) {
    2549                 :          0 :             PyErr_SetString(PyExc_ValueError,
    2550                 :            :                 "coefficient must be a tuple of digits");
    2551                 :          0 :             goto error;
    2552                 :            :         }
    2553                 :          0 :         l = PyLong_AsLong(tmp);
    2554   [ #  #  #  # ]:          0 :         if (l == -1 && PyErr_Occurred()) {
    2555                 :          0 :             goto error;
    2556                 :            :         }
    2557   [ #  #  #  # ]:          0 :         if (l < 0 || l > 9) {
    2558                 :          0 :             PyErr_SetString(PyExc_ValueError,
    2559                 :            :                 "coefficient must be a tuple of digits");
    2560                 :          0 :             goto error;
    2561                 :            :         }
    2562         [ #  # ]:          0 :         if (is_infinite) {
    2563                 :            :             /* accept but ignore any well-formed coefficient for compatibility
    2564                 :            :                with decimal.py */
    2565                 :          0 :             continue;
    2566                 :            :         }
    2567                 :          0 :         *cp++ = (char)l + '0';
    2568                 :            :     }
    2569                 :          0 :     *cp = '\0';
    2570                 :            : 
    2571         [ #  # ]:          0 :     if (sign_special[1] == '\0') {
    2572                 :            :         /* not a special number */
    2573                 :          0 :         *cp++ = 'E';
    2574                 :          0 :         n = snprintf(cp, MPD_EXPDIGITS+2, "%" PRI_mpd_ssize_t, exp);
    2575   [ #  #  #  # ]:          0 :         if (n < 0 || n >= MPD_EXPDIGITS+2) {
    2576                 :          0 :             PyErr_SetString(PyExc_RuntimeError,
    2577                 :            :                 "internal error in dec_sequence_as_str");
    2578                 :          0 :             goto error;
    2579                 :            :         }
    2580                 :            :     }
    2581                 :            : 
    2582                 :          0 :     Py_XDECREF(digits);
    2583                 :          0 :     return decstring;
    2584                 :            : 
    2585                 :            : 
    2586                 :          0 : error:
    2587                 :          0 :     Py_XDECREF(digits);
    2588         [ #  # ]:          0 :     if (decstring) PyMem_Free(decstring);
    2589                 :          0 :     return NULL;
    2590                 :            : }
    2591                 :            : 
    2592                 :            : /* Currently accepts tuples and lists. */
    2593                 :            : static PyObject *
    2594                 :          0 : PyDecType_FromSequence(PyTypeObject *type, PyObject *v,
    2595                 :            :                        PyObject *context)
    2596                 :            : {
    2597                 :            :     PyObject *dectuple;
    2598                 :            :     PyObject *dec;
    2599                 :            :     char *s;
    2600                 :            : 
    2601                 :          0 :     dectuple = sequence_as_tuple(v, PyExc_TypeError,
    2602                 :            :                                  "argument must be a tuple or list");
    2603         [ #  # ]:          0 :     if (dectuple == NULL) {
    2604                 :          0 :         return NULL;
    2605                 :            :     }
    2606                 :            : 
    2607                 :          0 :     s = dectuple_as_str(dectuple);
    2608                 :          0 :     Py_DECREF(dectuple);
    2609         [ #  # ]:          0 :     if (s == NULL) {
    2610                 :          0 :         return NULL;
    2611                 :            :     }
    2612                 :            : 
    2613                 :          0 :     dec = PyDecType_FromCString(type, s, context);
    2614                 :            : 
    2615                 :          0 :     PyMem_Free(s);
    2616                 :          0 :     return dec;
    2617                 :            : }
    2618                 :            : 
    2619                 :            : /* Currently accepts tuples and lists. */
    2620                 :            : static PyObject *
    2621                 :          0 : PyDecType_FromSequenceExact(PyTypeObject *type, PyObject *v,
    2622                 :            :                             PyObject *context)
    2623                 :            : {
    2624                 :            :     PyObject *dectuple;
    2625                 :            :     PyObject *dec;
    2626                 :            :     char *s;
    2627                 :            : 
    2628                 :          0 :     dectuple = sequence_as_tuple(v, PyExc_TypeError,
    2629                 :            :                    "argument must be a tuple or list");
    2630         [ #  # ]:          0 :     if (dectuple == NULL) {
    2631                 :          0 :         return NULL;
    2632                 :            :     }
    2633                 :            : 
    2634                 :          0 :     s = dectuple_as_str(dectuple);
    2635                 :          0 :     Py_DECREF(dectuple);
    2636         [ #  # ]:          0 :     if (s == NULL) {
    2637                 :          0 :         return NULL;
    2638                 :            :     }
    2639                 :            : 
    2640                 :          0 :     dec = PyDecType_FromCStringExact(type, s, context);
    2641                 :            : 
    2642                 :          0 :     PyMem_Free(s);
    2643                 :          0 :     return dec;
    2644                 :            : }
    2645                 :            : 
    2646                 :            : #define PyDec_FromCString(str, context) \
    2647                 :            :         PyDecType_FromCString(&PyDec_Type, str, context)
    2648                 :            : #define PyDec_FromCStringExact(str, context) \
    2649                 :            :         PyDecType_FromCStringExact(&PyDec_Type, str, context)
    2650                 :            : 
    2651                 :            : #define PyDec_FromUnicode(unicode, context) \
    2652                 :            :         PyDecType_FromUnicode(&PyDec_Type, unicode, context)
    2653                 :            : #define PyDec_FromUnicodeExact(unicode, context) \
    2654                 :            :         PyDecType_FromUnicodeExact(&PyDec_Type, unicode, context)
    2655                 :            : #define PyDec_FromUnicodeExactWS(unicode, context) \
    2656                 :            :         PyDecType_FromUnicodeExactWS(&PyDec_Type, unicode, context)
    2657                 :            : 
    2658                 :            : #define PyDec_FromSsize(v, context) \
    2659                 :            :         PyDecType_FromSsize(&PyDec_Type, v, context)
    2660                 :            : #define PyDec_FromSsizeExact(v, context) \
    2661                 :            :         PyDecType_FromSsizeExact(&PyDec_Type, v, context)
    2662                 :            : 
    2663                 :            : #define PyDec_FromLong(pylong, context) \
    2664                 :            :         PyDecType_FromLong(&PyDec_Type, pylong, context)
    2665                 :            : #define PyDec_FromLongExact(pylong, context) \
    2666                 :            :         PyDecType_FromLongExact(&PyDec_Type, pylong, context)
    2667                 :            : 
    2668                 :            : #define PyDec_FromFloat(pyfloat, context) \
    2669                 :            :         PyDecType_FromFloat(&PyDec_Type, pyfloat, context)
    2670                 :            : #define PyDec_FromFloatExact(pyfloat, context) \
    2671                 :            :         PyDecType_FromFloatExact(&PyDec_Type, pyfloat, context)
    2672                 :            : 
    2673                 :            : #define PyDec_FromSequence(sequence, context) \
    2674                 :            :         PyDecType_FromSequence(&PyDec_Type, sequence, context)
    2675                 :            : #define PyDec_FromSequenceExact(sequence, context) \
    2676                 :            :         PyDecType_FromSequenceExact(&PyDec_Type, sequence, context)
    2677                 :            : 
    2678                 :            : /* class method */
    2679                 :            : static PyObject *
    2680                 :          0 : dec_from_float(PyObject *type, PyObject *pyfloat)
    2681                 :            : {
    2682                 :            :     PyObject *context;
    2683                 :            :     PyObject *result;
    2684                 :            : 
    2685         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    2686                 :          0 :     result = PyDecType_FromFloatExact(&PyDec_Type, pyfloat, context);
    2687   [ #  #  #  # ]:          0 :     if (type != (PyObject *)&PyDec_Type && result != NULL) {
    2688                 :          0 :         Py_SETREF(result, PyObject_CallFunctionObjArgs(type, result, NULL));
    2689                 :            :     }
    2690                 :            : 
    2691                 :          0 :     return result;
    2692                 :            : }
    2693                 :            : 
    2694                 :            : /* create_decimal_from_float */
    2695                 :            : static PyObject *
    2696                 :          0 : ctx_from_float(PyObject *context, PyObject *v)
    2697                 :            : {
    2698                 :          0 :     return PyDec_FromFloat(v, context);
    2699                 :            : }
    2700                 :            : 
    2701                 :            : /* Apply the context to the input operand. Return a new PyDecObject. */
    2702                 :            : static PyObject *
    2703                 :          0 : dec_apply(PyObject *v, PyObject *context)
    2704                 :            : {
    2705                 :            :     PyObject *result;
    2706                 :          0 :     uint32_t status = 0;
    2707                 :            : 
    2708                 :          0 :     result = dec_alloc();
    2709         [ #  # ]:          0 :     if (result == NULL) {
    2710                 :          0 :         return NULL;
    2711                 :            :     }
    2712                 :            : 
    2713                 :          0 :     mpd_qcopy(MPD(result), MPD(v), &status);
    2714         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2715                 :          0 :         Py_DECREF(result);
    2716                 :          0 :         return NULL;
    2717                 :            :     }
    2718                 :            : 
    2719                 :          0 :     mpd_qfinalize(MPD(result), CTX(context), &status);
    2720         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    2721                 :          0 :         Py_DECREF(result);
    2722                 :          0 :         return NULL;
    2723                 :            :     }
    2724                 :            : 
    2725                 :          0 :     return result;
    2726                 :            : }
    2727                 :            : 
    2728                 :            : /* 'v' can have any type accepted by the Decimal constructor. Attempt
    2729                 :            :    an exact conversion. If the result does not meet the restrictions
    2730                 :            :    for an mpd_t, fail with InvalidOperation. */
    2731                 :            : static PyObject *
    2732                 :         86 : PyDecType_FromObjectExact(PyTypeObject *type, PyObject *v, PyObject *context)
    2733                 :            : {
    2734         [ -  + ]:         86 :     if (v == NULL) {
    2735                 :          0 :         return PyDecType_FromSsizeExact(type, 0, context);
    2736                 :            :     }
    2737         [ -  + ]:         86 :     else if (PyDec_Check(v)) {
    2738                 :          0 :         return PyDecType_FromDecimalExact(type, v, context);
    2739                 :            :     }
    2740         [ +  + ]:         86 :     else if (PyUnicode_Check(v)) {
    2741                 :         11 :         return PyDecType_FromUnicodeExactWS(type, v, context);
    2742                 :            :     }
    2743         [ +  + ]:         75 :     else if (PyLong_Check(v)) {
    2744                 :          7 :         return PyDecType_FromLongExact(type, v, context);
    2745                 :            :     }
    2746   [ +  -  -  + ]:         68 :     else if (PyTuple_Check(v) || PyList_Check(v)) {
    2747                 :          0 :         return PyDecType_FromSequenceExact(type, v, context);
    2748                 :            :     }
    2749         [ +  - ]:         68 :     else if (PyFloat_Check(v)) {
    2750         [ -  + ]:         68 :         if (dec_addstatus(context, MPD_Float_operation)) {
    2751                 :          0 :             return NULL;
    2752                 :            :         }
    2753                 :         68 :         return PyDecType_FromFloatExact(type, v, context);
    2754                 :            :     }
    2755                 :            :     else {
    2756                 :          0 :         PyErr_Format(PyExc_TypeError,
    2757                 :            :             "conversion from %s to Decimal is not supported",
    2758                 :          0 :             Py_TYPE(v)->tp_name);
    2759                 :          0 :         return NULL;
    2760                 :            :     }
    2761                 :            : }
    2762                 :            : 
    2763                 :            : /* The context is used during conversion. This function is the
    2764                 :            :    equivalent of context.create_decimal(). */
    2765                 :            : static PyObject *
    2766                 :          0 : PyDec_FromObject(PyObject *v, PyObject *context)
    2767                 :            : {
    2768         [ #  # ]:          0 :     if (v == NULL) {
    2769                 :          0 :         return PyDec_FromSsize(0, context);
    2770                 :            :     }
    2771         [ #  # ]:          0 :     else if (PyDec_Check(v)) {
    2772                 :          0 :         mpd_context_t *ctx = CTX(context);
    2773         [ #  # ]:          0 :         if (mpd_isnan(MPD(v)) &&
    2774         [ #  # ]:          0 :             MPD(v)->digits > ctx->prec - ctx->clamp) {
    2775                 :            :             /* Special case: too many NaN payload digits */
    2776                 :            :             PyObject *result;
    2777         [ #  # ]:          0 :             if (dec_addstatus(context, MPD_Conversion_syntax)) {
    2778                 :          0 :                 return NULL;
    2779                 :            :             }
    2780                 :          0 :             result = dec_alloc();
    2781         [ #  # ]:          0 :             if (result == NULL) {
    2782                 :          0 :                 return NULL;
    2783                 :            :             }
    2784                 :          0 :             mpd_setspecial(MPD(result), MPD_POS, MPD_NAN);
    2785                 :          0 :             return result;
    2786                 :            :         }
    2787                 :          0 :         return dec_apply(v, context);
    2788                 :            :     }
    2789         [ #  # ]:          0 :     else if (PyUnicode_Check(v)) {
    2790                 :          0 :         return PyDec_FromUnicode(v, context);
    2791                 :            :     }
    2792         [ #  # ]:          0 :     else if (PyLong_Check(v)) {
    2793                 :          0 :         return PyDec_FromLong(v, context);
    2794                 :            :     }
    2795   [ #  #  #  # ]:          0 :     else if (PyTuple_Check(v) || PyList_Check(v)) {
    2796                 :          0 :         return PyDec_FromSequence(v, context);
    2797                 :            :     }
    2798         [ #  # ]:          0 :     else if (PyFloat_Check(v)) {
    2799         [ #  # ]:          0 :         if (dec_addstatus(context, MPD_Float_operation)) {
    2800                 :          0 :             return NULL;
    2801                 :            :         }
    2802                 :          0 :         return PyDec_FromFloat(v, context);
    2803                 :            :     }
    2804                 :            :     else {
    2805                 :          0 :         PyErr_Format(PyExc_TypeError,
    2806                 :            :             "conversion from %s to Decimal is not supported",
    2807                 :          0 :             Py_TYPE(v)->tp_name);
    2808                 :          0 :         return NULL;
    2809                 :            :     }
    2810                 :            : }
    2811                 :            : 
    2812                 :            : static PyObject *
    2813                 :         86 : dec_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
    2814                 :            : {
    2815                 :            :     static char *kwlist[] = {"value", "context", NULL};
    2816                 :         86 :     PyObject *v = NULL;
    2817                 :         86 :     PyObject *context = Py_None;
    2818                 :            : 
    2819         [ -  + ]:         86 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
    2820                 :            :                                      &v, &context)) {
    2821                 :          0 :         return NULL;
    2822                 :            :     }
    2823   [ +  -  -  +  :         86 :     CONTEXT_CHECK_VA(context);
                   -  - ]
    2824                 :            : 
    2825                 :         86 :     return PyDecType_FromObjectExact(type, v, context);
    2826                 :            : }
    2827                 :            : 
    2828                 :            : static PyObject *
    2829                 :          0 : ctx_create_decimal(PyObject *context, PyObject *args)
    2830                 :            : {
    2831                 :          0 :     PyObject *v = NULL;
    2832                 :            : 
    2833         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "|O", &v)) {
    2834                 :          0 :         return NULL;
    2835                 :            :     }
    2836                 :            : 
    2837                 :          0 :     return PyDec_FromObject(v, context);
    2838                 :            : }
    2839                 :            : 
    2840                 :            : 
    2841                 :            : /******************************************************************************/
    2842                 :            : /*                        Implicit conversions to Decimal                     */
    2843                 :            : /******************************************************************************/
    2844                 :            : 
    2845                 :            : /* Try to convert PyObject v to a new PyDecObject conv. If the conversion
    2846                 :            :    fails, set conv to NULL (exception is set). If the conversion is not
    2847                 :            :    implemented, set conv to Py_NotImplemented. */
    2848                 :            : #define NOT_IMPL 0
    2849                 :            : #define TYPE_ERR 1
    2850                 :            : Py_LOCAL_INLINE(int)
    2851                 :        246 : convert_op(int type_err, PyObject **conv, PyObject *v, PyObject *context)
    2852                 :            : {
    2853                 :            : 
    2854         [ +  + ]:        246 :     if (PyDec_Check(v)) {
    2855                 :        169 :         *conv = Py_NewRef(v);
    2856                 :        169 :         return 1;
    2857                 :            :     }
    2858         [ +  - ]:         77 :     if (PyLong_Check(v)) {
    2859                 :         77 :         *conv = PyDec_FromLongExact(v, context);
    2860         [ -  + ]:         77 :         if (*conv == NULL) {
    2861                 :          0 :             return 0;
    2862                 :            :         }
    2863                 :         77 :         return 1;
    2864                 :            :     }
    2865                 :            : 
    2866         [ #  # ]:          0 :     if (type_err) {
    2867                 :          0 :         PyErr_Format(PyExc_TypeError,
    2868                 :            :             "conversion from %s to Decimal is not supported",
    2869                 :          0 :             Py_TYPE(v)->tp_name);
    2870                 :            :     }
    2871                 :            :     else {
    2872                 :          0 :         *conv = Py_NewRef(Py_NotImplemented);
    2873                 :            :     }
    2874                 :          0 :     return 0;
    2875                 :            : }
    2876                 :            : 
    2877                 :            : /* Return NotImplemented for unsupported types. */
    2878                 :            : #define CONVERT_OP(a, v, context) \
    2879                 :            :     if (!convert_op(NOT_IMPL, a, v, context)) { \
    2880                 :            :         return *(a);                            \
    2881                 :            :     }
    2882                 :            : 
    2883                 :            : #define CONVERT_BINOP(a, b, v, w, context) \
    2884                 :            :     if (!convert_op(NOT_IMPL, a, v, context)) { \
    2885                 :            :         return *(a);                            \
    2886                 :            :     }                                           \
    2887                 :            :     if (!convert_op(NOT_IMPL, b, w, context)) { \
    2888                 :            :         Py_DECREF(*(a));                        \
    2889                 :            :         return *(b);                            \
    2890                 :            :     }
    2891                 :            : 
    2892                 :            : #define CONVERT_TERNOP(a, b, c, v, w, x, context) \
    2893                 :            :     if (!convert_op(NOT_IMPL, a, v, context)) {   \
    2894                 :            :         return *(a);                              \
    2895                 :            :     }                                             \
    2896                 :            :     if (!convert_op(NOT_IMPL, b, w, context)) {   \
    2897                 :            :         Py_DECREF(*(a));                          \
    2898                 :            :         return *(b);                              \
    2899                 :            :     }                                             \
    2900                 :            :     if (!convert_op(NOT_IMPL, c, x, context)) {   \
    2901                 :            :         Py_DECREF(*(a));                          \
    2902                 :            :         Py_DECREF(*(b));                          \
    2903                 :            :         return *(c);                              \
    2904                 :            :     }
    2905                 :            : 
    2906                 :            : /* Raise TypeError for unsupported types. */
    2907                 :            : #define CONVERT_OP_RAISE(a, v, context) \
    2908                 :            :     if (!convert_op(TYPE_ERR, a, v, context)) { \
    2909                 :            :         return NULL;                            \
    2910                 :            :     }
    2911                 :            : 
    2912                 :            : #define CONVERT_BINOP_RAISE(a, b, v, w, context) \
    2913                 :            :     if (!convert_op(TYPE_ERR, a, v, context)) {  \
    2914                 :            :         return NULL;                             \
    2915                 :            :     }                                            \
    2916                 :            :     if (!convert_op(TYPE_ERR, b, w, context)) {  \
    2917                 :            :         Py_DECREF(*(a));                         \
    2918                 :            :         return NULL;                             \
    2919                 :            :     }
    2920                 :            : 
    2921                 :            : #define CONVERT_TERNOP_RAISE(a, b, c, v, w, x, context) \
    2922                 :            :     if (!convert_op(TYPE_ERR, a, v, context)) {         \
    2923                 :            :         return NULL;                                    \
    2924                 :            :     }                                                   \
    2925                 :            :     if (!convert_op(TYPE_ERR, b, w, context)) {         \
    2926                 :            :         Py_DECREF(*(a));                                \
    2927                 :            :         return NULL;                                    \
    2928                 :            :     }                                                   \
    2929                 :            :     if (!convert_op(TYPE_ERR, c, x, context)) {         \
    2930                 :            :         Py_DECREF(*(a));                                \
    2931                 :            :         Py_DECREF(*(b));                                \
    2932                 :            :         return NULL;                                    \
    2933                 :            :     }
    2934                 :            : 
    2935                 :            : 
    2936                 :            : /******************************************************************************/
    2937                 :            : /*              Implicit conversions to Decimal for comparison                */
    2938                 :            : /******************************************************************************/
    2939                 :            : 
    2940                 :            : /* Convert rationals for comparison */
    2941                 :            : static PyObject *Rational = NULL;
    2942                 :            : static PyObject *
    2943                 :          0 : multiply_by_denominator(PyObject *v, PyObject *r, PyObject *context)
    2944                 :            : {
    2945                 :            :     PyObject *result;
    2946                 :          0 :     PyObject *tmp = NULL;
    2947                 :          0 :     PyObject *denom = NULL;
    2948                 :          0 :     uint32_t status = 0;
    2949                 :            :     mpd_context_t maxctx;
    2950                 :            :     mpd_ssize_t exp;
    2951                 :            :     mpd_t *vv;
    2952                 :            : 
    2953                 :            :     /* v is not special, r is a rational */
    2954                 :          0 :     tmp = PyObject_GetAttrString(r, "denominator");
    2955         [ #  # ]:          0 :     if (tmp == NULL) {
    2956                 :          0 :         return NULL;
    2957                 :            :     }
    2958                 :          0 :     denom = PyDec_FromLongExact(tmp, context);
    2959                 :          0 :     Py_DECREF(tmp);
    2960         [ #  # ]:          0 :     if (denom == NULL) {
    2961                 :          0 :         return NULL;
    2962                 :            :     }
    2963                 :            : 
    2964                 :          0 :     vv = mpd_qncopy(MPD(v));
    2965         [ #  # ]:          0 :     if (vv == NULL) {
    2966                 :          0 :         Py_DECREF(denom);
    2967                 :          0 :         PyErr_NoMemory();
    2968                 :          0 :         return NULL;
    2969                 :            :     }
    2970                 :          0 :     result = dec_alloc();
    2971         [ #  # ]:          0 :     if (result == NULL) {
    2972                 :          0 :         Py_DECREF(denom);
    2973                 :          0 :         mpd_del(vv);
    2974                 :          0 :         return NULL;
    2975                 :            :     }
    2976                 :            : 
    2977                 :          0 :     mpd_maxcontext(&maxctx);
    2978                 :            :     /* Prevent Overflow in the following multiplication. The result of
    2979                 :            :        the multiplication is only used in mpd_qcmp, which can handle
    2980                 :            :        values that are technically out of bounds, like (for 32-bit)
    2981                 :            :        99999999999999999999...99999999e+425000000. */
    2982                 :          0 :     exp = vv->exp;
    2983                 :          0 :     vv->exp = 0;
    2984                 :          0 :     mpd_qmul(MPD(result), vv, MPD(denom), &maxctx, &status);
    2985                 :          0 :     MPD(result)->exp = exp;
    2986                 :            : 
    2987                 :          0 :     Py_DECREF(denom);
    2988                 :          0 :     mpd_del(vv);
    2989                 :            :     /* If any status has been accumulated during the multiplication,
    2990                 :            :        the result is invalid. This is very unlikely, since even the
    2991                 :            :        32-bit version supports 425000000 digits. */
    2992         [ #  # ]:          0 :     if (status) {
    2993                 :          0 :         PyErr_SetString(PyExc_ValueError,
    2994                 :            :             "exact conversion for comparison failed");
    2995                 :          0 :         Py_DECREF(result);
    2996                 :          0 :         return NULL;
    2997                 :            :     }
    2998                 :            : 
    2999                 :          0 :     return result;
    3000                 :            : }
    3001                 :            : 
    3002                 :            : static PyObject *
    3003                 :          0 : numerator_as_decimal(PyObject *r, PyObject *context)
    3004                 :            : {
    3005                 :            :     PyObject *tmp, *num;
    3006                 :            : 
    3007                 :          0 :     tmp = PyObject_GetAttrString(r, "numerator");
    3008         [ #  # ]:          0 :     if (tmp == NULL) {
    3009                 :          0 :         return NULL;
    3010                 :            :     }
    3011                 :            : 
    3012                 :          0 :     num = PyDec_FromLongExact(tmp, context);
    3013                 :          0 :     Py_DECREF(tmp);
    3014                 :          0 :     return num;
    3015                 :            : }
    3016                 :            : 
    3017                 :            : /* Convert v and w for comparison. v is a Decimal. If w is a Rational, both
    3018                 :            :    v and w have to be transformed. Return 1 for success, with new references
    3019                 :            :    to the converted objects in vcmp and wcmp. Return 0 for failure. In that
    3020                 :            :    case wcmp is either NULL or Py_NotImplemented (new reference) and vcmp
    3021                 :            :    is undefined. */
    3022                 :            : static int
    3023                 :          5 : convert_op_cmp(PyObject **vcmp, PyObject **wcmp, PyObject *v, PyObject *w,
    3024                 :            :                int op, PyObject *context)
    3025                 :            : {
    3026                 :          5 :     mpd_context_t *ctx = CTX(context);
    3027                 :            : 
    3028                 :          5 :     *vcmp = v;
    3029                 :            : 
    3030         [ +  + ]:          5 :     if (PyDec_Check(w)) {
    3031                 :          4 :         *wcmp = Py_NewRef(w);
    3032                 :            :     }
    3033         [ -  + ]:          1 :     else if (PyLong_Check(w)) {
    3034                 :          0 :         *wcmp = PyDec_FromLongExact(w, context);
    3035                 :            :     }
    3036         [ +  - ]:          1 :     else if (PyFloat_Check(w)) {
    3037   [ -  +  -  -  :          1 :         if (op != Py_EQ && op != Py_NE &&
                   -  - ]
    3038                 :          0 :             dec_addstatus(context, MPD_Float_operation)) {
    3039                 :          0 :             *wcmp = NULL;
    3040                 :            :         }
    3041                 :            :         else {
    3042                 :          1 :             ctx->status |= MPD_Float_operation;
    3043                 :          1 :             *wcmp = PyDec_FromFloatExact(w, context);
    3044                 :            :         }
    3045                 :            :     }
    3046   [ #  #  #  #  :          0 :     else if (PyComplex_Check(w) && (op == Py_EQ || op == Py_NE)) {
                   #  # ]
    3047                 :          0 :         Py_complex c = PyComplex_AsCComplex(w);
    3048   [ #  #  #  # ]:          0 :         if (c.real == -1.0 && PyErr_Occurred()) {
    3049                 :          0 :             *wcmp = NULL;
    3050                 :            :         }
    3051         [ #  # ]:          0 :         else if (c.imag == 0.0) {
    3052                 :          0 :             PyObject *tmp = PyFloat_FromDouble(c.real);
    3053         [ #  # ]:          0 :             if (tmp == NULL) {
    3054                 :          0 :                 *wcmp = NULL;
    3055                 :            :             }
    3056                 :            :             else {
    3057                 :          0 :                 ctx->status |= MPD_Float_operation;
    3058                 :          0 :                 *wcmp = PyDec_FromFloatExact(tmp, context);
    3059                 :          0 :                 Py_DECREF(tmp);
    3060                 :            :             }
    3061                 :            :         }
    3062                 :            :         else {
    3063                 :          0 :             *wcmp = Py_NewRef(Py_NotImplemented);
    3064                 :            :         }
    3065                 :            :     }
    3066                 :            :     else {
    3067                 :          0 :         int is_rational = PyObject_IsInstance(w, Rational);
    3068         [ #  # ]:          0 :         if (is_rational < 0) {
    3069                 :          0 :             *wcmp = NULL;
    3070                 :            :         }
    3071         [ #  # ]:          0 :         else if (is_rational > 0) {
    3072                 :          0 :             *wcmp = numerator_as_decimal(w, context);
    3073   [ #  #  #  # ]:          0 :             if (*wcmp && !mpd_isspecial(MPD(v))) {
    3074                 :          0 :                 *vcmp = multiply_by_denominator(v, w, context);
    3075         [ #  # ]:          0 :                 if (*vcmp == NULL) {
    3076         [ #  # ]:          0 :                     Py_CLEAR(*wcmp);
    3077                 :            :                 }
    3078                 :            :             }
    3079                 :            :         }
    3080                 :            :         else {
    3081                 :          0 :             *wcmp = Py_NewRef(Py_NotImplemented);
    3082                 :            :         }
    3083                 :            :     }
    3084                 :            : 
    3085   [ +  -  -  + ]:          5 :     if (*wcmp == NULL || *wcmp == Py_NotImplemented) {
    3086                 :          0 :         return 0;
    3087                 :            :     }
    3088         [ +  - ]:          5 :     if (*vcmp == v) {
    3089                 :          5 :         Py_INCREF(v);
    3090                 :            :     }
    3091                 :          5 :     return 1;
    3092                 :            : }
    3093                 :            : 
    3094                 :            : #define CONVERT_BINOP_CMP(vcmp, wcmp, v, w, op, ctx) \
    3095                 :            :     if (!convert_op_cmp(vcmp, wcmp, v, w, op, ctx)) {  \
    3096                 :            :         return *(wcmp);                                \
    3097                 :            :     }                                                  \
    3098                 :            : 
    3099                 :            : 
    3100                 :            : /******************************************************************************/
    3101                 :            : /*                          Conversions from decimal                          */
    3102                 :            : /******************************************************************************/
    3103                 :            : 
    3104                 :            : static PyObject *
    3105                 :         68 : unicode_fromascii(const char *s, Py_ssize_t size)
    3106                 :            : {
    3107                 :            :     PyObject *res;
    3108                 :            : 
    3109                 :         68 :     res = PyUnicode_New(size, 127);
    3110         [ -  + ]:         68 :     if (res == NULL) {
    3111                 :          0 :         return NULL;
    3112                 :            :     }
    3113                 :            : 
    3114                 :         68 :     memcpy(PyUnicode_1BYTE_DATA(res), s, size);
    3115                 :         68 :     return res;
    3116                 :            : }
    3117                 :            : 
    3118                 :            : /* PyDecObject as a string. The default module context is only used for
    3119                 :            :    the value of 'capitals'. */
    3120                 :            : static PyObject *
    3121                 :         68 : dec_str(PyObject *dec)
    3122                 :            : {
    3123                 :            :     PyObject *res, *context;
    3124                 :            :     mpd_ssize_t size;
    3125                 :            :     char *cp;
    3126                 :            : 
    3127         [ -  + ]:         68 :     CURRENT_CONTEXT(context);
    3128                 :         68 :     size = mpd_to_sci_size(&cp, MPD(dec), CtxCaps(context));
    3129         [ -  + ]:         68 :     if (size < 0) {
    3130                 :          0 :         PyErr_NoMemory();
    3131                 :          0 :         return NULL;
    3132                 :            :     }
    3133                 :            : 
    3134                 :         68 :     res = unicode_fromascii(cp, size);
    3135                 :         68 :     mpd_free(cp);
    3136                 :         68 :     return res;
    3137                 :            : }
    3138                 :            : 
    3139                 :            : /* Representation of a PyDecObject. */
    3140                 :            : static PyObject *
    3141                 :          0 : dec_repr(PyObject *dec)
    3142                 :            : {
    3143                 :            :     PyObject *res, *context;
    3144                 :            :     char *cp;
    3145                 :            : 
    3146         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    3147                 :          0 :     cp = mpd_to_sci(MPD(dec), CtxCaps(context));
    3148         [ #  # ]:          0 :     if (cp == NULL) {
    3149                 :          0 :         PyErr_NoMemory();
    3150                 :          0 :         return NULL;
    3151                 :            :     }
    3152                 :            : 
    3153                 :          0 :     res = PyUnicode_FromFormat("Decimal('%s')", cp);
    3154                 :          0 :     mpd_free(cp);
    3155                 :          0 :     return res;
    3156                 :            : }
    3157                 :            : 
    3158                 :            : /* Return a duplicate of src, copy embedded null characters. */
    3159                 :            : static char *
    3160                 :          0 : dec_strdup(const char *src, Py_ssize_t size)
    3161                 :            : {
    3162                 :          0 :     char *dest = PyMem_Malloc(size+1);
    3163         [ #  # ]:          0 :     if (dest == NULL) {
    3164                 :          0 :         PyErr_NoMemory();
    3165                 :          0 :         return NULL;
    3166                 :            :     }
    3167                 :            : 
    3168                 :          0 :     memcpy(dest, src, size);
    3169                 :          0 :     dest[size] = '\0';
    3170                 :          0 :     return dest;
    3171                 :            : }
    3172                 :            : 
    3173                 :            : static void
    3174                 :          0 : dec_replace_fillchar(char *dest)
    3175                 :            : {
    3176         [ #  # ]:          0 :      while (*dest != '\0') {
    3177         [ #  # ]:          0 :          if (*dest == '\xff') *dest = '\0';
    3178                 :          0 :          dest++;
    3179                 :            :      }
    3180                 :          0 : }
    3181                 :            : 
    3182                 :            : /* Convert decimal_point or thousands_sep, which may be multibyte or in
    3183                 :            :    the range [128, 255], to a UTF8 string. */
    3184                 :            : static PyObject *
    3185                 :          0 : dotsep_as_utf8(const char *s)
    3186                 :            : {
    3187                 :            :     PyObject *utf8;
    3188                 :            :     PyObject *tmp;
    3189                 :            :     wchar_t buf[2];
    3190                 :            :     size_t n;
    3191                 :            : 
    3192                 :          0 :     n = mbstowcs(buf, s, 2);
    3193         [ #  # ]:          0 :     if (n != 1) { /* Issue #7442 */
    3194                 :          0 :         PyErr_SetString(PyExc_ValueError,
    3195                 :            :             "invalid decimal point or unsupported "
    3196                 :            :             "combination of LC_CTYPE and LC_NUMERIC");
    3197                 :          0 :         return NULL;
    3198                 :            :     }
    3199                 :          0 :     tmp = PyUnicode_FromWideChar(buf, n);
    3200         [ #  # ]:          0 :     if (tmp == NULL) {
    3201                 :          0 :         return NULL;
    3202                 :            :     }
    3203                 :          0 :     utf8 = PyUnicode_AsUTF8String(tmp);
    3204                 :          0 :     Py_DECREF(tmp);
    3205                 :          0 :     return utf8;
    3206                 :            : }
    3207                 :            : 
    3208                 :            : /* copy of libmpdec _mpd_round() */
    3209                 :            : static void
    3210                 :          0 : _mpd_round(mpd_t *result, const mpd_t *a, mpd_ssize_t prec,
    3211                 :            :            const mpd_context_t *ctx, uint32_t *status)
    3212                 :            : {
    3213                 :          0 :     mpd_ssize_t exp = a->exp + a->digits - prec;
    3214                 :            : 
    3215         [ #  # ]:          0 :     if (prec <= 0) {
    3216                 :          0 :         mpd_seterror(result, MPD_Invalid_operation, status);
    3217                 :          0 :         return;
    3218                 :            :     }
    3219   [ #  #  #  # ]:          0 :     if (mpd_isspecial(a) || mpd_iszero(a)) {
    3220                 :          0 :         mpd_qcopy(result, a, status);
    3221                 :          0 :         return;
    3222                 :            :     }
    3223                 :            : 
    3224                 :          0 :     mpd_qrescale_fmt(result, a, exp, ctx, status);
    3225         [ #  # ]:          0 :     if (result->digits > prec) {
    3226                 :          0 :         mpd_qrescale_fmt(result, result, exp+1, ctx, status);
    3227                 :            :     }
    3228                 :            : }
    3229                 :            : 
    3230                 :            : /* Locate negative zero "z" option within a UTF-8 format spec string.
    3231                 :            :  * Returns pointer to "z", else NULL.
    3232                 :            :  * The portion of the spec we're working with is [[fill]align][sign][z] */
    3233                 :            : static const char *
    3234                 :          0 : format_spec_z_search(char const *fmt, Py_ssize_t size) {
    3235                 :          0 :     char const *pos = fmt;
    3236                 :          0 :     char const *fmt_end = fmt + size;
    3237                 :            :     /* skip over [[fill]align] (fill may be multi-byte character) */
    3238                 :          0 :     pos += 1;
    3239   [ #  #  #  # ]:          0 :     while (pos < fmt_end && *pos & 0x80) {
    3240                 :          0 :         pos += 1;
    3241                 :            :     }
    3242   [ #  #  #  # ]:          0 :     if (pos < fmt_end && strchr("<>=^", *pos) != NULL) {
    3243                 :          0 :         pos += 1;
    3244                 :            :     } else {
    3245                 :            :         /* fill not present-- skip over [align] */
    3246                 :          0 :         pos = fmt;
    3247   [ #  #  #  # ]:          0 :         if (pos < fmt_end && strchr("<>=^", *pos) != NULL) {
    3248                 :          0 :             pos += 1;
    3249                 :            :         }
    3250                 :            :     }
    3251                 :            :     /* skip over [sign] */
    3252   [ #  #  #  # ]:          0 :     if (pos < fmt_end && strchr("+- ", *pos) != NULL) {
    3253                 :          0 :         pos += 1;
    3254                 :            :     }
    3255   [ #  #  #  # ]:          0 :     return pos < fmt_end && *pos == 'z' ? pos : NULL;
    3256                 :            : }
    3257                 :            : 
    3258                 :            : static int
    3259                 :          0 : dict_get_item_string(PyObject *dict, const char *key, PyObject **valueobj, const char **valuestr)
    3260                 :            : {
    3261                 :          0 :     *valueobj = NULL;
    3262                 :          0 :     PyObject *keyobj = PyUnicode_FromString(key);
    3263         [ #  # ]:          0 :     if (keyobj == NULL) {
    3264                 :          0 :         return -1;
    3265                 :            :     }
    3266                 :          0 :     PyObject *value = PyDict_GetItemWithError(dict, keyobj);
    3267                 :          0 :     Py_DECREF(keyobj);
    3268         [ #  # ]:          0 :     if (value == NULL) {
    3269         [ #  # ]:          0 :         if (PyErr_Occurred()) {
    3270                 :          0 :             return -1;
    3271                 :            :         }
    3272                 :          0 :         return 0;
    3273                 :            :     }
    3274                 :          0 :     value = PyUnicode_AsUTF8String(value);
    3275         [ #  # ]:          0 :     if (value == NULL) {
    3276                 :          0 :         return -1;
    3277                 :            :     }
    3278                 :          0 :     *valueobj = value;
    3279                 :          0 :     *valuestr = PyBytes_AS_STRING(value);
    3280                 :          0 :     return 0;
    3281                 :            : }
    3282                 :            : 
    3283                 :            : /* Formatted representation of a PyDecObject. */
    3284                 :            : static PyObject *
    3285                 :          0 : dec_format(PyObject *dec, PyObject *args)
    3286                 :            : {
    3287                 :          0 :     PyObject *result = NULL;
    3288                 :          0 :     PyObject *override = NULL;
    3289                 :          0 :     PyObject *dot = NULL;
    3290                 :          0 :     PyObject *sep = NULL;
    3291                 :          0 :     PyObject *grouping = NULL;
    3292                 :            :     PyObject *fmtarg;
    3293                 :            :     PyObject *context;
    3294                 :            :     mpd_spec_t spec;
    3295                 :            :     char const *fmt;
    3296                 :          0 :     char *fmt_copy = NULL;
    3297                 :          0 :     char *decstring = NULL;
    3298                 :          0 :     uint32_t status = 0;
    3299                 :          0 :     int replace_fillchar = 0;
    3300                 :          0 :     int no_neg_0 = 0;
    3301                 :            :     Py_ssize_t size;
    3302                 :          0 :     mpd_t *mpd = MPD(dec);
    3303                 :            :     mpd_uint_t dt[MPD_MINALLOC_MAX];
    3304                 :          0 :     mpd_t tmp = {MPD_STATIC|MPD_STATIC_DATA,0,0,0,MPD_MINALLOC_MAX,dt};
    3305                 :            : 
    3306                 :            : 
    3307         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    3308         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "O|O", &fmtarg, &override)) {
    3309                 :          0 :         return NULL;
    3310                 :            :     }
    3311                 :            : 
    3312         [ #  # ]:          0 :     if (PyUnicode_Check(fmtarg)) {
    3313                 :          0 :         fmt = PyUnicode_AsUTF8AndSize(fmtarg, &size);
    3314         [ #  # ]:          0 :         if (fmt == NULL) {
    3315                 :          0 :             return NULL;
    3316                 :            :         }
    3317                 :            :         /* NOTE: If https://github.com/python/cpython/pull/29438 lands, the
    3318                 :            :          *   format string manipulation below can be eliminated by enhancing
    3319                 :            :          *   the forked mpd_parse_fmt_str(). */
    3320   [ #  #  #  # ]:          0 :         if (size > 0 && fmt[0] == '\0') {
    3321                 :            :             /* NUL fill character: must be replaced with a valid UTF-8 char
    3322                 :            :                before calling mpd_parse_fmt_str(). */
    3323                 :          0 :             replace_fillchar = 1;
    3324                 :          0 :             fmt = fmt_copy = dec_strdup(fmt, size);
    3325         [ #  # ]:          0 :             if (fmt_copy == NULL) {
    3326                 :          0 :                 return NULL;
    3327                 :            :             }
    3328                 :          0 :             fmt_copy[0] = '_';
    3329                 :            :         }
    3330                 :            :         /* Strip 'z' option, which isn't understood by mpd_parse_fmt_str().
    3331                 :            :          * NOTE: fmt is always null terminated by PyUnicode_AsUTF8AndSize() */
    3332                 :          0 :         char const *z_position = format_spec_z_search(fmt, size);
    3333         [ #  # ]:          0 :         if (z_position != NULL) {
    3334                 :          0 :             no_neg_0 = 1;
    3335                 :          0 :             size_t z_index = z_position - fmt;
    3336         [ #  # ]:          0 :             if (fmt_copy == NULL) {
    3337                 :          0 :                 fmt = fmt_copy = dec_strdup(fmt, size);
    3338         [ #  # ]:          0 :                 if (fmt_copy == NULL) {
    3339                 :          0 :                     return NULL;
    3340                 :            :                 }
    3341                 :            :             }
    3342                 :            :             /* Shift characters (including null terminator) left,
    3343                 :            :                overwriting the 'z' option. */
    3344                 :          0 :             memmove(fmt_copy + z_index, fmt_copy + z_index + 1, size - z_index);
    3345                 :          0 :             size -= 1;
    3346                 :            :         }
    3347                 :            :     }
    3348                 :            :     else {
    3349                 :          0 :         PyErr_SetString(PyExc_TypeError,
    3350                 :            :             "format arg must be str");
    3351                 :          0 :         return NULL;
    3352                 :            :     }
    3353                 :            : 
    3354         [ #  # ]:          0 :     if (!mpd_parse_fmt_str(&spec, fmt, CtxCaps(context))) {
    3355                 :          0 :         PyErr_SetString(PyExc_ValueError,
    3356                 :            :             "invalid format string");
    3357                 :          0 :         goto finish;
    3358                 :            :     }
    3359         [ #  # ]:          0 :     if (replace_fillchar) {
    3360                 :            :         /* In order to avoid clobbering parts of UTF-8 thousands separators or
    3361                 :            :            decimal points when the substitution is reversed later, the actual
    3362                 :            :            placeholder must be an invalid UTF-8 byte. */
    3363                 :          0 :         spec.fill[0] = '\xff';
    3364                 :          0 :         spec.fill[1] = '\0';
    3365                 :            :     }
    3366                 :            : 
    3367         [ #  # ]:          0 :     if (override) {
    3368                 :            :         /* Values for decimal_point, thousands_sep and grouping can
    3369                 :            :            be explicitly specified in the override dict. These values
    3370                 :            :            take precedence over the values obtained from localeconv()
    3371                 :            :            in mpd_parse_fmt_str(). The feature is not documented and
    3372                 :            :            is only used in test_decimal. */
    3373         [ #  # ]:          0 :         if (!PyDict_Check(override)) {
    3374                 :          0 :             PyErr_SetString(PyExc_TypeError,
    3375                 :            :                 "optional argument must be a dict");
    3376                 :          0 :             goto finish;
    3377                 :            :         }
    3378   [ #  #  #  # ]:          0 :         if (dict_get_item_string(override, "decimal_point", &dot, &spec.dot) ||
    3379         [ #  # ]:          0 :             dict_get_item_string(override, "thousands_sep", &sep, &spec.sep) ||
    3380                 :          0 :             dict_get_item_string(override, "grouping", &grouping, &spec.grouping))
    3381                 :            :         {
    3382                 :          0 :             goto finish;
    3383                 :            :         }
    3384         [ #  # ]:          0 :         if (mpd_validate_lconv(&spec) < 0) {
    3385                 :          0 :             PyErr_SetString(PyExc_ValueError,
    3386                 :            :                 "invalid override dict");
    3387                 :          0 :             goto finish;
    3388                 :            :         }
    3389                 :            :     }
    3390                 :            :     else {
    3391                 :          0 :         size_t n = strlen(spec.dot);
    3392   [ #  #  #  #  :          0 :         if (n > 1 || (n == 1 && !isascii((unsigned char)spec.dot[0]))) {
                   #  # ]
    3393                 :            :             /* fix locale dependent non-ascii characters */
    3394                 :          0 :             dot = dotsep_as_utf8(spec.dot);
    3395         [ #  # ]:          0 :             if (dot == NULL) {
    3396                 :          0 :                 goto finish;
    3397                 :            :             }
    3398                 :          0 :             spec.dot = PyBytes_AS_STRING(dot);
    3399                 :            :         }
    3400                 :          0 :         n = strlen(spec.sep);
    3401   [ #  #  #  #  :          0 :         if (n > 1 || (n == 1 && !isascii((unsigned char)spec.sep[0]))) {
                   #  # ]
    3402                 :            :             /* fix locale dependent non-ascii characters */
    3403                 :          0 :             sep = dotsep_as_utf8(spec.sep);
    3404         [ #  # ]:          0 :             if (sep == NULL) {
    3405                 :          0 :                 goto finish;
    3406                 :            :             }
    3407                 :          0 :             spec.sep = PyBytes_AS_STRING(sep);
    3408                 :            :         }
    3409                 :            :     }
    3410                 :            : 
    3411   [ #  #  #  #  :          0 :     if (no_neg_0 && mpd_isnegative(mpd) && !mpd_isspecial(mpd)) {
                   #  # ]
    3412                 :            :         /* Round into a temporary (carefully mirroring the rounding
    3413                 :            :            of mpd_qformat_spec()), and check if the result is negative zero.
    3414                 :            :            If so, clear the sign and format the resulting positive zero. */
    3415                 :            :         mpd_ssize_t prec;
    3416                 :          0 :         mpd_qcopy(&tmp, mpd, &status);
    3417         [ #  # ]:          0 :         if (spec.prec >= 0) {
    3418   [ #  #  #  #  :          0 :             switch (spec.type) {
                      # ]
    3419                 :          0 :               case 'f':
    3420                 :          0 :                   mpd_qrescale(&tmp, &tmp, -spec.prec, CTX(context), &status);
    3421                 :          0 :                   break;
    3422                 :          0 :               case '%':
    3423                 :          0 :                   tmp.exp += 2;
    3424                 :          0 :                   mpd_qrescale(&tmp, &tmp, -spec.prec, CTX(context), &status);
    3425                 :          0 :                   break;
    3426                 :          0 :               case 'g':
    3427         [ #  # ]:          0 :                   prec = (spec.prec == 0) ? 1 : spec.prec;
    3428         [ #  # ]:          0 :                   if (tmp.digits > prec) {
    3429                 :          0 :                       _mpd_round(&tmp, &tmp, prec, CTX(context), &status);
    3430                 :            :                   }
    3431                 :          0 :                   break;
    3432                 :          0 :               case 'e':
    3433         [ #  # ]:          0 :                   if (!mpd_iszero(&tmp)) {
    3434                 :          0 :                       _mpd_round(&tmp, &tmp, spec.prec+1, CTX(context), &status);
    3435                 :            :                   }
    3436                 :          0 :                   break;
    3437                 :            :             }
    3438                 :          0 :         }
    3439         [ #  # ]:          0 :         if (status & MPD_Errors) {
    3440                 :          0 :             PyErr_SetString(PyExc_ValueError, "unexpected error when rounding");
    3441                 :          0 :             goto finish;
    3442                 :            :         }
    3443         [ #  # ]:          0 :         if (mpd_iszero(&tmp)) {
    3444                 :          0 :             mpd_set_positive(&tmp);
    3445                 :          0 :             mpd = &tmp;
    3446                 :            :         }
    3447                 :            :     }
    3448                 :            : 
    3449                 :          0 :     decstring = mpd_qformat_spec(mpd, &spec, CTX(context), &status);
    3450         [ #  # ]:          0 :     if (decstring == NULL) {
    3451         [ #  # ]:          0 :         if (status & MPD_Malloc_error) {
    3452                 :          0 :             PyErr_NoMemory();
    3453                 :            :         }
    3454                 :            :         else {
    3455                 :          0 :             PyErr_SetString(PyExc_ValueError,
    3456                 :            :                 "format specification exceeds internal limits of _decimal");
    3457                 :            :         }
    3458                 :          0 :         goto finish;
    3459                 :            :     }
    3460                 :          0 :     size = strlen(decstring);
    3461         [ #  # ]:          0 :     if (replace_fillchar) {
    3462                 :          0 :         dec_replace_fillchar(decstring);
    3463                 :            :     }
    3464                 :            : 
    3465                 :          0 :     result = PyUnicode_DecodeUTF8(decstring, size, NULL);
    3466                 :            : 
    3467                 :            : 
    3468                 :          0 : finish:
    3469                 :          0 :     Py_XDECREF(grouping);
    3470                 :          0 :     Py_XDECREF(sep);
    3471                 :          0 :     Py_XDECREF(dot);
    3472         [ #  # ]:          0 :     if (fmt_copy) PyMem_Free(fmt_copy);
    3473         [ #  # ]:          0 :     if (decstring) mpd_free(decstring);
    3474                 :          0 :     return result;
    3475                 :            : }
    3476                 :            : 
    3477                 :            : /* Return a PyLongObject from a PyDecObject, using the specified rounding
    3478                 :            :  * mode. The context precision is not observed. */
    3479                 :            : static PyObject *
    3480                 :          0 : dec_as_long(PyObject *dec, PyObject *context, int round)
    3481                 :            : {
    3482                 :            :     PyLongObject *pylong;
    3483                 :            :     digit *ob_digit;
    3484                 :            :     size_t n;
    3485                 :            :     Py_ssize_t i;
    3486                 :            :     mpd_t *x;
    3487                 :            :     mpd_context_t workctx;
    3488                 :          0 :     uint32_t status = 0;
    3489                 :            : 
    3490         [ #  # ]:          0 :     if (mpd_isspecial(MPD(dec))) {
    3491         [ #  # ]:          0 :         if (mpd_isnan(MPD(dec))) {
    3492                 :          0 :             PyErr_SetString(PyExc_ValueError,
    3493                 :            :                 "cannot convert NaN to integer");
    3494                 :            :         }
    3495                 :            :         else {
    3496                 :          0 :             PyErr_SetString(PyExc_OverflowError,
    3497                 :            :                 "cannot convert Infinity to integer");
    3498                 :            :         }
    3499                 :          0 :         return NULL;
    3500                 :            :     }
    3501                 :            : 
    3502                 :          0 :     x = mpd_qnew();
    3503         [ #  # ]:          0 :     if (x == NULL) {
    3504                 :          0 :         PyErr_NoMemory();
    3505                 :          0 :         return NULL;
    3506                 :            :     }
    3507                 :          0 :     workctx = *CTX(context);
    3508                 :          0 :     workctx.round = round;
    3509                 :          0 :     mpd_qround_to_int(x, MPD(dec), &workctx, &status);
    3510         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    3511                 :          0 :         mpd_del(x);
    3512                 :          0 :         return NULL;
    3513                 :            :     }
    3514                 :            : 
    3515                 :          0 :     status = 0;
    3516                 :          0 :     ob_digit = NULL;
    3517                 :            : #if PYLONG_BITS_IN_DIGIT == 30
    3518                 :          0 :     n = mpd_qexport_u32(&ob_digit, 0, PyLong_BASE, x, &status);
    3519                 :            : #elif PYLONG_BITS_IN_DIGIT == 15
    3520                 :            :     n = mpd_qexport_u16(&ob_digit, 0, PyLong_BASE, x, &status);
    3521                 :            : #else
    3522                 :            :     #error "PYLONG_BITS_IN_DIGIT should be 15 or 30"
    3523                 :            : #endif
    3524                 :            : 
    3525         [ #  # ]:          0 :     if (n == SIZE_MAX) {
    3526                 :          0 :         PyErr_NoMemory();
    3527                 :          0 :         mpd_del(x);
    3528                 :          0 :         return NULL;
    3529                 :            :     }
    3530                 :            : 
    3531         [ #  # ]:          0 :     if (n == 1) {
    3532                 :          0 :         sdigit val = mpd_arith_sign(x) * ob_digit[0];
    3533                 :          0 :         mpd_free(ob_digit);
    3534                 :          0 :         mpd_del(x);
    3535                 :          0 :         return PyLong_FromLong(val);
    3536                 :            :     }
    3537                 :            : 
    3538                 :            :     assert(n > 0);
    3539                 :          0 :     pylong = _PyLong_New(n);
    3540         [ #  # ]:          0 :     if (pylong == NULL) {
    3541                 :          0 :         mpd_free(ob_digit);
    3542                 :          0 :         mpd_del(x);
    3543                 :          0 :         return NULL;
    3544                 :            :     }
    3545                 :            : 
    3546                 :          0 :     memcpy(pylong->long_value.ob_digit, ob_digit, n * sizeof(digit));
    3547                 :          0 :     mpd_free(ob_digit);
    3548                 :            : 
    3549                 :          0 :     i = n;
    3550   [ #  #  #  # ]:          0 :     while ((i > 0) && (pylong->long_value.ob_digit[i-1] == 0)) {
    3551                 :          0 :         i--;
    3552                 :            :     }
    3553                 :            : 
    3554                 :          0 :     Py_SET_SIZE(pylong, i);
    3555   [ #  #  #  # ]:          0 :     if (mpd_isnegative(x) && !mpd_iszero(x)) {
    3556                 :          0 :         Py_SET_SIZE(pylong, -i);
    3557                 :            :     }
    3558                 :            : 
    3559                 :          0 :     mpd_del(x);
    3560                 :          0 :     return (PyObject *) pylong;
    3561                 :            : }
    3562                 :            : 
    3563                 :            : /* Convert a Decimal to its exact integer ratio representation. */
    3564                 :            : static PyObject *
    3565                 :          0 : dec_as_integer_ratio(PyObject *self, PyObject *args UNUSED)
    3566                 :            : {
    3567                 :          0 :     PyObject *numerator = NULL;
    3568                 :          0 :     PyObject *denominator = NULL;
    3569                 :          0 :     PyObject *exponent = NULL;
    3570                 :          0 :     PyObject *result = NULL;
    3571                 :            :     PyObject *tmp;
    3572                 :            :     mpd_ssize_t exp;
    3573                 :            :     PyObject *context;
    3574                 :          0 :     uint32_t status = 0;
    3575                 :            : 
    3576         [ #  # ]:          0 :     if (mpd_isspecial(MPD(self))) {
    3577         [ #  # ]:          0 :         if (mpd_isnan(MPD(self))) {
    3578                 :          0 :             PyErr_SetString(PyExc_ValueError,
    3579                 :            :                 "cannot convert NaN to integer ratio");
    3580                 :            :         }
    3581                 :            :         else {
    3582                 :          0 :             PyErr_SetString(PyExc_OverflowError,
    3583                 :            :                 "cannot convert Infinity to integer ratio");
    3584                 :            :         }
    3585                 :          0 :         return NULL;
    3586                 :            :     }
    3587                 :            : 
    3588         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    3589                 :            : 
    3590                 :          0 :     tmp = dec_alloc();
    3591         [ #  # ]:          0 :     if (tmp == NULL) {
    3592                 :          0 :         return NULL;
    3593                 :            :     }
    3594                 :            : 
    3595         [ #  # ]:          0 :     if (!mpd_qcopy(MPD(tmp), MPD(self), &status)) {
    3596                 :          0 :         Py_DECREF(tmp);
    3597                 :          0 :         PyErr_NoMemory();
    3598                 :          0 :         return NULL;
    3599                 :            :     }
    3600                 :            : 
    3601         [ #  # ]:          0 :     exp = mpd_iszero(MPD(tmp)) ? 0 : MPD(tmp)->exp;
    3602                 :          0 :     MPD(tmp)->exp = 0;
    3603                 :            : 
    3604                 :            :     /* context and rounding are unused here: the conversion is exact */
    3605                 :          0 :     numerator = dec_as_long(tmp, context, MPD_ROUND_FLOOR);
    3606                 :          0 :     Py_DECREF(tmp);
    3607         [ #  # ]:          0 :     if (numerator == NULL) {
    3608                 :          0 :         goto error;
    3609                 :            :     }
    3610                 :            : 
    3611                 :          0 :     exponent = PyLong_FromSsize_t(exp < 0 ? -exp : exp);
    3612         [ #  # ]:          0 :     if (exponent == NULL) {
    3613                 :          0 :         goto error;
    3614                 :            :     }
    3615                 :            : 
    3616                 :          0 :     tmp = PyLong_FromLong(10);
    3617         [ #  # ]:          0 :     if (tmp == NULL) {
    3618                 :          0 :         goto error;
    3619                 :            :     }
    3620                 :            : 
    3621                 :          0 :     Py_SETREF(exponent, _py_long_power(tmp, exponent, Py_None));
    3622                 :          0 :     Py_DECREF(tmp);
    3623         [ #  # ]:          0 :     if (exponent == NULL) {
    3624                 :          0 :         goto error;
    3625                 :            :     }
    3626                 :            : 
    3627         [ #  # ]:          0 :     if (exp >= 0) {
    3628                 :          0 :         Py_SETREF(numerator, _py_long_multiply(numerator, exponent));
    3629         [ #  # ]:          0 :         if (numerator == NULL) {
    3630                 :          0 :             goto error;
    3631                 :            :         }
    3632                 :          0 :         denominator = PyLong_FromLong(1);
    3633         [ #  # ]:          0 :         if (denominator == NULL) {
    3634                 :          0 :             goto error;
    3635                 :            :         }
    3636                 :            :     }
    3637                 :            :     else {
    3638                 :          0 :         denominator = exponent;
    3639                 :          0 :         exponent = NULL;
    3640                 :          0 :         tmp = _PyLong_GCD(numerator, denominator);
    3641         [ #  # ]:          0 :         if (tmp == NULL) {
    3642                 :          0 :             goto error;
    3643                 :            :         }
    3644                 :          0 :         Py_SETREF(numerator, _py_long_floor_divide(numerator, tmp));
    3645                 :          0 :         Py_SETREF(denominator, _py_long_floor_divide(denominator, tmp));
    3646                 :          0 :         Py_DECREF(tmp);
    3647   [ #  #  #  # ]:          0 :         if (numerator == NULL || denominator == NULL) {
    3648                 :          0 :             goto error;
    3649                 :            :         }
    3650                 :            :     }
    3651                 :            : 
    3652                 :          0 :     result = PyTuple_Pack(2, numerator, denominator);
    3653                 :            : 
    3654                 :            : 
    3655                 :          0 : error:
    3656                 :          0 :     Py_XDECREF(exponent);
    3657                 :          0 :     Py_XDECREF(denominator);
    3658                 :          0 :     Py_XDECREF(numerator);
    3659                 :          0 :     return result;
    3660                 :            : }
    3661                 :            : 
    3662                 :            : static PyObject *
    3663                 :          0 : PyDec_ToIntegralValue(PyObject *dec, PyObject *args, PyObject *kwds)
    3664                 :            : {
    3665                 :            :     static char *kwlist[] = {"rounding", "context", NULL};
    3666                 :            :     PyObject *result;
    3667                 :          0 :     PyObject *rounding = Py_None;
    3668                 :          0 :     PyObject *context = Py_None;
    3669                 :          0 :     uint32_t status = 0;
    3670                 :            :     mpd_context_t workctx;
    3671                 :            : 
    3672         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
    3673                 :            :                                      &rounding, &context)) {
    3674                 :          0 :         return NULL;
    3675                 :            :     }
    3676   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    3677                 :            : 
    3678                 :          0 :     workctx = *CTX(context);
    3679         [ #  # ]:          0 :     if (rounding != Py_None) {
    3680                 :          0 :         int round = getround(rounding);
    3681         [ #  # ]:          0 :         if (round < 0) {
    3682                 :          0 :             return NULL;
    3683                 :            :         }
    3684         [ #  # ]:          0 :         if (!mpd_qsetround(&workctx, round)) {
    3685                 :          0 :             INTERNAL_ERROR_PTR("PyDec_ToIntegralValue"); /* GCOV_NOT_REACHED */
    3686                 :            :         }
    3687                 :            :     }
    3688                 :            : 
    3689                 :          0 :     result = dec_alloc();
    3690         [ #  # ]:          0 :     if (result == NULL) {
    3691                 :          0 :         return NULL;
    3692                 :            :     }
    3693                 :            : 
    3694                 :          0 :     mpd_qround_to_int(MPD(result), MPD(dec), &workctx, &status);
    3695         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    3696                 :          0 :         Py_DECREF(result);
    3697                 :          0 :         return NULL;
    3698                 :            :     }
    3699                 :            : 
    3700                 :          0 :     return result;
    3701                 :            : }
    3702                 :            : 
    3703                 :            : static PyObject *
    3704                 :          0 : PyDec_ToIntegralExact(PyObject *dec, PyObject *args, PyObject *kwds)
    3705                 :            : {
    3706                 :            :     static char *kwlist[] = {"rounding", "context", NULL};
    3707                 :            :     PyObject *result;
    3708                 :          0 :     PyObject *rounding = Py_None;
    3709                 :          0 :     PyObject *context = Py_None;
    3710                 :          0 :     uint32_t status = 0;
    3711                 :            :     mpd_context_t workctx;
    3712                 :            : 
    3713         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,
    3714                 :            :                                      &rounding, &context)) {
    3715                 :          0 :         return NULL;
    3716                 :            :     }
    3717   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    3718                 :            : 
    3719                 :          0 :     workctx = *CTX(context);
    3720         [ #  # ]:          0 :     if (rounding != Py_None) {
    3721                 :          0 :         int round = getround(rounding);
    3722         [ #  # ]:          0 :         if (round < 0) {
    3723                 :          0 :             return NULL;
    3724                 :            :         }
    3725         [ #  # ]:          0 :         if (!mpd_qsetround(&workctx, round)) {
    3726                 :          0 :             INTERNAL_ERROR_PTR("PyDec_ToIntegralExact"); /* GCOV_NOT_REACHED */
    3727                 :            :         }
    3728                 :            :     }
    3729                 :            : 
    3730                 :          0 :     result = dec_alloc();
    3731         [ #  # ]:          0 :     if (result == NULL) {
    3732                 :          0 :         return NULL;
    3733                 :            :     }
    3734                 :            : 
    3735                 :          0 :     mpd_qround_to_intx(MPD(result), MPD(dec), &workctx, &status);
    3736         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    3737                 :          0 :         Py_DECREF(result);
    3738                 :          0 :         return NULL;
    3739                 :            :     }
    3740                 :            : 
    3741                 :          0 :     return result;
    3742                 :            : }
    3743                 :            : 
    3744                 :            : static PyObject *
    3745                 :         52 : PyDec_AsFloat(PyObject *dec)
    3746                 :            : {
    3747                 :            :     PyObject *f, *s;
    3748                 :            : 
    3749         [ -  + ]:         52 :     if (mpd_isnan(MPD(dec))) {
    3750         [ #  # ]:          0 :         if (mpd_issnan(MPD(dec))) {
    3751                 :          0 :             PyErr_SetString(PyExc_ValueError,
    3752                 :            :                 "cannot convert signaling NaN to float");
    3753                 :          0 :             return NULL;
    3754                 :            :         }
    3755         [ #  # ]:          0 :         if (mpd_isnegative(MPD(dec))) {
    3756                 :          0 :             s = PyUnicode_FromString("-nan");
    3757                 :            :         }
    3758                 :            :         else {
    3759                 :          0 :             s = PyUnicode_FromString("nan");
    3760                 :            :         }
    3761                 :            :     }
    3762                 :            :     else {
    3763                 :         52 :         s = dec_str(dec);
    3764                 :            :     }
    3765                 :            : 
    3766         [ -  + ]:         52 :     if (s == NULL) {
    3767                 :          0 :         return NULL;
    3768                 :            :     }
    3769                 :            : 
    3770                 :         52 :     f = PyFloat_FromString(s);
    3771                 :         52 :     Py_DECREF(s);
    3772                 :            : 
    3773                 :         52 :     return f;
    3774                 :            : }
    3775                 :            : 
    3776                 :            : static PyObject *
    3777                 :          0 : PyDec_Round(PyObject *dec, PyObject *args)
    3778                 :            : {
    3779                 :            :     PyObject *result;
    3780                 :          0 :     PyObject *x = NULL;
    3781                 :          0 :     uint32_t status = 0;
    3782                 :            :     PyObject *context;
    3783                 :            : 
    3784                 :            : 
    3785         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    3786         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "|O", &x)) {
    3787                 :          0 :         return NULL;
    3788                 :            :     }
    3789                 :            : 
    3790         [ #  # ]:          0 :     if (x) {
    3791                 :          0 :         mpd_uint_t dq[1] = {1};
    3792                 :          0 :         mpd_t q = {MPD_STATIC|MPD_CONST_DATA,0,1,1,1,dq};
    3793                 :            :         mpd_ssize_t y;
    3794                 :            : 
    3795         [ #  # ]:          0 :         if (!PyLong_Check(x)) {
    3796                 :          0 :             PyErr_SetString(PyExc_TypeError,
    3797                 :            :                 "optional arg must be an integer");
    3798                 :          0 :             return NULL;
    3799                 :            :         }
    3800                 :            : 
    3801                 :          0 :         y = PyLong_AsSsize_t(x);
    3802   [ #  #  #  # ]:          0 :         if (y == -1 && PyErr_Occurred()) {
    3803                 :          0 :             return NULL;
    3804                 :            :         }
    3805                 :          0 :         result = dec_alloc();
    3806         [ #  # ]:          0 :         if (result == NULL) {
    3807                 :          0 :             return NULL;
    3808                 :            :         }
    3809                 :            : 
    3810         [ #  # ]:          0 :         q.exp = (y == MPD_SSIZE_MIN) ? MPD_SSIZE_MAX : -y;
    3811                 :          0 :         mpd_qquantize(MPD(result), MPD(dec), &q, CTX(context), &status);
    3812         [ #  # ]:          0 :         if (dec_addstatus(context, status)) {
    3813                 :          0 :             Py_DECREF(result);
    3814                 :          0 :             return NULL;
    3815                 :            :         }
    3816                 :            : 
    3817                 :          0 :         return result;
    3818                 :            :     }
    3819                 :            :     else {
    3820                 :          0 :         return dec_as_long(dec, context, MPD_ROUND_HALF_EVEN);
    3821                 :            :     }
    3822                 :            : }
    3823                 :            : 
    3824                 :            : static PyTypeObject *DecimalTuple = NULL;
    3825                 :            : /* Return the DecimalTuple representation of a PyDecObject. */
    3826                 :            : static PyObject *
    3827                 :          0 : PyDec_AsTuple(PyObject *dec, PyObject *dummy UNUSED)
    3828                 :            : {
    3829                 :          0 :     PyObject *result = NULL;
    3830                 :          0 :     PyObject *sign = NULL;
    3831                 :          0 :     PyObject *coeff = NULL;
    3832                 :          0 :     PyObject *expt = NULL;
    3833                 :          0 :     PyObject *tmp = NULL;
    3834                 :          0 :     mpd_t *x = NULL;
    3835                 :          0 :     char *intstring = NULL;
    3836                 :            :     Py_ssize_t intlen, i;
    3837                 :            : 
    3838                 :            : 
    3839                 :          0 :     x = mpd_qncopy(MPD(dec));
    3840         [ #  # ]:          0 :     if (x == NULL) {
    3841                 :          0 :         PyErr_NoMemory();
    3842                 :          0 :         goto out;
    3843                 :            :     }
    3844                 :            : 
    3845                 :          0 :     sign = PyLong_FromUnsignedLong(mpd_sign(MPD(dec)));
    3846         [ #  # ]:          0 :     if (sign == NULL) {
    3847                 :          0 :         goto out;
    3848                 :            :     }
    3849                 :            : 
    3850         [ #  # ]:          0 :     if (mpd_isinfinite(x)) {
    3851                 :          0 :         expt = PyUnicode_FromString("F");
    3852         [ #  # ]:          0 :         if (expt == NULL) {
    3853                 :          0 :             goto out;
    3854                 :            :         }
    3855                 :            :         /* decimal.py has non-compliant infinity payloads. */
    3856                 :          0 :         coeff = Py_BuildValue("(i)", 0);
    3857         [ #  # ]:          0 :         if (coeff == NULL) {
    3858                 :          0 :             goto out;
    3859                 :            :         }
    3860                 :            :     }
    3861                 :            :     else {
    3862         [ #  # ]:          0 :         if (mpd_isnan(x)) {
    3863         [ #  # ]:          0 :             expt = PyUnicode_FromString(mpd_isqnan(x)?"n":"N");
    3864                 :            :         }
    3865                 :            :         else {
    3866                 :          0 :             expt = PyLong_FromSsize_t(MPD(dec)->exp);
    3867                 :            :         }
    3868         [ #  # ]:          0 :         if (expt == NULL) {
    3869                 :          0 :             goto out;
    3870                 :            :         }
    3871                 :            : 
    3872                 :            :         /* coefficient is defined */
    3873         [ #  # ]:          0 :         if (x->len > 0) {
    3874                 :            : 
    3875                 :            :             /* make an integer */
    3876                 :          0 :             x->exp = 0;
    3877                 :            :             /* clear NaN and sign */
    3878                 :          0 :             mpd_clear_flags(x);
    3879                 :          0 :             intstring = mpd_to_sci(x, 1);
    3880         [ #  # ]:          0 :             if (intstring == NULL) {
    3881                 :          0 :                 PyErr_NoMemory();
    3882                 :          0 :                 goto out;
    3883                 :            :             }
    3884                 :            : 
    3885                 :          0 :             intlen = strlen(intstring);
    3886                 :          0 :             coeff = PyTuple_New(intlen);
    3887         [ #  # ]:          0 :             if (coeff == NULL) {
    3888                 :          0 :                 goto out;
    3889                 :            :             }
    3890                 :            : 
    3891         [ #  # ]:          0 :             for (i = 0; i < intlen; i++) {
    3892                 :          0 :                 tmp = PyLong_FromLong(intstring[i]-'0');
    3893         [ #  # ]:          0 :                 if (tmp == NULL) {
    3894                 :          0 :                     goto out;
    3895                 :            :                 }
    3896                 :          0 :                 PyTuple_SET_ITEM(coeff, i, tmp);
    3897                 :            :             }
    3898                 :            :         }
    3899                 :            :         else {
    3900                 :          0 :             coeff = PyTuple_New(0);
    3901         [ #  # ]:          0 :             if (coeff == NULL) {
    3902                 :          0 :                 goto out;
    3903                 :            :             }
    3904                 :            :         }
    3905                 :            :     }
    3906                 :            : 
    3907                 :          0 :     result = PyObject_CallFunctionObjArgs((PyObject *)DecimalTuple,
    3908                 :            :                                           sign, coeff, expt, NULL);
    3909                 :            : 
    3910                 :          0 : out:
    3911         [ #  # ]:          0 :     if (x) mpd_del(x);
    3912         [ #  # ]:          0 :     if (intstring) mpd_free(intstring);
    3913                 :          0 :     Py_XDECREF(sign);
    3914                 :          0 :     Py_XDECREF(coeff);
    3915                 :          0 :     Py_XDECREF(expt);
    3916                 :          0 :     return result;
    3917                 :            : }
    3918                 :            : 
    3919                 :            : 
    3920                 :            : /******************************************************************************/
    3921                 :            : /*         Macros for converting mpdecimal functions to Decimal methods       */
    3922                 :            : /******************************************************************************/
    3923                 :            : 
    3924                 :            : /* Unary number method that uses the default module context. */
    3925                 :            : #define Dec_UnaryNumberMethod(MPDFUNC) \
    3926                 :            : static PyObject *                                           \
    3927                 :            : nm_##MPDFUNC(PyObject *self)                                \
    3928                 :            : {                                                           \
    3929                 :            :     PyObject *result;                                       \
    3930                 :            :     PyObject *context;                                      \
    3931                 :            :     uint32_t status = 0;                                    \
    3932                 :            :                                                             \
    3933                 :            :     CURRENT_CONTEXT(context);                               \
    3934                 :            :     if ((result = dec_alloc()) == NULL) {                   \
    3935                 :            :         return NULL;                                        \
    3936                 :            :     }                                                       \
    3937                 :            :                                                             \
    3938                 :            :     MPDFUNC(MPD(result), MPD(self), CTX(context), &status); \
    3939                 :            :     if (dec_addstatus(context, status)) {                   \
    3940                 :            :         Py_DECREF(result);                                  \
    3941                 :            :         return NULL;                                        \
    3942                 :            :     }                                                       \
    3943                 :            :                                                             \
    3944                 :            :     return result;                                          \
    3945                 :            : }
    3946                 :            : 
    3947                 :            : /* Binary number method that uses default module context. */
    3948                 :            : #define Dec_BinaryNumberMethod(MPDFUNC) \
    3949                 :            : static PyObject *                                                \
    3950                 :            : nm_##MPDFUNC(PyObject *self, PyObject *other)                    \
    3951                 :            : {                                                                \
    3952                 :            :     PyObject *a, *b;                                             \
    3953                 :            :     PyObject *result;                                            \
    3954                 :            :     PyObject *context;                                           \
    3955                 :            :     uint32_t status = 0;                                         \
    3956                 :            :                                                                  \
    3957                 :            :     CURRENT_CONTEXT(context) ;                                   \
    3958                 :            :     CONVERT_BINOP(&a, &b, self, other, context);                 \
    3959                 :            :                                                                  \
    3960                 :            :     if ((result = dec_alloc()) == NULL) {                        \
    3961                 :            :         Py_DECREF(a);                                            \
    3962                 :            :         Py_DECREF(b);                                            \
    3963                 :            :         return NULL;                                             \
    3964                 :            :     }                                                            \
    3965                 :            :                                                                  \
    3966                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b), CTX(context), &status); \
    3967                 :            :     Py_DECREF(a);                                                \
    3968                 :            :     Py_DECREF(b);                                                \
    3969                 :            :     if (dec_addstatus(context, status)) {                        \
    3970                 :            :         Py_DECREF(result);                                       \
    3971                 :            :         return NULL;                                             \
    3972                 :            :     }                                                            \
    3973                 :            :                                                                  \
    3974                 :            :     return result;                                               \
    3975                 :            : }
    3976                 :            : 
    3977                 :            : /* Boolean function without a context arg. */
    3978                 :            : #define Dec_BoolFunc(MPDFUNC) \
    3979                 :            : static PyObject *                                           \
    3980                 :            : dec_##MPDFUNC(PyObject *self, PyObject *dummy UNUSED)       \
    3981                 :            : {                                                           \
    3982                 :            :     return MPDFUNC(MPD(self)) ? incr_true() : incr_false(); \
    3983                 :            : }
    3984                 :            : 
    3985                 :            : /* Boolean function with an optional context arg. */
    3986                 :            : #define Dec_BoolFuncVA(MPDFUNC) \
    3987                 :            : static PyObject *                                                         \
    3988                 :            : dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds)             \
    3989                 :            : {                                                                         \
    3990                 :            :     static char *kwlist[] = {"context", NULL};                            \
    3991                 :            :     PyObject *context = Py_None;                                          \
    3992                 :            :                                                                           \
    3993                 :            :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist,            \
    3994                 :            :                                      &context)) {                         \
    3995                 :            :         return NULL;                                                      \
    3996                 :            :     }                                                                     \
    3997                 :            :     CONTEXT_CHECK_VA(context);                                            \
    3998                 :            :                                                                           \
    3999                 :            :     return MPDFUNC(MPD(self), CTX(context)) ? incr_true() : incr_false(); \
    4000                 :            : }
    4001                 :            : 
    4002                 :            : /* Unary function with an optional context arg. */
    4003                 :            : #define Dec_UnaryFuncVA(MPDFUNC) \
    4004                 :            : static PyObject *                                              \
    4005                 :            : dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds)  \
    4006                 :            : {                                                              \
    4007                 :            :     static char *kwlist[] = {"context", NULL};                 \
    4008                 :            :     PyObject *result;                                          \
    4009                 :            :     PyObject *context = Py_None;                               \
    4010                 :            :     uint32_t status = 0;                                       \
    4011                 :            :                                                                \
    4012                 :            :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, \
    4013                 :            :                                      &context)) {              \
    4014                 :            :         return NULL;                                           \
    4015                 :            :     }                                                          \
    4016                 :            :     CONTEXT_CHECK_VA(context);                                 \
    4017                 :            :                                                                \
    4018                 :            :     if ((result = dec_alloc()) == NULL) {                      \
    4019                 :            :         return NULL;                                           \
    4020                 :            :     }                                                          \
    4021                 :            :                                                                \
    4022                 :            :     MPDFUNC(MPD(result), MPD(self), CTX(context), &status);    \
    4023                 :            :     if (dec_addstatus(context, status)) {                      \
    4024                 :            :         Py_DECREF(result);                                     \
    4025                 :            :         return NULL;                                           \
    4026                 :            :     }                                                          \
    4027                 :            :                                                                \
    4028                 :            :     return result;                                             \
    4029                 :            : }
    4030                 :            : 
    4031                 :            : /* Binary function with an optional context arg. */
    4032                 :            : #define Dec_BinaryFuncVA(MPDFUNC) \
    4033                 :            : static PyObject *                                                \
    4034                 :            : dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds)    \
    4035                 :            : {                                                                \
    4036                 :            :     static char *kwlist[] = {"other", "context", NULL};          \
    4037                 :            :     PyObject *other;                                             \
    4038                 :            :     PyObject *a, *b;                                             \
    4039                 :            :     PyObject *result;                                            \
    4040                 :            :     PyObject *context = Py_None;                                 \
    4041                 :            :     uint32_t status = 0;                                         \
    4042                 :            :                                                                  \
    4043                 :            :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,  \
    4044                 :            :                                      &other, &context)) {        \
    4045                 :            :         return NULL;                                             \
    4046                 :            :     }                                                            \
    4047                 :            :     CONTEXT_CHECK_VA(context);                                   \
    4048                 :            :     CONVERT_BINOP_RAISE(&a, &b, self, other, context);           \
    4049                 :            :                                                                  \
    4050                 :            :     if ((result = dec_alloc()) == NULL) {                        \
    4051                 :            :         Py_DECREF(a);                                            \
    4052                 :            :         Py_DECREF(b);                                            \
    4053                 :            :         return NULL;                                             \
    4054                 :            :     }                                                            \
    4055                 :            :                                                                  \
    4056                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b), CTX(context), &status); \
    4057                 :            :     Py_DECREF(a);                                                \
    4058                 :            :     Py_DECREF(b);                                                \
    4059                 :            :     if (dec_addstatus(context, status)) {                        \
    4060                 :            :         Py_DECREF(result);                                       \
    4061                 :            :         return NULL;                                             \
    4062                 :            :     }                                                            \
    4063                 :            :                                                                  \
    4064                 :            :     return result;                                               \
    4065                 :            : }
    4066                 :            : 
    4067                 :            : /* Binary function with an optional context arg. Actual MPDFUNC does
    4068                 :            :    NOT take a context. The context is used to record InvalidOperation
    4069                 :            :    if the second operand cannot be converted exactly. */
    4070                 :            : #define Dec_BinaryFuncVA_NO_CTX(MPDFUNC) \
    4071                 :            : static PyObject *                                               \
    4072                 :            : dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds)   \
    4073                 :            : {                                                               \
    4074                 :            :     static char *kwlist[] = {"other", "context", NULL};         \
    4075                 :            :     PyObject *context = Py_None;                                \
    4076                 :            :     PyObject *other;                                            \
    4077                 :            :     PyObject *a, *b;                                            \
    4078                 :            :     PyObject *result;                                           \
    4079                 :            :                                                                 \
    4080                 :            :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, \
    4081                 :            :                                      &other, &context)) {       \
    4082                 :            :         return NULL;                                            \
    4083                 :            :     }                                                           \
    4084                 :            :     CONTEXT_CHECK_VA(context);                                  \
    4085                 :            :     CONVERT_BINOP_RAISE(&a, &b, self, other, context);          \
    4086                 :            :                                                                 \
    4087                 :            :     if ((result = dec_alloc()) == NULL) {                       \
    4088                 :            :         Py_DECREF(a);                                           \
    4089                 :            :         Py_DECREF(b);                                           \
    4090                 :            :         return NULL;                                            \
    4091                 :            :     }                                                           \
    4092                 :            :                                                                 \
    4093                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b));                       \
    4094                 :            :     Py_DECREF(a);                                               \
    4095                 :            :     Py_DECREF(b);                                               \
    4096                 :            :                                                                 \
    4097                 :            :     return result;                                              \
    4098                 :            : }
    4099                 :            : 
    4100                 :            : /* Ternary function with an optional context arg. */
    4101                 :            : #define Dec_TernaryFuncVA(MPDFUNC) \
    4102                 :            : static PyObject *                                                        \
    4103                 :            : dec_##MPDFUNC(PyObject *self, PyObject *args, PyObject *kwds)            \
    4104                 :            : {                                                                        \
    4105                 :            :     static char *kwlist[] = {"other", "third", "context", NULL};         \
    4106                 :            :     PyObject *other, *third;                                             \
    4107                 :            :     PyObject *a, *b, *c;                                                 \
    4108                 :            :     PyObject *result;                                                    \
    4109                 :            :     PyObject *context = Py_None;                                         \
    4110                 :            :     uint32_t status = 0;                                                 \
    4111                 :            :                                                                          \
    4112                 :            :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist,         \
    4113                 :            :                                      &other, &third, &context)) {        \
    4114                 :            :         return NULL;                                                     \
    4115                 :            :     }                                                                    \
    4116                 :            :     CONTEXT_CHECK_VA(context);                                           \
    4117                 :            :     CONVERT_TERNOP_RAISE(&a, &b, &c, self, other, third, context);       \
    4118                 :            :                                                                          \
    4119                 :            :     if ((result = dec_alloc()) == NULL) {                                \
    4120                 :            :         Py_DECREF(a);                                                    \
    4121                 :            :         Py_DECREF(b);                                                    \
    4122                 :            :         Py_DECREF(c);                                                    \
    4123                 :            :         return NULL;                                                     \
    4124                 :            :     }                                                                    \
    4125                 :            :                                                                          \
    4126                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b), MPD(c), CTX(context), &status); \
    4127                 :            :     Py_DECREF(a);                                                        \
    4128                 :            :     Py_DECREF(b);                                                        \
    4129                 :            :     Py_DECREF(c);                                                        \
    4130                 :            :     if (dec_addstatus(context, status)) {                                \
    4131                 :            :         Py_DECREF(result);                                               \
    4132                 :            :         return NULL;                                                     \
    4133                 :            :     }                                                                    \
    4134                 :            :                                                                          \
    4135                 :            :     return result;                                                       \
    4136                 :            : }
    4137                 :            : 
    4138                 :            : 
    4139                 :            : /**********************************************/
    4140                 :            : /*              Number methods                */
    4141                 :            : /**********************************************/
    4142                 :            : 
    4143   [ #  #  #  #  :          0 : Dec_UnaryNumberMethod(mpd_qminus)
                   #  # ]
    4144   [ #  #  #  #  :          0 : Dec_UnaryNumberMethod(mpd_qplus)
                   #  # ]
    4145   [ #  #  #  #  :          0 : Dec_UnaryNumberMethod(mpd_qabs)
                   #  # ]
    4146                 :            : 
    4147   [ -  +  -  +  :         44 : Dec_BinaryNumberMethod(mpd_qadd)
          -  +  -  +  -  
                      + ]
    4148   [ #  #  #  #  :          0 : Dec_BinaryNumberMethod(mpd_qsub)
          #  #  #  #  #  
                      # ]
    4149   [ -  +  -  +  :         19 : Dec_BinaryNumberMethod(mpd_qmul)
          -  +  -  +  -  
                      + ]
    4150   [ #  #  #  #  :          0 : Dec_BinaryNumberMethod(mpd_qdiv)
          #  #  #  #  #  
                      # ]
    4151   [ #  #  #  #  :          0 : Dec_BinaryNumberMethod(mpd_qrem)
          #  #  #  #  #  
                      # ]
    4152   [ #  #  #  #  :          0 : Dec_BinaryNumberMethod(mpd_qdivint)
          #  #  #  #  #  
                      # ]
    4153                 :            : 
    4154                 :            : static PyObject *
    4155                 :          0 : nm_dec_as_long(PyObject *dec)
    4156                 :            : {
    4157                 :            :     PyObject *context;
    4158                 :            : 
    4159         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    4160                 :          0 :     return dec_as_long(dec, context, MPD_ROUND_DOWN);
    4161                 :            : }
    4162                 :            : 
    4163                 :            : static int
    4164                 :          0 : nm_nonzero(PyObject *v)
    4165                 :            : {
    4166                 :          0 :     return !mpd_iszero(MPD(v));
    4167                 :            : }
    4168                 :            : 
    4169                 :            : static PyObject *
    4170                 :          0 : nm_mpd_qdivmod(PyObject *v, PyObject *w)
    4171                 :            : {
    4172                 :            :     PyObject *a, *b;
    4173                 :            :     PyObject *q, *r;
    4174                 :            :     PyObject *context;
    4175                 :          0 :     uint32_t status = 0;
    4176                 :            :     PyObject *ret;
    4177                 :            : 
    4178         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    4179   [ #  #  #  # ]:          0 :     CONVERT_BINOP(&a, &b, v, w, context);
    4180                 :            : 
    4181                 :          0 :     q = dec_alloc();
    4182         [ #  # ]:          0 :     if (q == NULL) {
    4183                 :          0 :         Py_DECREF(a);
    4184                 :          0 :         Py_DECREF(b);
    4185                 :          0 :         return NULL;
    4186                 :            :     }
    4187                 :          0 :     r = dec_alloc();
    4188         [ #  # ]:          0 :     if (r == NULL) {
    4189                 :          0 :         Py_DECREF(a);
    4190                 :          0 :         Py_DECREF(b);
    4191                 :          0 :         Py_DECREF(q);
    4192                 :          0 :         return NULL;
    4193                 :            :     }
    4194                 :            : 
    4195                 :          0 :     mpd_qdivmod(MPD(q), MPD(r), MPD(a), MPD(b), CTX(context), &status);
    4196                 :          0 :     Py_DECREF(a);
    4197                 :          0 :     Py_DECREF(b);
    4198         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    4199                 :          0 :         Py_DECREF(r);
    4200                 :          0 :         Py_DECREF(q);
    4201                 :          0 :         return NULL;
    4202                 :            :     }
    4203                 :            : 
    4204                 :          0 :     ret = Py_BuildValue("(OO)", q, r);
    4205                 :          0 :     Py_DECREF(r);
    4206                 :          0 :     Py_DECREF(q);
    4207                 :          0 :     return ret;
    4208                 :            : }
    4209                 :            : 
    4210                 :            : static PyObject *
    4211                 :         60 : nm_mpd_qpow(PyObject *base, PyObject *exp, PyObject *mod)
    4212                 :            : {
    4213                 :         60 :     PyObject *a, *b, *c = NULL;
    4214                 :            :     PyObject *result;
    4215                 :            :     PyObject *context;
    4216                 :         60 :     uint32_t status = 0;
    4217                 :            : 
    4218         [ -  + ]:         60 :     CURRENT_CONTEXT(context);
    4219   [ -  +  -  + ]:         60 :     CONVERT_BINOP(&a, &b, base, exp, context);
    4220                 :            : 
    4221         [ -  + ]:         60 :     if (mod != Py_None) {
    4222         [ #  # ]:          0 :         if (!convert_op(NOT_IMPL, &c, mod, context)) {
    4223                 :          0 :             Py_DECREF(a);
    4224                 :          0 :             Py_DECREF(b);
    4225                 :          0 :             return c;
    4226                 :            :         }
    4227                 :            :     }
    4228                 :            : 
    4229                 :         60 :     result = dec_alloc();
    4230         [ -  + ]:         60 :     if (result == NULL) {
    4231                 :          0 :         Py_DECREF(a);
    4232                 :          0 :         Py_DECREF(b);
    4233                 :          0 :         Py_XDECREF(c);
    4234                 :          0 :         return NULL;
    4235                 :            :     }
    4236                 :            : 
    4237         [ +  - ]:         60 :     if (c == NULL) {
    4238                 :         60 :         mpd_qpow(MPD(result), MPD(a), MPD(b),
    4239                 :         60 :                  CTX(context), &status);
    4240                 :            :     }
    4241                 :            :     else {
    4242                 :          0 :         mpd_qpowmod(MPD(result), MPD(a), MPD(b), MPD(c),
    4243                 :          0 :                     CTX(context), &status);
    4244                 :          0 :         Py_DECREF(c);
    4245                 :            :     }
    4246                 :         60 :     Py_DECREF(a);
    4247                 :         60 :     Py_DECREF(b);
    4248         [ -  + ]:         60 :     if (dec_addstatus(context, status)) {
    4249                 :          0 :         Py_DECREF(result);
    4250                 :          0 :         return NULL;
    4251                 :            :     }
    4252                 :            : 
    4253                 :         60 :     return result;
    4254                 :            : }
    4255                 :            : 
    4256                 :            : 
    4257                 :            : /******************************************************************************/
    4258                 :            : /*                             Decimal Methods                                */
    4259                 :            : /******************************************************************************/
    4260                 :            : 
    4261                 :            : /* Unary arithmetic functions, optional context arg */
    4262   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qexp)
          #  #  #  #  #  
                #  #  # ]
    4263   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qln)
          #  #  #  #  #  
                #  #  # ]
    4264   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qlog10)
          #  #  #  #  #  
                #  #  # ]
    4265   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qnext_minus)
          #  #  #  #  #  
                #  #  # ]
    4266   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qnext_plus)
          #  #  #  #  #  
                #  #  # ]
    4267   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qreduce)
          #  #  #  #  #  
                #  #  # ]
    4268   [ -  +  +  -  :         30 : Dec_UnaryFuncVA(mpd_qsqrt)
          -  +  -  -  -  
                +  -  + ]
    4269                 :            : 
    4270                 :            : /* Binary arithmetic functions, optional context arg */
    4271   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qcompare)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4272   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qcompare_signal)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4273   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qmax)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4274   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qmax_mag)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4275   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qmin)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4276   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qmin_mag)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4277   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qnext_toward)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4278   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qrem_near)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4279                 :            : 
    4280                 :            : /* Ternary arithmetic functions, optional context arg */
    4281   [ #  #  #  #  :          0 : Dec_TernaryFuncVA(mpd_qfma)
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    4282                 :            : 
    4283                 :            : /* Boolean functions, no context arg */
    4284         [ #  # ]:          0 : Dec_BoolFunc(mpd_iscanonical)
    4285         [ #  # ]:          0 : Dec_BoolFunc(mpd_isfinite)
    4286         [ #  # ]:          0 : Dec_BoolFunc(mpd_isinfinite)
    4287         [ #  # ]:          0 : Dec_BoolFunc(mpd_isnan)
    4288         [ #  # ]:          0 : Dec_BoolFunc(mpd_isqnan)
    4289         [ #  # ]:          0 : Dec_BoolFunc(mpd_issnan)
    4290         [ #  # ]:          0 : Dec_BoolFunc(mpd_issigned)
    4291         [ #  # ]:          0 : Dec_BoolFunc(mpd_iszero)
    4292                 :            : 
    4293                 :            : /* Boolean functions, optional context arg */
    4294   [ #  #  #  #  :          0 : Dec_BoolFuncVA(mpd_isnormal)
          #  #  #  #  #  
                      # ]
    4295   [ #  #  #  #  :          0 : Dec_BoolFuncVA(mpd_issubnormal)
          #  #  #  #  #  
                      # ]
    4296                 :            : 
    4297                 :            : /* Unary functions, no context arg */
    4298                 :            : static PyObject *
    4299                 :          0 : dec_mpd_adjexp(PyObject *self, PyObject *dummy UNUSED)
    4300                 :            : {
    4301                 :            :     mpd_ssize_t retval;
    4302                 :            : 
    4303         [ #  # ]:          0 :     if (mpd_isspecial(MPD(self))) {
    4304                 :          0 :         retval = 0;
    4305                 :            :     }
    4306                 :            :     else {
    4307                 :          0 :         retval = mpd_adjexp(MPD(self));
    4308                 :            :     }
    4309                 :            : 
    4310                 :          0 :     return PyLong_FromSsize_t(retval);
    4311                 :            : }
    4312                 :            : 
    4313                 :            : static PyObject *
    4314                 :          0 : dec_canonical(PyObject *self, PyObject *dummy UNUSED)
    4315                 :            : {
    4316                 :          0 :     return Py_NewRef(self);
    4317                 :            : }
    4318                 :            : 
    4319                 :            : static PyObject *
    4320                 :          0 : dec_conjugate(PyObject *self, PyObject *dummy UNUSED)
    4321                 :            : {
    4322                 :          0 :     return Py_NewRef(self);
    4323                 :            : }
    4324                 :            : 
    4325                 :            : static PyObject *
    4326                 :          0 : dec_mpd_radix(PyObject *self UNUSED, PyObject *dummy UNUSED)
    4327                 :            : {
    4328                 :            :     PyObject *result;
    4329                 :            : 
    4330                 :          0 :     result = dec_alloc();
    4331         [ #  # ]:          0 :     if (result == NULL) {
    4332                 :          0 :         return NULL;
    4333                 :            :     }
    4334                 :            : 
    4335                 :          0 :     _dec_settriple(result, MPD_POS, 10, 0);
    4336                 :          0 :     return result;
    4337                 :            : }
    4338                 :            : 
    4339                 :            : static PyObject *
    4340                 :          0 : dec_mpd_qcopy_abs(PyObject *self, PyObject *dummy UNUSED)
    4341                 :            : {
    4342                 :            :     PyObject *result;
    4343                 :          0 :     uint32_t status = 0;
    4344                 :            : 
    4345         [ #  # ]:          0 :     if ((result = dec_alloc()) == NULL) {
    4346                 :          0 :         return NULL;
    4347                 :            :     }
    4348                 :            : 
    4349                 :          0 :     mpd_qcopy_abs(MPD(result), MPD(self), &status);
    4350         [ #  # ]:          0 :     if (status & MPD_Malloc_error) {
    4351                 :          0 :         Py_DECREF(result);
    4352                 :          0 :         PyErr_NoMemory();
    4353                 :          0 :         return NULL;
    4354                 :            :     }
    4355                 :            : 
    4356                 :          0 :     return result;
    4357                 :            : }
    4358                 :            : 
    4359                 :            : static PyObject *
    4360                 :          0 : dec_mpd_qcopy_negate(PyObject *self, PyObject *dummy UNUSED)
    4361                 :            : {
    4362                 :            :     PyObject *result;
    4363                 :          0 :     uint32_t status = 0;
    4364                 :            : 
    4365         [ #  # ]:          0 :     if ((result = dec_alloc()) == NULL) {
    4366                 :          0 :         return NULL;
    4367                 :            :     }
    4368                 :            : 
    4369                 :          0 :     mpd_qcopy_negate(MPD(result), MPD(self), &status);
    4370         [ #  # ]:          0 :     if (status & MPD_Malloc_error) {
    4371                 :          0 :         Py_DECREF(result);
    4372                 :          0 :         PyErr_NoMemory();
    4373                 :          0 :         return NULL;
    4374                 :            :     }
    4375                 :            : 
    4376                 :          0 :     return result;
    4377                 :            : }
    4378                 :            : 
    4379                 :            : /* Unary functions, optional context arg */
    4380   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qinvert)
          #  #  #  #  #  
                #  #  # ]
    4381   [ #  #  #  #  :          0 : Dec_UnaryFuncVA(mpd_qlogb)
          #  #  #  #  #  
                #  #  # ]
    4382                 :            : 
    4383                 :            : static PyObject *
    4384                 :          0 : dec_mpd_class(PyObject *self, PyObject *args, PyObject *kwds)
    4385                 :            : {
    4386                 :            :     static char *kwlist[] = {"context", NULL};
    4387                 :          0 :     PyObject *context = Py_None;
    4388                 :            :     const char *cp;
    4389                 :            : 
    4390         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist,
    4391                 :            :                                      &context)) {
    4392                 :          0 :         return NULL;
    4393                 :            :     }
    4394   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    4395                 :            : 
    4396                 :          0 :     cp = mpd_class(MPD(self), CTX(context));
    4397                 :          0 :     return PyUnicode_FromString(cp);
    4398                 :            : }
    4399                 :            : 
    4400                 :            : static PyObject *
    4401                 :          0 : dec_mpd_to_eng(PyObject *self, PyObject *args, PyObject *kwds)
    4402                 :            : {
    4403                 :            :     static char *kwlist[] = {"context", NULL};
    4404                 :            :     PyObject *result;
    4405                 :          0 :     PyObject *context = Py_None;
    4406                 :            :     mpd_ssize_t size;
    4407                 :            :     char *s;
    4408                 :            : 
    4409         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist,
    4410                 :            :                                      &context)) {
    4411                 :          0 :         return NULL;
    4412                 :            :     }
    4413   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    4414                 :            : 
    4415                 :          0 :     size = mpd_to_eng_size(&s, MPD(self), CtxCaps(context));
    4416         [ #  # ]:          0 :     if (size < 0) {
    4417                 :          0 :         PyErr_NoMemory();
    4418                 :          0 :         return NULL;
    4419                 :            :     }
    4420                 :            : 
    4421                 :          0 :     result = unicode_fromascii(s, size);
    4422                 :          0 :     mpd_free(s);
    4423                 :            : 
    4424                 :          0 :     return result;
    4425                 :            : }
    4426                 :            : 
    4427                 :            : /* Binary functions, optional context arg for conversion errors */
    4428   [ #  #  #  #  :          0 : Dec_BinaryFuncVA_NO_CTX(mpd_compare_total)
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    4429   [ #  #  #  #  :          0 : Dec_BinaryFuncVA_NO_CTX(mpd_compare_total_mag)
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    4430                 :            : 
    4431                 :            : static PyObject *
    4432                 :          0 : dec_mpd_qcopy_sign(PyObject *self, PyObject *args, PyObject *kwds)
    4433                 :            : {
    4434                 :            :     static char *kwlist[] = {"other", "context", NULL};
    4435                 :            :     PyObject *other;
    4436                 :            :     PyObject *a, *b;
    4437                 :            :     PyObject *result;
    4438                 :          0 :     PyObject *context = Py_None;
    4439                 :          0 :     uint32_t status = 0;
    4440                 :            : 
    4441         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,
    4442                 :            :                                      &other, &context)) {
    4443                 :          0 :         return NULL;
    4444                 :            :     }
    4445   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    4446   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, self, other, context);
    4447                 :            : 
    4448                 :          0 :     result = dec_alloc();
    4449         [ #  # ]:          0 :     if (result == NULL) {
    4450                 :          0 :         Py_DECREF(a);
    4451                 :          0 :         Py_DECREF(b);
    4452                 :          0 :         return NULL;
    4453                 :            :     }
    4454                 :            : 
    4455                 :          0 :     mpd_qcopy_sign(MPD(result), MPD(a), MPD(b), &status);
    4456                 :          0 :     Py_DECREF(a);
    4457                 :          0 :     Py_DECREF(b);
    4458         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    4459                 :          0 :         Py_DECREF(result);
    4460                 :          0 :         return NULL;
    4461                 :            :     }
    4462                 :            : 
    4463                 :          0 :     return result;
    4464                 :            : }
    4465                 :            : 
    4466                 :            : static PyObject *
    4467                 :          0 : dec_mpd_same_quantum(PyObject *self, PyObject *args, PyObject *kwds)
    4468                 :            : {
    4469                 :            :     static char *kwlist[] = {"other", "context", NULL};
    4470                 :            :     PyObject *other;
    4471                 :            :     PyObject *a, *b;
    4472                 :            :     PyObject *result;
    4473                 :          0 :     PyObject *context = Py_None;
    4474                 :            : 
    4475         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,
    4476                 :            :                                      &other, &context)) {
    4477                 :          0 :         return NULL;
    4478                 :            :     }
    4479   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    4480   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, self, other, context);
    4481                 :            : 
    4482         [ #  # ]:          0 :     result = mpd_same_quantum(MPD(a), MPD(b)) ? incr_true() : incr_false();
    4483                 :          0 :     Py_DECREF(a);
    4484                 :          0 :     Py_DECREF(b);
    4485                 :            : 
    4486                 :          0 :     return result;
    4487                 :            : }
    4488                 :            : 
    4489                 :            : /* Binary functions, optional context arg */
    4490   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qand)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4491   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qor)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4492   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qxor)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4493                 :            : 
    4494   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qrotate)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4495   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qscaleb)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4496   [ #  #  #  #  :          0 : Dec_BinaryFuncVA(mpd_qshift)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    4497                 :            : 
    4498                 :            : static PyObject *
    4499                 :          0 : dec_mpd_qquantize(PyObject *v, PyObject *args, PyObject *kwds)
    4500                 :            : {
    4501                 :            :     static char *kwlist[] = {"exp", "rounding", "context", NULL};
    4502                 :          0 :     PyObject *rounding = Py_None;
    4503                 :          0 :     PyObject *context = Py_None;
    4504                 :            :     PyObject *w, *a, *b;
    4505                 :            :     PyObject *result;
    4506                 :          0 :     uint32_t status = 0;
    4507                 :            :     mpd_context_t workctx;
    4508                 :            : 
    4509         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist,
    4510                 :            :                                      &w, &rounding, &context)) {
    4511                 :          0 :         return NULL;
    4512                 :            :     }
    4513   [ #  #  #  #  :          0 :     CONTEXT_CHECK_VA(context);
                   #  # ]
    4514                 :            : 
    4515                 :          0 :     workctx = *CTX(context);
    4516         [ #  # ]:          0 :     if (rounding != Py_None) {
    4517                 :          0 :         int round = getround(rounding);
    4518         [ #  # ]:          0 :         if (round < 0) {
    4519                 :          0 :             return NULL;
    4520                 :            :         }
    4521         [ #  # ]:          0 :         if (!mpd_qsetround(&workctx, round)) {
    4522                 :          0 :             INTERNAL_ERROR_PTR("dec_mpd_qquantize"); /* GCOV_NOT_REACHED */
    4523                 :            :         }
    4524                 :            :     }
    4525                 :            : 
    4526   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, v, w, context);
    4527                 :            : 
    4528                 :          0 :     result = dec_alloc();
    4529         [ #  # ]:          0 :     if (result == NULL) {
    4530                 :          0 :         Py_DECREF(a);
    4531                 :          0 :         Py_DECREF(b);
    4532                 :          0 :         return NULL;
    4533                 :            :     }
    4534                 :            : 
    4535                 :          0 :     mpd_qquantize(MPD(result), MPD(a), MPD(b), &workctx, &status);
    4536                 :          0 :     Py_DECREF(a);
    4537                 :          0 :     Py_DECREF(b);
    4538         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    4539                 :          0 :         Py_DECREF(result);
    4540                 :          0 :         return NULL;
    4541                 :            :     }
    4542                 :            : 
    4543                 :          0 :     return result;
    4544                 :            : }
    4545                 :            : 
    4546                 :            : /* Special methods */
    4547                 :            : static PyObject *
    4548                 :          5 : dec_richcompare(PyObject *v, PyObject *w, int op)
    4549                 :            : {
    4550                 :            :     PyObject *a;
    4551                 :            :     PyObject *b;
    4552                 :            :     PyObject *context;
    4553                 :          5 :     uint32_t status = 0;
    4554                 :            :     int a_issnan, b_issnan;
    4555                 :            :     int r;
    4556                 :            : 
    4557                 :            :     assert(PyDec_Check(v));
    4558                 :            : 
    4559         [ -  + ]:          5 :     CURRENT_CONTEXT(context);
    4560         [ -  + ]:          5 :     CONVERT_BINOP_CMP(&a, &b, v, w, op, context);
    4561                 :            : 
    4562                 :          5 :     a_issnan = mpd_issnan(MPD(a));
    4563                 :          5 :     b_issnan = mpd_issnan(MPD(b));
    4564                 :            : 
    4565                 :          5 :     r = mpd_qcmp(MPD(a), MPD(b), &status);
    4566                 :          5 :     Py_DECREF(a);
    4567                 :          5 :     Py_DECREF(b);
    4568         [ -  + ]:          5 :     if (r == INT_MAX) {
    4569                 :            :         /* sNaNs or op={le,ge,lt,gt} always signal. */
    4570   [ #  #  #  #  :          0 :         if (a_issnan || b_issnan || (op != Py_EQ && op != Py_NE)) {
             #  #  #  # ]
    4571         [ #  # ]:          0 :             if (dec_addstatus(context, status)) {
    4572                 :          0 :                 return NULL;
    4573                 :            :             }
    4574                 :            :         }
    4575                 :            :         /* qNaN comparison with op={eq,ne} or comparison
    4576                 :            :          * with InvalidOperation disabled. */
    4577         [ #  # ]:          0 :         return (op == Py_NE) ? incr_true() : incr_false();
    4578                 :            :     }
    4579                 :            : 
    4580   [ +  -  -  -  :          5 :     switch (op) {
                -  -  - ]
    4581                 :          5 :     case Py_EQ:
    4582                 :          5 :         r = (r == 0);
    4583                 :          5 :         break;
    4584                 :          0 :     case Py_NE:
    4585                 :          0 :         r = (r != 0);
    4586                 :          0 :         break;
    4587                 :          0 :     case Py_LE:
    4588                 :          0 :         r = (r <= 0);
    4589                 :          0 :         break;
    4590                 :          0 :     case Py_GE:
    4591                 :          0 :         r = (r >= 0);
    4592                 :          0 :         break;
    4593                 :          0 :     case Py_LT:
    4594                 :          0 :         r = (r == -1);
    4595                 :          0 :         break;
    4596                 :          0 :     case Py_GT:
    4597                 :          0 :         r = (r == 1);
    4598                 :          0 :         break;
    4599                 :            :     }
    4600                 :            : 
    4601                 :          5 :     return PyBool_FromLong(r);
    4602                 :            : }
    4603                 :            : 
    4604                 :            : /* __ceil__ */
    4605                 :            : static PyObject *
    4606                 :          0 : dec_ceil(PyObject *self, PyObject *dummy UNUSED)
    4607                 :            : {
    4608                 :            :     PyObject *context;
    4609                 :            : 
    4610         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    4611                 :          0 :     return dec_as_long(self, context, MPD_ROUND_CEILING);
    4612                 :            : }
    4613                 :            : 
    4614                 :            : /* __complex__ */
    4615                 :            : static PyObject *
    4616                 :          0 : dec_complex(PyObject *self, PyObject *dummy UNUSED)
    4617                 :            : {
    4618                 :            :     PyObject *f;
    4619                 :            :     double x;
    4620                 :            : 
    4621                 :          0 :     f = PyDec_AsFloat(self);
    4622         [ #  # ]:          0 :     if (f == NULL) {
    4623                 :          0 :         return NULL;
    4624                 :            :     }
    4625                 :            : 
    4626                 :          0 :     x = PyFloat_AsDouble(f);
    4627                 :          0 :     Py_DECREF(f);
    4628   [ #  #  #  # ]:          0 :     if (x == -1.0 && PyErr_Occurred()) {
    4629                 :          0 :         return NULL;
    4630                 :            :     }
    4631                 :            : 
    4632                 :          0 :     return PyComplex_FromDoubles(x, 0);
    4633                 :            : }
    4634                 :            : 
    4635                 :            : /* __copy__ and __deepcopy__ */
    4636                 :            : static PyObject *
    4637                 :          0 : dec_copy(PyObject *self, PyObject *dummy UNUSED)
    4638                 :            : {
    4639                 :          0 :     return Py_NewRef(self);
    4640                 :            : }
    4641                 :            : 
    4642                 :            : /* __floor__ */
    4643                 :            : static PyObject *
    4644                 :          0 : dec_floor(PyObject *self, PyObject *dummy UNUSED)
    4645                 :            : {
    4646                 :            :     PyObject *context;
    4647                 :            : 
    4648         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    4649                 :          0 :     return dec_as_long(self, context, MPD_ROUND_FLOOR);
    4650                 :            : }
    4651                 :            : 
    4652                 :            : /* Always uses the module context */
    4653                 :            : static Py_hash_t
    4654                 :          0 : _dec_hash(PyDecObject *v)
    4655                 :            : {
    4656                 :            : #if defined(CONFIG_64) && _PyHASH_BITS == 61
    4657                 :            :     /* 2**61 - 1 */
    4658                 :          0 :     mpd_uint_t p_data[1] = {2305843009213693951ULL};
    4659                 :          0 :     mpd_t p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 19, 1, 1, p_data};
    4660                 :            :     /* Inverse of 10 modulo p */
    4661                 :          0 :     mpd_uint_t inv10_p_data[1] = {2075258708292324556ULL};
    4662                 :          0 :     mpd_t inv10_p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA,
    4663                 :            :                      0, 19, 1, 1, inv10_p_data};
    4664                 :            : #elif defined(CONFIG_32) && _PyHASH_BITS == 31
    4665                 :            :     /* 2**31 - 1 */
    4666                 :            :     mpd_uint_t p_data[2] = {147483647UL, 2};
    4667                 :            :     mpd_t p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 10, 2, 2, p_data};
    4668                 :            :     /* Inverse of 10 modulo p */
    4669                 :            :     mpd_uint_t inv10_p_data[2] = {503238553UL, 1};
    4670                 :            :     mpd_t inv10_p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA,
    4671                 :            :                      0, 10, 2, 2, inv10_p_data};
    4672                 :            : #else
    4673                 :            :     #error "No valid combination of CONFIG_64, CONFIG_32 and _PyHASH_BITS"
    4674                 :            : #endif
    4675                 :          0 :     const Py_hash_t py_hash_inf = 314159;
    4676                 :          0 :     mpd_uint_t ten_data[1] = {10};
    4677                 :          0 :     mpd_t ten = {MPD_POS|MPD_STATIC|MPD_CONST_DATA,
    4678                 :            :                  0, 2, 1, 1, ten_data};
    4679                 :            :     Py_hash_t result;
    4680                 :          0 :     mpd_t *exp_hash = NULL;
    4681                 :          0 :     mpd_t *tmp = NULL;
    4682                 :            :     mpd_ssize_t exp;
    4683                 :          0 :     uint32_t status = 0;
    4684                 :            :     mpd_context_t maxctx;
    4685                 :            : 
    4686                 :            : 
    4687         [ #  # ]:          0 :     if (mpd_isspecial(MPD(v))) {
    4688         [ #  # ]:          0 :         if (mpd_issnan(MPD(v))) {
    4689                 :          0 :             PyErr_SetString(PyExc_TypeError,
    4690                 :            :                 "Cannot hash a signaling NaN value");
    4691                 :          0 :             return -1;
    4692                 :            :         }
    4693         [ #  # ]:          0 :         else if (mpd_isnan(MPD(v))) {
    4694                 :          0 :             return _Py_HashPointer(v);
    4695                 :            :         }
    4696                 :            :         else {
    4697                 :          0 :             return py_hash_inf * mpd_arith_sign(MPD(v));
    4698                 :            :         }
    4699                 :            :     }
    4700                 :            : 
    4701                 :          0 :     mpd_maxcontext(&maxctx);
    4702                 :          0 :     exp_hash = mpd_qnew();
    4703         [ #  # ]:          0 :     if (exp_hash == NULL) {
    4704                 :          0 :         goto malloc_error;
    4705                 :            :     }
    4706                 :          0 :     tmp = mpd_qnew();
    4707         [ #  # ]:          0 :     if (tmp == NULL) {
    4708                 :          0 :         goto malloc_error;
    4709                 :            :     }
    4710                 :            : 
    4711                 :            :     /*
    4712                 :            :      * exp(v): exponent of v
    4713                 :            :      * int(v): coefficient of v
    4714                 :            :      */
    4715                 :          0 :     exp = MPD(v)->exp;
    4716         [ #  # ]:          0 :     if (exp >= 0) {
    4717                 :            :         /* 10**exp(v) % p */
    4718                 :          0 :         mpd_qsset_ssize(tmp, exp, &maxctx, &status);
    4719                 :          0 :         mpd_qpowmod(exp_hash, &ten, tmp, &p, &maxctx, &status);
    4720                 :            :     }
    4721                 :            :     else {
    4722                 :            :         /* inv10_p**(-exp(v)) % p */
    4723                 :          0 :         mpd_qsset_ssize(tmp, -exp, &maxctx, &status);
    4724                 :          0 :         mpd_qpowmod(exp_hash, &inv10_p, tmp, &p, &maxctx, &status);
    4725                 :            :     }
    4726                 :            : 
    4727                 :            :     /* hash = (int(v) * exp_hash) % p */
    4728         [ #  # ]:          0 :     if (!mpd_qcopy(tmp, MPD(v), &status)) {
    4729                 :          0 :         goto malloc_error;
    4730                 :            :     }
    4731                 :          0 :     tmp->exp = 0;
    4732                 :          0 :     mpd_set_positive(tmp);
    4733                 :            : 
    4734                 :          0 :     maxctx.prec = MPD_MAX_PREC + 21;
    4735                 :          0 :     maxctx.emax = MPD_MAX_EMAX + 21;
    4736                 :          0 :     maxctx.emin = MPD_MIN_EMIN - 21;
    4737                 :            : 
    4738                 :          0 :     mpd_qmul(tmp, tmp, exp_hash, &maxctx, &status);
    4739                 :          0 :     mpd_qrem(tmp, tmp, &p, &maxctx, &status);
    4740                 :            : 
    4741                 :          0 :     result = mpd_qget_ssize(tmp, &status);
    4742         [ #  # ]:          0 :     result = mpd_ispositive(MPD(v)) ? result : -result;
    4743         [ #  # ]:          0 :     result = (result == -1) ? -2 : result;
    4744                 :            : 
    4745         [ #  # ]:          0 :     if (status != 0) {
    4746         [ #  # ]:          0 :         if (status & MPD_Malloc_error) {
    4747                 :          0 :             goto malloc_error;
    4748                 :            :         }
    4749                 :            :         else {
    4750                 :          0 :             PyErr_SetString(PyExc_RuntimeError, /* GCOV_NOT_REACHED */
    4751                 :            :                 "dec_hash: internal error: please report"); /* GCOV_NOT_REACHED */
    4752                 :            :         }
    4753                 :          0 :         result = -1; /* GCOV_NOT_REACHED */
    4754                 :            :     }
    4755                 :            : 
    4756                 :            : 
    4757                 :          0 : finish:
    4758         [ #  # ]:          0 :     if (exp_hash) mpd_del(exp_hash);
    4759         [ #  # ]:          0 :     if (tmp) mpd_del(tmp);
    4760                 :          0 :     return result;
    4761                 :            : 
    4762                 :          0 : malloc_error:
    4763                 :          0 :     PyErr_NoMemory();
    4764                 :          0 :     result = -1;
    4765                 :          0 :     goto finish;
    4766                 :            : }
    4767                 :            : 
    4768                 :            : static Py_hash_t
    4769                 :          0 : dec_hash(PyDecObject *self)
    4770                 :            : {
    4771         [ #  # ]:          0 :     if (self->hash == -1) {
    4772                 :          0 :         self->hash = _dec_hash(self);
    4773                 :            :     }
    4774                 :            : 
    4775                 :          0 :     return self->hash;
    4776                 :            : }
    4777                 :            : 
    4778                 :            : /* __reduce__ */
    4779                 :            : static PyObject *
    4780                 :          0 : dec_reduce(PyObject *self, PyObject *dummy UNUSED)
    4781                 :            : {
    4782                 :            :     PyObject *result, *str;
    4783                 :            : 
    4784                 :          0 :     str = dec_str(self);
    4785         [ #  # ]:          0 :     if (str == NULL) {
    4786                 :          0 :         return NULL;
    4787                 :            :     }
    4788                 :            : 
    4789                 :          0 :     result = Py_BuildValue("O(O)", Py_TYPE(self), str);
    4790                 :          0 :     Py_DECREF(str);
    4791                 :            : 
    4792                 :          0 :     return result;
    4793                 :            : }
    4794                 :            : 
    4795                 :            : /* __sizeof__ */
    4796                 :            : static PyObject *
    4797                 :          0 : dec_sizeof(PyObject *v, PyObject *dummy UNUSED)
    4798                 :            : {
    4799                 :          0 :     size_t res = _PyObject_SIZE(Py_TYPE(v));
    4800         [ #  # ]:          0 :     if (mpd_isdynamic_data(MPD(v))) {
    4801                 :          0 :         res += (size_t)MPD(v)->alloc * sizeof(mpd_uint_t);
    4802                 :            :     }
    4803                 :          0 :     return PyLong_FromSize_t(res);
    4804                 :            : }
    4805                 :            : 
    4806                 :            : /* __trunc__ */
    4807                 :            : static PyObject *
    4808                 :          0 : dec_trunc(PyObject *self, PyObject *dummy UNUSED)
    4809                 :            : {
    4810                 :            :     PyObject *context;
    4811                 :            : 
    4812         [ #  # ]:          0 :     CURRENT_CONTEXT(context);
    4813                 :          0 :     return dec_as_long(self, context, MPD_ROUND_DOWN);
    4814                 :            : }
    4815                 :            : 
    4816                 :            : /* real and imag */
    4817                 :            : static PyObject *
    4818                 :          0 : dec_real(PyObject *self, void *closure UNUSED)
    4819                 :            : {
    4820                 :          0 :     return Py_NewRef(self);
    4821                 :            : }
    4822                 :            : 
    4823                 :            : static PyObject *
    4824                 :          0 : dec_imag(PyObject *self UNUSED, void *closure UNUSED)
    4825                 :            : {
    4826                 :            :     PyObject *result;
    4827                 :            : 
    4828                 :          0 :     result = dec_alloc();
    4829         [ #  # ]:          0 :     if (result == NULL) {
    4830                 :          0 :         return NULL;
    4831                 :            :     }
    4832                 :            : 
    4833                 :          0 :     _dec_settriple(result, MPD_POS, 0, 0);
    4834                 :          0 :     return result;
    4835                 :            : }
    4836                 :            : 
    4837                 :            : 
    4838                 :            : static PyGetSetDef dec_getsets [] =
    4839                 :            : {
    4840                 :            :   { "real", (getter)dec_real, NULL, NULL, NULL},
    4841                 :            :   { "imag", (getter)dec_imag, NULL, NULL, NULL},
    4842                 :            :   {NULL}
    4843                 :            : };
    4844                 :            : 
    4845                 :            : static PyNumberMethods dec_number_methods =
    4846                 :            : {
    4847                 :            :     (binaryfunc) nm_mpd_qadd,
    4848                 :            :     (binaryfunc) nm_mpd_qsub,
    4849                 :            :     (binaryfunc) nm_mpd_qmul,
    4850                 :            :     (binaryfunc) nm_mpd_qrem,
    4851                 :            :     (binaryfunc) nm_mpd_qdivmod,
    4852                 :            :     (ternaryfunc) nm_mpd_qpow,
    4853                 :            :     (unaryfunc) nm_mpd_qminus,
    4854                 :            :     (unaryfunc) nm_mpd_qplus,
    4855                 :            :     (unaryfunc) nm_mpd_qabs,
    4856                 :            :     (inquiry) nm_nonzero,
    4857                 :            :     (unaryfunc) 0,   /* no bit-complement */
    4858                 :            :     (binaryfunc) 0,  /* no shiftl */
    4859                 :            :     (binaryfunc) 0,  /* no shiftr */
    4860                 :            :     (binaryfunc) 0,  /* no bit-and */
    4861                 :            :     (binaryfunc) 0,  /* no bit-xor */
    4862                 :            :     (binaryfunc) 0,  /* no bit-ior */
    4863                 :            :     (unaryfunc) nm_dec_as_long,
    4864                 :            :     0,               /* nb_reserved */
    4865                 :            :     (unaryfunc) PyDec_AsFloat,
    4866                 :            :     0,               /* binaryfunc nb_inplace_add; */
    4867                 :            :     0,               /* binaryfunc nb_inplace_subtract; */
    4868                 :            :     0,               /* binaryfunc nb_inplace_multiply; */
    4869                 :            :     0,               /* binaryfunc nb_inplace_remainder; */
    4870                 :            :     0,               /* ternaryfunc nb_inplace_power; */
    4871                 :            :     0,               /* binaryfunc nb_inplace_lshift; */
    4872                 :            :     0,               /* binaryfunc nb_inplace_rshift; */
    4873                 :            :     0,               /* binaryfunc nb_inplace_and; */
    4874                 :            :     0,               /* binaryfunc nb_inplace_xor; */
    4875                 :            :     0,               /* binaryfunc nb_inplace_or; */
    4876                 :            :     (binaryfunc) nm_mpd_qdivint,  /* binaryfunc nb_floor_divide; */
    4877                 :            :     (binaryfunc) nm_mpd_qdiv,     /* binaryfunc nb_true_divide; */
    4878                 :            :     0,               /* binaryfunc nb_inplace_floor_divide; */
    4879                 :            :     0,               /* binaryfunc nb_inplace_true_divide; */
    4880                 :            : };
    4881                 :            : 
    4882                 :            : static PyMethodDef dec_methods [] =
    4883                 :            : {
    4884                 :            :   /* Unary arithmetic functions, optional context arg */
    4885                 :            :   { "exp", _PyCFunction_CAST(dec_mpd_qexp), METH_VARARGS|METH_KEYWORDS, doc_exp },
    4886                 :            :   { "ln", _PyCFunction_CAST(dec_mpd_qln), METH_VARARGS|METH_KEYWORDS, doc_ln },
    4887                 :            :   { "log10", _PyCFunction_CAST(dec_mpd_qlog10), METH_VARARGS|METH_KEYWORDS, doc_log10 },
    4888                 :            :   { "next_minus", _PyCFunction_CAST(dec_mpd_qnext_minus), METH_VARARGS|METH_KEYWORDS, doc_next_minus },
    4889                 :            :   { "next_plus", _PyCFunction_CAST(dec_mpd_qnext_plus), METH_VARARGS|METH_KEYWORDS, doc_next_plus },
    4890                 :            :   { "normalize", _PyCFunction_CAST(dec_mpd_qreduce), METH_VARARGS|METH_KEYWORDS, doc_normalize },
    4891                 :            :   { "to_integral", _PyCFunction_CAST(PyDec_ToIntegralValue), METH_VARARGS|METH_KEYWORDS, doc_to_integral },
    4892                 :            :   { "to_integral_exact", _PyCFunction_CAST(PyDec_ToIntegralExact), METH_VARARGS|METH_KEYWORDS, doc_to_integral_exact },
    4893                 :            :   { "to_integral_value", _PyCFunction_CAST(PyDec_ToIntegralValue), METH_VARARGS|METH_KEYWORDS, doc_to_integral_value },
    4894                 :            :   { "sqrt", _PyCFunction_CAST(dec_mpd_qsqrt), METH_VARARGS|METH_KEYWORDS, doc_sqrt },
    4895                 :            : 
    4896                 :            :   /* Binary arithmetic functions, optional context arg */
    4897                 :            :   { "compare", _PyCFunction_CAST(dec_mpd_qcompare), METH_VARARGS|METH_KEYWORDS, doc_compare },
    4898                 :            :   { "compare_signal", _PyCFunction_CAST(dec_mpd_qcompare_signal), METH_VARARGS|METH_KEYWORDS, doc_compare_signal },
    4899                 :            :   { "max", _PyCFunction_CAST(dec_mpd_qmax), METH_VARARGS|METH_KEYWORDS, doc_max },
    4900                 :            :   { "max_mag", _PyCFunction_CAST(dec_mpd_qmax_mag), METH_VARARGS|METH_KEYWORDS, doc_max_mag },
    4901                 :            :   { "min", _PyCFunction_CAST(dec_mpd_qmin), METH_VARARGS|METH_KEYWORDS, doc_min },
    4902                 :            :   { "min_mag", _PyCFunction_CAST(dec_mpd_qmin_mag), METH_VARARGS|METH_KEYWORDS, doc_min_mag },
    4903                 :            :   { "next_toward", _PyCFunction_CAST(dec_mpd_qnext_toward), METH_VARARGS|METH_KEYWORDS, doc_next_toward },
    4904                 :            :   { "quantize", _PyCFunction_CAST(dec_mpd_qquantize), METH_VARARGS|METH_KEYWORDS, doc_quantize },
    4905                 :            :   { "remainder_near", _PyCFunction_CAST(dec_mpd_qrem_near), METH_VARARGS|METH_KEYWORDS, doc_remainder_near },
    4906                 :            : 
    4907                 :            :   /* Ternary arithmetic functions, optional context arg */
    4908                 :            :   { "fma", _PyCFunction_CAST(dec_mpd_qfma), METH_VARARGS|METH_KEYWORDS, doc_fma },
    4909                 :            : 
    4910                 :            :   /* Boolean functions, no context arg */
    4911                 :            :   { "is_canonical", dec_mpd_iscanonical, METH_NOARGS, doc_is_canonical },
    4912                 :            :   { "is_finite", dec_mpd_isfinite, METH_NOARGS, doc_is_finite },
    4913                 :            :   { "is_infinite", dec_mpd_isinfinite, METH_NOARGS, doc_is_infinite },
    4914                 :            :   { "is_nan", dec_mpd_isnan, METH_NOARGS, doc_is_nan },
    4915                 :            :   { "is_qnan", dec_mpd_isqnan, METH_NOARGS, doc_is_qnan },
    4916                 :            :   { "is_snan", dec_mpd_issnan, METH_NOARGS, doc_is_snan },
    4917                 :            :   { "is_signed", dec_mpd_issigned, METH_NOARGS, doc_is_signed },
    4918                 :            :   { "is_zero", dec_mpd_iszero, METH_NOARGS, doc_is_zero },
    4919                 :            : 
    4920                 :            :   /* Boolean functions, optional context arg */
    4921                 :            :   { "is_normal", _PyCFunction_CAST(dec_mpd_isnormal), METH_VARARGS|METH_KEYWORDS, doc_is_normal },
    4922                 :            :   { "is_subnormal", _PyCFunction_CAST(dec_mpd_issubnormal), METH_VARARGS|METH_KEYWORDS, doc_is_subnormal },
    4923                 :            : 
    4924                 :            :   /* Unary functions, no context arg */
    4925                 :            :   { "adjusted", dec_mpd_adjexp, METH_NOARGS, doc_adjusted },
    4926                 :            :   { "canonical", dec_canonical, METH_NOARGS, doc_canonical },
    4927                 :            :   { "conjugate", dec_conjugate, METH_NOARGS, doc_conjugate },
    4928                 :            :   { "radix", dec_mpd_radix, METH_NOARGS, doc_radix },
    4929                 :            : 
    4930                 :            :   /* Unary functions, optional context arg for conversion errors */
    4931                 :            :   { "copy_abs", dec_mpd_qcopy_abs, METH_NOARGS, doc_copy_abs },
    4932                 :            :   { "copy_negate", dec_mpd_qcopy_negate, METH_NOARGS, doc_copy_negate },
    4933                 :            : 
    4934                 :            :   /* Unary functions, optional context arg */
    4935                 :            :   { "logb", _PyCFunction_CAST(dec_mpd_qlogb), METH_VARARGS|METH_KEYWORDS, doc_logb },
    4936                 :            :   { "logical_invert", _PyCFunction_CAST(dec_mpd_qinvert), METH_VARARGS|METH_KEYWORDS, doc_logical_invert },
    4937                 :            :   { "number_class", _PyCFunction_CAST(dec_mpd_class), METH_VARARGS|METH_KEYWORDS, doc_number_class },
    4938                 :            :   { "to_eng_string", _PyCFunction_CAST(dec_mpd_to_eng), METH_VARARGS|METH_KEYWORDS, doc_to_eng_string },
    4939                 :            : 
    4940                 :            :   /* Binary functions, optional context arg for conversion errors */
    4941                 :            :   { "compare_total", _PyCFunction_CAST(dec_mpd_compare_total), METH_VARARGS|METH_KEYWORDS, doc_compare_total },
    4942                 :            :   { "compare_total_mag", _PyCFunction_CAST(dec_mpd_compare_total_mag), METH_VARARGS|METH_KEYWORDS, doc_compare_total_mag },
    4943                 :            :   { "copy_sign", _PyCFunction_CAST(dec_mpd_qcopy_sign), METH_VARARGS|METH_KEYWORDS, doc_copy_sign },
    4944                 :            :   { "same_quantum", _PyCFunction_CAST(dec_mpd_same_quantum), METH_VARARGS|METH_KEYWORDS, doc_same_quantum },
    4945                 :            : 
    4946                 :            :   /* Binary functions, optional context arg */
    4947                 :            :   { "logical_and", _PyCFunction_CAST(dec_mpd_qand), METH_VARARGS|METH_KEYWORDS, doc_logical_and },
    4948                 :            :   { "logical_or", _PyCFunction_CAST(dec_mpd_qor), METH_VARARGS|METH_KEYWORDS, doc_logical_or },
    4949                 :            :   { "logical_xor", _PyCFunction_CAST(dec_mpd_qxor), METH_VARARGS|METH_KEYWORDS, doc_logical_xor },
    4950                 :            :   { "rotate", _PyCFunction_CAST(dec_mpd_qrotate), METH_VARARGS|METH_KEYWORDS, doc_rotate },
    4951                 :            :   { "scaleb", _PyCFunction_CAST(dec_mpd_qscaleb), METH_VARARGS|METH_KEYWORDS, doc_scaleb },
    4952                 :            :   { "shift", _PyCFunction_CAST(dec_mpd_qshift), METH_VARARGS|METH_KEYWORDS, doc_shift },
    4953                 :            : 
    4954                 :            :   /* Miscellaneous */
    4955                 :            :   { "from_float", dec_from_float, METH_O|METH_CLASS, doc_from_float },
    4956                 :            :   { "as_tuple", PyDec_AsTuple, METH_NOARGS, doc_as_tuple },
    4957                 :            :   { "as_integer_ratio", dec_as_integer_ratio, METH_NOARGS, doc_as_integer_ratio },
    4958                 :            : 
    4959                 :            :   /* Special methods */
    4960                 :            :   { "__copy__", dec_copy, METH_NOARGS, NULL },
    4961                 :            :   { "__deepcopy__", dec_copy, METH_O, NULL },
    4962                 :            :   { "__format__", dec_format, METH_VARARGS, NULL },
    4963                 :            :   { "__reduce__", dec_reduce, METH_NOARGS, NULL },
    4964                 :            :   { "__round__", PyDec_Round, METH_VARARGS, NULL },
    4965                 :            :   { "__ceil__", dec_ceil, METH_NOARGS, NULL },
    4966                 :            :   { "__floor__", dec_floor, METH_NOARGS, NULL },
    4967                 :            :   { "__trunc__", dec_trunc, METH_NOARGS, NULL },
    4968                 :            :   { "__complex__", dec_complex, METH_NOARGS, NULL },
    4969                 :            :   { "__sizeof__", dec_sizeof, METH_NOARGS, NULL },
    4970                 :            : 
    4971                 :            :   { NULL, NULL, 1 }
    4972                 :            : };
    4973                 :            : 
    4974                 :            : static PyTypeObject PyDec_Type =
    4975                 :            : {
    4976                 :            :     PyVarObject_HEAD_INIT(NULL, 0)
    4977                 :            :     "decimal.Decimal",                      /* tp_name */
    4978                 :            :     sizeof(PyDecObject),                    /* tp_basicsize */
    4979                 :            :     0,                                      /* tp_itemsize */
    4980                 :            :     (destructor) dec_dealloc,               /* tp_dealloc */
    4981                 :            :     0,                                      /* tp_vectorcall_offset */
    4982                 :            :     (getattrfunc) 0,                        /* tp_getattr */
    4983                 :            :     (setattrfunc) 0,                        /* tp_setattr */
    4984                 :            :     0,                                      /* tp_as_async */
    4985                 :            :     (reprfunc) dec_repr,                    /* tp_repr */
    4986                 :            :     &dec_number_methods,                    /* tp_as_number */
    4987                 :            :     0,                                      /* tp_as_sequence */
    4988                 :            :     0,                                      /* tp_as_mapping */
    4989                 :            :     (hashfunc) dec_hash,                    /* tp_hash */
    4990                 :            :     0,                                      /* tp_call */
    4991                 :            :     (reprfunc) dec_str,                     /* tp_str */
    4992                 :            :     (getattrofunc) PyObject_GenericGetAttr, /* tp_getattro */
    4993                 :            :     (setattrofunc) 0,                       /* tp_setattro */
    4994                 :            :     (PyBufferProcs *) 0,                    /* tp_as_buffer */
    4995                 :            :     (Py_TPFLAGS_DEFAULT|
    4996                 :            :      Py_TPFLAGS_BASETYPE),                  /* tp_flags */
    4997                 :            :     doc_decimal,                            /* tp_doc */
    4998                 :            :     0,                                      /* tp_traverse */
    4999                 :            :     0,                                      /* tp_clear */
    5000                 :            :     dec_richcompare,                        /* tp_richcompare */
    5001                 :            :     0,                                      /* tp_weaklistoffset */
    5002                 :            :     0,                                      /* tp_iter */
    5003                 :            :     0,                                      /* tp_iternext */
    5004                 :            :     dec_methods,                            /* tp_methods */
    5005                 :            :     0,                                      /* tp_members */
    5006                 :            :     dec_getsets,                            /* tp_getset */
    5007                 :            :     0,                                      /* tp_base */
    5008                 :            :     0,                                      /* tp_dict */
    5009                 :            :     0,                                      /* tp_descr_get */
    5010                 :            :     0,                                      /* tp_descr_set */
    5011                 :            :     0,                                      /* tp_dictoffset */
    5012                 :            :     0,                                      /* tp_init */
    5013                 :            :     0,                                      /* tp_alloc */
    5014                 :            :     dec_new,                                /* tp_new */
    5015                 :            :     PyObject_Del,                           /* tp_free */
    5016                 :            : };
    5017                 :            : 
    5018                 :            : 
    5019                 :            : /******************************************************************************/
    5020                 :            : /*                         Context Object, Part 2                             */
    5021                 :            : /******************************************************************************/
    5022                 :            : 
    5023                 :            : 
    5024                 :            : /************************************************************************/
    5025                 :            : /*     Macros for converting mpdecimal functions to Context methods     */
    5026                 :            : /************************************************************************/
    5027                 :            : 
    5028                 :            : /* Boolean context method. */
    5029                 :            : #define DecCtx_BoolFunc(MPDFUNC) \
    5030                 :            : static PyObject *                                                     \
    5031                 :            : ctx_##MPDFUNC(PyObject *context, PyObject *v)                         \
    5032                 :            : {                                                                     \
    5033                 :            :     PyObject *ret;                                                    \
    5034                 :            :     PyObject *a;                                                      \
    5035                 :            :                                                                       \
    5036                 :            :     CONVERT_OP_RAISE(&a, v, context);                                 \
    5037                 :            :                                                                       \
    5038                 :            :     ret = MPDFUNC(MPD(a), CTX(context)) ? incr_true() : incr_false(); \
    5039                 :            :     Py_DECREF(a);                                                     \
    5040                 :            :     return ret;                                                       \
    5041                 :            : }
    5042                 :            : 
    5043                 :            : /* Boolean context method. MPDFUNC does NOT use a context. */
    5044                 :            : #define DecCtx_BoolFunc_NO_CTX(MPDFUNC) \
    5045                 :            : static PyObject *                                       \
    5046                 :            : ctx_##MPDFUNC(PyObject *context, PyObject *v)           \
    5047                 :            : {                                                       \
    5048                 :            :     PyObject *ret;                                      \
    5049                 :            :     PyObject *a;                                        \
    5050                 :            :                                                         \
    5051                 :            :     CONVERT_OP_RAISE(&a, v, context);                   \
    5052                 :            :                                                         \
    5053                 :            :     ret = MPDFUNC(MPD(a)) ? incr_true() : incr_false(); \
    5054                 :            :     Py_DECREF(a);                                       \
    5055                 :            :     return ret;                                         \
    5056                 :            : }
    5057                 :            : 
    5058                 :            : /* Unary context method. */
    5059                 :            : #define DecCtx_UnaryFunc(MPDFUNC) \
    5060                 :            : static PyObject *                                        \
    5061                 :            : ctx_##MPDFUNC(PyObject *context, PyObject *v)            \
    5062                 :            : {                                                        \
    5063                 :            :     PyObject *result, *a;                                \
    5064                 :            :     uint32_t status = 0;                                 \
    5065                 :            :                                                          \
    5066                 :            :     CONVERT_OP_RAISE(&a, v, context);                    \
    5067                 :            :                                                          \
    5068                 :            :     if ((result = dec_alloc()) == NULL) {                \
    5069                 :            :         Py_DECREF(a);                                    \
    5070                 :            :         return NULL;                                     \
    5071                 :            :     }                                                    \
    5072                 :            :                                                          \
    5073                 :            :     MPDFUNC(MPD(result), MPD(a), CTX(context), &status); \
    5074                 :            :     Py_DECREF(a);                                        \
    5075                 :            :     if (dec_addstatus(context, status)) {                \
    5076                 :            :         Py_DECREF(result);                               \
    5077                 :            :         return NULL;                                     \
    5078                 :            :     }                                                    \
    5079                 :            :                                                          \
    5080                 :            :     return result;                                       \
    5081                 :            : }
    5082                 :            : 
    5083                 :            : /* Binary context method. */
    5084                 :            : #define DecCtx_BinaryFunc(MPDFUNC) \
    5085                 :            : static PyObject *                                                \
    5086                 :            : ctx_##MPDFUNC(PyObject *context, PyObject *args)                 \
    5087                 :            : {                                                                \
    5088                 :            :     PyObject *v, *w;                                             \
    5089                 :            :     PyObject *a, *b;                                             \
    5090                 :            :     PyObject *result;                                            \
    5091                 :            :     uint32_t status = 0;                                         \
    5092                 :            :                                                                  \
    5093                 :            :     if (!PyArg_ParseTuple(args, "OO", &v, &w)) {                 \
    5094                 :            :         return NULL;                                             \
    5095                 :            :     }                                                            \
    5096                 :            :                                                                  \
    5097                 :            :     CONVERT_BINOP_RAISE(&a, &b, v, w, context);                  \
    5098                 :            :                                                                  \
    5099                 :            :     if ((result = dec_alloc()) == NULL) {                        \
    5100                 :            :         Py_DECREF(a);                                            \
    5101                 :            :         Py_DECREF(b);                                            \
    5102                 :            :         return NULL;                                             \
    5103                 :            :     }                                                            \
    5104                 :            :                                                                  \
    5105                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b), CTX(context), &status); \
    5106                 :            :     Py_DECREF(a);                                                \
    5107                 :            :     Py_DECREF(b);                                                \
    5108                 :            :     if (dec_addstatus(context, status)) {                        \
    5109                 :            :         Py_DECREF(result);                                       \
    5110                 :            :         return NULL;                                             \
    5111                 :            :     }                                                            \
    5112                 :            :                                                                  \
    5113                 :            :     return result;                                               \
    5114                 :            : }
    5115                 :            : 
    5116                 :            : /*
    5117                 :            :  * Binary context method. The context is only used for conversion.
    5118                 :            :  * The actual MPDFUNC does NOT take a context arg.
    5119                 :            :  */
    5120                 :            : #define DecCtx_BinaryFunc_NO_CTX(MPDFUNC) \
    5121                 :            : static PyObject *                                \
    5122                 :            : ctx_##MPDFUNC(PyObject *context, PyObject *args) \
    5123                 :            : {                                                \
    5124                 :            :     PyObject *v, *w;                             \
    5125                 :            :     PyObject *a, *b;                             \
    5126                 :            :     PyObject *result;                            \
    5127                 :            :                                                  \
    5128                 :            :     if (!PyArg_ParseTuple(args, "OO", &v, &w)) { \
    5129                 :            :         return NULL;                             \
    5130                 :            :     }                                            \
    5131                 :            :                                                  \
    5132                 :            :     CONVERT_BINOP_RAISE(&a, &b, v, w, context);  \
    5133                 :            :                                                  \
    5134                 :            :     if ((result = dec_alloc()) == NULL) {        \
    5135                 :            :         Py_DECREF(a);                            \
    5136                 :            :         Py_DECREF(b);                            \
    5137                 :            :         return NULL;                             \
    5138                 :            :     }                                            \
    5139                 :            :                                                  \
    5140                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b));        \
    5141                 :            :     Py_DECREF(a);                                \
    5142                 :            :     Py_DECREF(b);                                \
    5143                 :            :                                                  \
    5144                 :            :     return result;                               \
    5145                 :            : }
    5146                 :            : 
    5147                 :            : /* Ternary context method. */
    5148                 :            : #define DecCtx_TernaryFunc(MPDFUNC) \
    5149                 :            : static PyObject *                                                        \
    5150                 :            : ctx_##MPDFUNC(PyObject *context, PyObject *args)                         \
    5151                 :            : {                                                                        \
    5152                 :            :     PyObject *v, *w, *x;                                                 \
    5153                 :            :     PyObject *a, *b, *c;                                                 \
    5154                 :            :     PyObject *result;                                                    \
    5155                 :            :     uint32_t status = 0;                                                 \
    5156                 :            :                                                                          \
    5157                 :            :     if (!PyArg_ParseTuple(args, "OOO", &v, &w, &x)) {                    \
    5158                 :            :         return NULL;                                                     \
    5159                 :            :     }                                                                    \
    5160                 :            :                                                                          \
    5161                 :            :     CONVERT_TERNOP_RAISE(&a, &b, &c, v, w, x, context);                  \
    5162                 :            :                                                                          \
    5163                 :            :     if ((result = dec_alloc()) == NULL) {                                \
    5164                 :            :         Py_DECREF(a);                                                    \
    5165                 :            :         Py_DECREF(b);                                                    \
    5166                 :            :         Py_DECREF(c);                                                    \
    5167                 :            :         return NULL;                                                     \
    5168                 :            :     }                                                                    \
    5169                 :            :                                                                          \
    5170                 :            :     MPDFUNC(MPD(result), MPD(a), MPD(b), MPD(c), CTX(context), &status); \
    5171                 :            :     Py_DECREF(a);                                                        \
    5172                 :            :     Py_DECREF(b);                                                        \
    5173                 :            :     Py_DECREF(c);                                                        \
    5174                 :            :     if (dec_addstatus(context, status)) {                                \
    5175                 :            :         Py_DECREF(result);                                               \
    5176                 :            :         return NULL;                                                     \
    5177                 :            :     }                                                                    \
    5178                 :            :                                                                          \
    5179                 :            :     return result;                                                       \
    5180                 :            : }
    5181                 :            : 
    5182                 :            : 
    5183                 :            : /* Unary arithmetic functions */
    5184   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qabs)
                   #  # ]
    5185   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qexp)
                   #  # ]
    5186   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qln)
                   #  # ]
    5187   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qlog10)
                   #  # ]
    5188   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qminus)
                   #  # ]
    5189   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qnext_minus)
                   #  # ]
    5190   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qnext_plus)
                   #  # ]
    5191   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qplus)
                   #  # ]
    5192   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qreduce)
                   #  # ]
    5193   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qround_to_int)
                   #  # ]
    5194   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qround_to_intx)
                   #  # ]
    5195   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qsqrt)
                   #  # ]
    5196                 :            : 
    5197                 :            : /* Binary arithmetic functions */
    5198   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qadd)
          #  #  #  #  #  
                      # ]
    5199   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qcompare)
          #  #  #  #  #  
                      # ]
    5200   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qcompare_signal)
          #  #  #  #  #  
                      # ]
    5201   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qdiv)
          #  #  #  #  #  
                      # ]
    5202   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qdivint)
          #  #  #  #  #  
                      # ]
    5203   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qmax)
          #  #  #  #  #  
                      # ]
    5204   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qmax_mag)
          #  #  #  #  #  
                      # ]
    5205   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qmin)
          #  #  #  #  #  
                      # ]
    5206   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qmin_mag)
          #  #  #  #  #  
                      # ]
    5207   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qmul)
          #  #  #  #  #  
                      # ]
    5208   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qnext_toward)
          #  #  #  #  #  
                      # ]
    5209   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qquantize)
          #  #  #  #  #  
                      # ]
    5210   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qrem)
          #  #  #  #  #  
                      # ]
    5211   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qrem_near)
          #  #  #  #  #  
                      # ]
    5212   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qsub)
          #  #  #  #  #  
                      # ]
    5213                 :            : 
    5214                 :            : static PyObject *
    5215                 :          0 : ctx_mpd_qdivmod(PyObject *context, PyObject *args)
    5216                 :            : {
    5217                 :            :     PyObject *v, *w;
    5218                 :            :     PyObject *a, *b;
    5219                 :            :     PyObject *q, *r;
    5220                 :          0 :     uint32_t status = 0;
    5221                 :            :     PyObject *ret;
    5222                 :            : 
    5223         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &v, &w)) {
    5224                 :          0 :         return NULL;
    5225                 :            :     }
    5226                 :            : 
    5227   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, v, w, context);
    5228                 :            : 
    5229                 :          0 :     q = dec_alloc();
    5230         [ #  # ]:          0 :     if (q == NULL) {
    5231                 :          0 :         Py_DECREF(a);
    5232                 :          0 :         Py_DECREF(b);
    5233                 :          0 :         return NULL;
    5234                 :            :     }
    5235                 :          0 :     r = dec_alloc();
    5236         [ #  # ]:          0 :     if (r == NULL) {
    5237                 :          0 :         Py_DECREF(a);
    5238                 :          0 :         Py_DECREF(b);
    5239                 :          0 :         Py_DECREF(q);
    5240                 :          0 :         return NULL;
    5241                 :            :     }
    5242                 :            : 
    5243                 :          0 :     mpd_qdivmod(MPD(q), MPD(r), MPD(a), MPD(b), CTX(context), &status);
    5244                 :          0 :     Py_DECREF(a);
    5245                 :          0 :     Py_DECREF(b);
    5246         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    5247                 :          0 :         Py_DECREF(r);
    5248                 :          0 :         Py_DECREF(q);
    5249                 :          0 :         return NULL;
    5250                 :            :     }
    5251                 :            : 
    5252                 :          0 :     ret = Py_BuildValue("(OO)", q, r);
    5253                 :          0 :     Py_DECREF(r);
    5254                 :          0 :     Py_DECREF(q);
    5255                 :          0 :     return ret;
    5256                 :            : }
    5257                 :            : 
    5258                 :            : /* Binary or ternary arithmetic functions */
    5259                 :            : static PyObject *
    5260                 :          0 : ctx_mpd_qpow(PyObject *context, PyObject *args, PyObject *kwds)
    5261                 :            : {
    5262                 :            :     static char *kwlist[] = {"a", "b", "modulo", NULL};
    5263                 :          0 :     PyObject *base, *exp, *mod = Py_None;
    5264                 :          0 :     PyObject *a, *b, *c = NULL;
    5265                 :            :     PyObject *result;
    5266                 :          0 :     uint32_t status = 0;
    5267                 :            : 
    5268         [ #  # ]:          0 :     if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|O", kwlist,
    5269                 :            :                                      &base, &exp, &mod)) {
    5270                 :          0 :         return NULL;
    5271                 :            :     }
    5272                 :            : 
    5273   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, base, exp, context);
    5274                 :            : 
    5275         [ #  # ]:          0 :     if (mod != Py_None) {
    5276         [ #  # ]:          0 :         if (!convert_op(TYPE_ERR, &c, mod, context)) {
    5277                 :          0 :             Py_DECREF(a);
    5278                 :          0 :             Py_DECREF(b);
    5279                 :          0 :             return c;
    5280                 :            :         }
    5281                 :            :     }
    5282                 :            : 
    5283                 :          0 :     result = dec_alloc();
    5284         [ #  # ]:          0 :     if (result == NULL) {
    5285                 :          0 :         Py_DECREF(a);
    5286                 :          0 :         Py_DECREF(b);
    5287                 :          0 :         Py_XDECREF(c);
    5288                 :          0 :         return NULL;
    5289                 :            :     }
    5290                 :            : 
    5291         [ #  # ]:          0 :     if (c == NULL) {
    5292                 :          0 :         mpd_qpow(MPD(result), MPD(a), MPD(b),
    5293                 :          0 :                  CTX(context), &status);
    5294                 :            :     }
    5295                 :            :     else {
    5296                 :          0 :         mpd_qpowmod(MPD(result), MPD(a), MPD(b), MPD(c),
    5297                 :          0 :                     CTX(context), &status);
    5298                 :          0 :         Py_DECREF(c);
    5299                 :            :     }
    5300                 :          0 :     Py_DECREF(a);
    5301                 :          0 :     Py_DECREF(b);
    5302         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    5303                 :          0 :         Py_DECREF(result);
    5304                 :          0 :         return NULL;
    5305                 :            :     }
    5306                 :            : 
    5307                 :          0 :     return result;
    5308                 :            : }
    5309                 :            : 
    5310                 :            : /* Ternary arithmetic functions */
    5311   [ #  #  #  #  :          0 : DecCtx_TernaryFunc(mpd_qfma)
          #  #  #  #  #  
                #  #  # ]
    5312                 :            : 
    5313                 :            : /* No argument */
    5314                 :            : static PyObject *
    5315                 :          0 : ctx_mpd_radix(PyObject *context, PyObject *dummy)
    5316                 :            : {
    5317                 :          0 :     return dec_mpd_radix(context, dummy);
    5318                 :            : }
    5319                 :            : 
    5320                 :            : /* Boolean functions: single decimal argument */
    5321   [ #  #  #  # ]:          0 : DecCtx_BoolFunc(mpd_isnormal)
    5322   [ #  #  #  # ]:          0 : DecCtx_BoolFunc(mpd_issubnormal)
    5323   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_isfinite)
    5324   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_isinfinite)
    5325   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_isnan)
    5326   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_isqnan)
    5327   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_issigned)
    5328   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_issnan)
    5329   [ #  #  #  # ]:          0 : DecCtx_BoolFunc_NO_CTX(mpd_iszero)
    5330                 :            : 
    5331                 :            : static PyObject *
    5332                 :          0 : ctx_iscanonical(PyObject *context UNUSED, PyObject *v)
    5333                 :            : {
    5334         [ #  # ]:          0 :     if (!PyDec_Check(v)) {
    5335                 :          0 :         PyErr_SetString(PyExc_TypeError,
    5336                 :            :             "argument must be a Decimal");
    5337                 :          0 :         return NULL;
    5338                 :            :     }
    5339                 :            : 
    5340         [ #  # ]:          0 :     return mpd_iscanonical(MPD(v)) ? incr_true() : incr_false();
    5341                 :            : }
    5342                 :            : 
    5343                 :            : /* Functions with a single decimal argument */
    5344                 :            : static PyObject *
    5345                 :          0 : PyDecContext_Apply(PyObject *context, PyObject *v)
    5346                 :            : {
    5347                 :            :     PyObject *result, *a;
    5348                 :            : 
    5349         [ #  # ]:          0 :     CONVERT_OP_RAISE(&a, v, context);
    5350                 :            : 
    5351                 :          0 :     result = dec_apply(a, context);
    5352                 :          0 :     Py_DECREF(a);
    5353                 :          0 :     return result;
    5354                 :            : }
    5355                 :            : 
    5356                 :            : static PyObject *
    5357                 :          0 : ctx_canonical(PyObject *context UNUSED, PyObject *v)
    5358                 :            : {
    5359         [ #  # ]:          0 :     if (!PyDec_Check(v)) {
    5360                 :          0 :         PyErr_SetString(PyExc_TypeError,
    5361                 :            :             "argument must be a Decimal");
    5362                 :          0 :         return NULL;
    5363                 :            :     }
    5364                 :            : 
    5365                 :          0 :     return Py_NewRef(v);
    5366                 :            : }
    5367                 :            : 
    5368                 :            : static PyObject *
    5369                 :          0 : ctx_mpd_qcopy_abs(PyObject *context, PyObject *v)
    5370                 :            : {
    5371                 :            :     PyObject *result, *a;
    5372                 :          0 :     uint32_t status = 0;
    5373                 :            : 
    5374         [ #  # ]:          0 :     CONVERT_OP_RAISE(&a, v, context);
    5375                 :            : 
    5376                 :          0 :     result = dec_alloc();
    5377         [ #  # ]:          0 :     if (result == NULL) {
    5378                 :          0 :         Py_DECREF(a);
    5379                 :          0 :         return NULL;
    5380                 :            :     }
    5381                 :            : 
    5382                 :          0 :     mpd_qcopy_abs(MPD(result), MPD(a), &status);
    5383                 :          0 :     Py_DECREF(a);
    5384         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    5385                 :          0 :         Py_DECREF(result);
    5386                 :          0 :         return NULL;
    5387                 :            :     }
    5388                 :            : 
    5389                 :          0 :     return result;
    5390                 :            : }
    5391                 :            : 
    5392                 :            : static PyObject *
    5393                 :          0 : ctx_copy_decimal(PyObject *context, PyObject *v)
    5394                 :            : {
    5395                 :            :     PyObject *result;
    5396                 :            : 
    5397         [ #  # ]:          0 :     CONVERT_OP_RAISE(&result, v, context);
    5398                 :          0 :     return result;
    5399                 :            : }
    5400                 :            : 
    5401                 :            : static PyObject *
    5402                 :          0 : ctx_mpd_qcopy_negate(PyObject *context, PyObject *v)
    5403                 :            : {
    5404                 :            :     PyObject *result, *a;
    5405                 :          0 :     uint32_t status = 0;
    5406                 :            : 
    5407         [ #  # ]:          0 :     CONVERT_OP_RAISE(&a, v, context);
    5408                 :            : 
    5409                 :          0 :     result = dec_alloc();
    5410         [ #  # ]:          0 :     if (result == NULL) {
    5411                 :          0 :         Py_DECREF(a);
    5412                 :          0 :         return NULL;
    5413                 :            :     }
    5414                 :            : 
    5415                 :          0 :     mpd_qcopy_negate(MPD(result), MPD(a), &status);
    5416                 :          0 :     Py_DECREF(a);
    5417         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    5418                 :          0 :         Py_DECREF(result);
    5419                 :          0 :         return NULL;
    5420                 :            :     }
    5421                 :            : 
    5422                 :          0 :     return result;
    5423                 :            : }
    5424                 :            : 
    5425   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qlogb)
                   #  # ]
    5426   [ #  #  #  #  :          0 : DecCtx_UnaryFunc(mpd_qinvert)
                   #  # ]
    5427                 :            : 
    5428                 :            : static PyObject *
    5429                 :          0 : ctx_mpd_class(PyObject *context, PyObject *v)
    5430                 :            : {
    5431                 :            :     PyObject *a;
    5432                 :            :     const char *cp;
    5433                 :            : 
    5434         [ #  # ]:          0 :     CONVERT_OP_RAISE(&a, v, context);
    5435                 :            : 
    5436                 :          0 :     cp = mpd_class(MPD(a), CTX(context));
    5437                 :          0 :     Py_DECREF(a);
    5438                 :            : 
    5439                 :          0 :     return PyUnicode_FromString(cp);
    5440                 :            : }
    5441                 :            : 
    5442                 :            : static PyObject *
    5443                 :          0 : ctx_mpd_to_sci(PyObject *context, PyObject *v)
    5444                 :            : {
    5445                 :            :     PyObject *result;
    5446                 :            :     PyObject *a;
    5447                 :            :     mpd_ssize_t size;
    5448                 :            :     char *s;
    5449                 :            : 
    5450         [ #  # ]:          0 :     CONVERT_OP_RAISE(&a, v, context);
    5451                 :            : 
    5452                 :          0 :     size = mpd_to_sci_size(&s, MPD(a), CtxCaps(context));
    5453                 :          0 :     Py_DECREF(a);
    5454         [ #  # ]:          0 :     if (size < 0) {
    5455                 :          0 :         PyErr_NoMemory();
    5456                 :          0 :         return NULL;
    5457                 :            :     }
    5458                 :            : 
    5459                 :          0 :     result = unicode_fromascii(s, size);
    5460                 :          0 :     mpd_free(s);
    5461                 :            : 
    5462                 :          0 :     return result;
    5463                 :            : }
    5464                 :            : 
    5465                 :            : static PyObject *
    5466                 :          0 : ctx_mpd_to_eng(PyObject *context, PyObject *v)
    5467                 :            : {
    5468                 :            :     PyObject *result;
    5469                 :            :     PyObject *a;
    5470                 :            :     mpd_ssize_t size;
    5471                 :            :     char *s;
    5472                 :            : 
    5473         [ #  # ]:          0 :     CONVERT_OP_RAISE(&a, v, context);
    5474                 :            : 
    5475                 :          0 :     size = mpd_to_eng_size(&s, MPD(a), CtxCaps(context));
    5476                 :          0 :     Py_DECREF(a);
    5477         [ #  # ]:          0 :     if (size < 0) {
    5478                 :          0 :         PyErr_NoMemory();
    5479                 :          0 :         return NULL;
    5480                 :            :     }
    5481                 :            : 
    5482                 :          0 :     result = unicode_fromascii(s, size);
    5483                 :          0 :     mpd_free(s);
    5484                 :            : 
    5485                 :          0 :     return result;
    5486                 :            : }
    5487                 :            : 
    5488                 :            : /* Functions with two decimal arguments */
    5489   [ #  #  #  #  :          0 : DecCtx_BinaryFunc_NO_CTX(mpd_compare_total)
             #  #  #  # ]
    5490   [ #  #  #  #  :          0 : DecCtx_BinaryFunc_NO_CTX(mpd_compare_total_mag)
             #  #  #  # ]
    5491                 :            : 
    5492                 :            : static PyObject *
    5493                 :          0 : ctx_mpd_qcopy_sign(PyObject *context, PyObject *args)
    5494                 :            : {
    5495                 :            :     PyObject *v, *w;
    5496                 :            :     PyObject *a, *b;
    5497                 :            :     PyObject *result;
    5498                 :          0 :     uint32_t status = 0;
    5499                 :            : 
    5500         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &v, &w)) {
    5501                 :          0 :         return NULL;
    5502                 :            :     }
    5503                 :            : 
    5504   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, v, w, context);
    5505                 :            : 
    5506                 :          0 :     result = dec_alloc();
    5507         [ #  # ]:          0 :     if (result == NULL) {
    5508                 :          0 :         Py_DECREF(a);
    5509                 :          0 :         Py_DECREF(b);
    5510                 :          0 :         return NULL;
    5511                 :            :     }
    5512                 :            : 
    5513                 :          0 :     mpd_qcopy_sign(MPD(result), MPD(a), MPD(b), &status);
    5514                 :          0 :     Py_DECREF(a);
    5515                 :          0 :     Py_DECREF(b);
    5516         [ #  # ]:          0 :     if (dec_addstatus(context, status)) {
    5517                 :          0 :         Py_DECREF(result);
    5518                 :          0 :         return NULL;
    5519                 :            :     }
    5520                 :            : 
    5521                 :          0 :     return result;
    5522                 :            : }
    5523                 :            : 
    5524   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qand)
          #  #  #  #  #  
                      # ]
    5525   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qor)
          #  #  #  #  #  
                      # ]
    5526   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qxor)
          #  #  #  #  #  
                      # ]
    5527                 :            : 
    5528   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qrotate)
          #  #  #  #  #  
                      # ]
    5529   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qscaleb)
          #  #  #  #  #  
                      # ]
    5530   [ #  #  #  #  :          0 : DecCtx_BinaryFunc(mpd_qshift)
          #  #  #  #  #  
                      # ]
    5531                 :            : 
    5532                 :            : static PyObject *
    5533                 :          0 : ctx_mpd_same_quantum(PyObject *context, PyObject *args)
    5534                 :            : {
    5535                 :            :     PyObject *v, *w;
    5536                 :            :     PyObject *a, *b;
    5537                 :            :     PyObject *result;
    5538                 :            : 
    5539         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &v, &w)) {
    5540                 :          0 :         return NULL;
    5541                 :            :     }
    5542                 :            : 
    5543   [ #  #  #  # ]:          0 :     CONVERT_BINOP_RAISE(&a, &b, v, w, context);
    5544                 :            : 
    5545         [ #  # ]:          0 :     result = mpd_same_quantum(MPD(a), MPD(b)) ? incr_true() : incr_false();
    5546                 :          0 :     Py_DECREF(a);
    5547                 :          0 :     Py_DECREF(b);
    5548                 :            : 
    5549                 :          0 :     return result;
    5550                 :            : }
    5551                 :            : 
    5552                 :            : 
    5553                 :            : static PyMethodDef context_methods [] =
    5554                 :            : {
    5555                 :            :   /* Unary arithmetic functions */
    5556                 :            :   { "abs", ctx_mpd_qabs, METH_O, doc_ctx_abs },
    5557                 :            :   { "exp", ctx_mpd_qexp, METH_O, doc_ctx_exp },
    5558                 :            :   { "ln", ctx_mpd_qln, METH_O, doc_ctx_ln },
    5559                 :            :   { "log10", ctx_mpd_qlog10, METH_O, doc_ctx_log10 },
    5560                 :            :   { "minus", ctx_mpd_qminus, METH_O, doc_ctx_minus },
    5561                 :            :   { "next_minus", ctx_mpd_qnext_minus, METH_O, doc_ctx_next_minus },
    5562                 :            :   { "next_plus", ctx_mpd_qnext_plus, METH_O, doc_ctx_next_plus },
    5563                 :            :   { "normalize", ctx_mpd_qreduce, METH_O, doc_ctx_normalize },
    5564                 :            :   { "plus", ctx_mpd_qplus, METH_O, doc_ctx_plus },
    5565                 :            :   { "to_integral", ctx_mpd_qround_to_int, METH_O, doc_ctx_to_integral },
    5566                 :            :   { "to_integral_exact", ctx_mpd_qround_to_intx, METH_O, doc_ctx_to_integral_exact },
    5567                 :            :   { "to_integral_value", ctx_mpd_qround_to_int, METH_O, doc_ctx_to_integral_value },
    5568                 :            :   { "sqrt", ctx_mpd_qsqrt, METH_O, doc_ctx_sqrt },
    5569                 :            : 
    5570                 :            :   /* Binary arithmetic functions */
    5571                 :            :   { "add", ctx_mpd_qadd, METH_VARARGS, doc_ctx_add },
    5572                 :            :   { "compare", ctx_mpd_qcompare, METH_VARARGS, doc_ctx_compare },
    5573                 :            :   { "compare_signal", ctx_mpd_qcompare_signal, METH_VARARGS, doc_ctx_compare_signal },
    5574                 :            :   { "divide", ctx_mpd_qdiv, METH_VARARGS, doc_ctx_divide },
    5575                 :            :   { "divide_int", ctx_mpd_qdivint, METH_VARARGS, doc_ctx_divide_int },
    5576                 :            :   { "divmod", ctx_mpd_qdivmod, METH_VARARGS, doc_ctx_divmod },
    5577                 :            :   { "max", ctx_mpd_qmax, METH_VARARGS, doc_ctx_max },
    5578                 :            :   { "max_mag", ctx_mpd_qmax_mag, METH_VARARGS, doc_ctx_max_mag },
    5579                 :            :   { "min", ctx_mpd_qmin, METH_VARARGS, doc_ctx_min },
    5580                 :            :   { "min_mag", ctx_mpd_qmin_mag, METH_VARARGS, doc_ctx_min_mag },
    5581                 :            :   { "multiply", ctx_mpd_qmul, METH_VARARGS, doc_ctx_multiply },
    5582                 :            :   { "next_toward", ctx_mpd_qnext_toward, METH_VARARGS, doc_ctx_next_toward },
    5583                 :            :   { "quantize", ctx_mpd_qquantize, METH_VARARGS, doc_ctx_quantize },
    5584                 :            :   { "remainder", ctx_mpd_qrem, METH_VARARGS, doc_ctx_remainder },
    5585                 :            :   { "remainder_near", ctx_mpd_qrem_near, METH_VARARGS, doc_ctx_remainder_near },
    5586                 :            :   { "subtract", ctx_mpd_qsub, METH_VARARGS, doc_ctx_subtract },
    5587                 :            : 
    5588                 :            :   /* Binary or ternary arithmetic functions */
    5589                 :            :   { "power", _PyCFunction_CAST(ctx_mpd_qpow), METH_VARARGS|METH_KEYWORDS, doc_ctx_power },
    5590                 :            : 
    5591                 :            :   /* Ternary arithmetic functions */
    5592                 :            :   { "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma },
    5593                 :            : 
    5594                 :            :   /* No argument */
    5595                 :            :   { "Etiny", context_getetiny, METH_NOARGS, doc_ctx_Etiny },
    5596                 :            :   { "Etop", context_getetop, METH_NOARGS, doc_ctx_Etop },
    5597                 :            :   { "radix", ctx_mpd_radix, METH_NOARGS, doc_ctx_radix },
    5598                 :            : 
    5599                 :            :   /* Boolean functions */
    5600                 :            :   { "is_canonical", ctx_iscanonical, METH_O, doc_ctx_is_canonical },
    5601                 :            :   { "is_finite", ctx_mpd_isfinite, METH_O, doc_ctx_is_finite },
    5602                 :            :   { "is_infinite", ctx_mpd_isinfinite, METH_O, doc_ctx_is_infinite },
    5603                 :            :   { "is_nan", ctx_mpd_isnan, METH_O, doc_ctx_is_nan },
    5604                 :            :   { "is_normal", ctx_mpd_isnormal, METH_O, doc_ctx_is_normal },
    5605                 :            :   { "is_qnan", ctx_mpd_isqnan, METH_O, doc_ctx_is_qnan },
    5606                 :            :   { "is_signed", ctx_mpd_issigned, METH_O, doc_ctx_is_signed },
    5607                 :            :   { "is_snan", ctx_mpd_issnan, METH_O, doc_ctx_is_snan },
    5608                 :            :   { "is_subnormal", ctx_mpd_issubnormal, METH_O, doc_ctx_is_subnormal },
    5609                 :            :   { "is_zero", ctx_mpd_iszero, METH_O, doc_ctx_is_zero },
    5610                 :            : 
    5611                 :            :   /* Functions with a single decimal argument */
    5612                 :            :   { "_apply", PyDecContext_Apply, METH_O, NULL }, /* alias for apply */
    5613                 :            : #ifdef EXTRA_FUNCTIONALITY
    5614                 :            :   { "apply", PyDecContext_Apply, METH_O, doc_ctx_apply },
    5615                 :            : #endif
    5616                 :            :   { "canonical", ctx_canonical, METH_O, doc_ctx_canonical },
    5617                 :            :   { "copy_abs", ctx_mpd_qcopy_abs, METH_O, doc_ctx_copy_abs },
    5618                 :            :   { "copy_decimal", ctx_copy_decimal, METH_O, doc_ctx_copy_decimal },
    5619                 :            :   { "copy_negate", ctx_mpd_qcopy_negate, METH_O, doc_ctx_copy_negate },
    5620                 :            :   { "logb", ctx_mpd_qlogb, METH_O, doc_ctx_logb },
    5621                 :            :   { "logical_invert", ctx_mpd_qinvert, METH_O, doc_ctx_logical_invert },
    5622                 :            :   { "number_class", ctx_mpd_class, METH_O, doc_ctx_number_class },
    5623                 :            :   { "to_sci_string", ctx_mpd_to_sci, METH_O, doc_ctx_to_sci_string },
    5624                 :            :   { "to_eng_string", ctx_mpd_to_eng, METH_O, doc_ctx_to_eng_string },
    5625                 :            : 
    5626                 :            :   /* Functions with two decimal arguments */
    5627                 :            :   { "compare_total", ctx_mpd_compare_total, METH_VARARGS, doc_ctx_compare_total },
    5628                 :            :   { "compare_total_mag", ctx_mpd_compare_total_mag, METH_VARARGS, doc_ctx_compare_total_mag },
    5629                 :            :   { "copy_sign", ctx_mpd_qcopy_sign, METH_VARARGS, doc_ctx_copy_sign },
    5630                 :            :   { "logical_and", ctx_mpd_qand, METH_VARARGS, doc_ctx_logical_and },
    5631                 :            :   { "logical_or", ctx_mpd_qor, METH_VARARGS, doc_ctx_logical_or },
    5632                 :            :   { "logical_xor", ctx_mpd_qxor, METH_VARARGS, doc_ctx_logical_xor },
    5633                 :            :   { "rotate", ctx_mpd_qrotate, METH_VARARGS, doc_ctx_rotate },
    5634                 :            :   { "same_quantum", ctx_mpd_same_quantum, METH_VARARGS, doc_ctx_same_quantum },
    5635                 :            :   { "scaleb", ctx_mpd_qscaleb, METH_VARARGS, doc_ctx_scaleb },
    5636                 :            :   { "shift", ctx_mpd_qshift, METH_VARARGS, doc_ctx_shift },
    5637                 :            : 
    5638                 :            :   /* Set context values */
    5639                 :            :   { "clear_flags", context_clear_flags, METH_NOARGS, doc_ctx_clear_flags },
    5640                 :            :   { "clear_traps", context_clear_traps, METH_NOARGS, doc_ctx_clear_traps },
    5641                 :            : 
    5642                 :            : #ifdef CONFIG_32
    5643                 :            :   /* Unsafe set functions with relaxed range checks */
    5644                 :            :   { "_unsafe_setprec", context_unsafe_setprec, METH_O, NULL },
    5645                 :            :   { "_unsafe_setemin", context_unsafe_setemin, METH_O, NULL },
    5646                 :            :   { "_unsafe_setemax", context_unsafe_setemax, METH_O, NULL },
    5647                 :            : #endif
    5648                 :            : 
    5649                 :            :   /* Miscellaneous */
    5650                 :            :   { "__copy__", (PyCFunction)context_copy, METH_NOARGS, NULL },
    5651                 :            :   { "__reduce__", context_reduce, METH_NOARGS, NULL },
    5652                 :            :   { "copy", (PyCFunction)context_copy, METH_NOARGS, doc_ctx_copy },
    5653                 :            :   { "create_decimal", ctx_create_decimal, METH_VARARGS, doc_ctx_create_decimal },
    5654                 :            :   { "create_decimal_from_float", ctx_from_float, METH_O, doc_ctx_create_decimal_from_float },
    5655                 :            : 
    5656                 :            :   { NULL, NULL, 1 }
    5657                 :            : };
    5658                 :            : 
    5659                 :            : static PyTypeObject PyDecContext_Type =
    5660                 :            : {
    5661                 :            :     PyVarObject_HEAD_INIT(NULL, 0)
    5662                 :            :     "decimal.Context",                         /* tp_name */
    5663                 :            :     sizeof(PyDecContextObject),                /* tp_basicsize */
    5664                 :            :     0,                                         /* tp_itemsize */
    5665                 :            :     (destructor) context_dealloc,              /* tp_dealloc */
    5666                 :            :     0,                                         /* tp_vectorcall_offset */
    5667                 :            :     (getattrfunc) 0,                           /* tp_getattr */
    5668                 :            :     (setattrfunc) 0,                           /* tp_setattr */
    5669                 :            :     0,                                         /* tp_as_async */
    5670                 :            :     (reprfunc) context_repr,                   /* tp_repr */
    5671                 :            :     0,                                         /* tp_as_number */
    5672                 :            :     0,                                         /* tp_as_sequence */
    5673                 :            :     0,                                         /* tp_as_mapping */
    5674                 :            :     (hashfunc) 0,                              /* tp_hash */
    5675                 :            :     0,                                         /* tp_call */
    5676                 :            :     0,                                         /* tp_str */
    5677                 :            :     (getattrofunc) context_getattr,            /* tp_getattro */
    5678                 :            :     (setattrofunc) context_setattr,            /* tp_setattro */
    5679                 :            :     (PyBufferProcs *) 0,                       /* tp_as_buffer */
    5680                 :            :     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,    /* tp_flags */
    5681                 :            :     doc_context,                               /* tp_doc */
    5682                 :            :     0,                                         /* tp_traverse */
    5683                 :            :     0,                                         /* tp_clear */
    5684                 :            :     0,                                         /* tp_richcompare */
    5685                 :            :     0,                                         /* tp_weaklistoffset */
    5686                 :            :     0,                                         /* tp_iter */
    5687                 :            :     0,                                         /* tp_iternext */
    5688                 :            :     context_methods,                           /* tp_methods */
    5689                 :            :     0,                                         /* tp_members */
    5690                 :            :     context_getsets,                           /* tp_getset */
    5691                 :            :     0,                                         /* tp_base */
    5692                 :            :     0,                                         /* tp_dict */
    5693                 :            :     0,                                         /* tp_descr_get */
    5694                 :            :     0,                                         /* tp_descr_set */
    5695                 :            :     0,                                         /* tp_dictoffset */
    5696                 :            :     context_init,                              /* tp_init */
    5697                 :            :     0,                                         /* tp_alloc */
    5698                 :            :     context_new,                               /* tp_new */
    5699                 :            :     PyObject_Del,                              /* tp_free */
    5700                 :            : };
    5701                 :            : 
    5702                 :            : 
    5703                 :            : static PyMethodDef _decimal_methods [] =
    5704                 :            : {
    5705                 :            :   { "getcontext", (PyCFunction)PyDec_GetCurrentContext, METH_NOARGS, doc_getcontext},
    5706                 :            :   { "setcontext", (PyCFunction)PyDec_SetCurrentContext, METH_O, doc_setcontext},
    5707                 :            :   { "localcontext", _PyCFunction_CAST(ctxmanager_new), METH_VARARGS|METH_KEYWORDS, doc_localcontext},
    5708                 :            : #ifdef EXTRA_FUNCTIONALITY
    5709                 :            :   { "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context},
    5710                 :            : #endif
    5711                 :            :   { NULL, NULL, 1, NULL }
    5712                 :            : };
    5713                 :            : 
    5714                 :            : static struct PyModuleDef _decimal_module = {
    5715                 :            :     PyModuleDef_HEAD_INIT,
    5716                 :            :     "decimal",
    5717                 :            :     doc__decimal,
    5718                 :            :     -1,
    5719                 :            :     _decimal_methods,
    5720                 :            :     NULL,
    5721                 :            :     NULL,
    5722                 :            :     NULL,
    5723                 :            :     NULL
    5724                 :            : };
    5725                 :            : 
    5726                 :            : struct ssize_constmap { const char *name; mpd_ssize_t val; };
    5727                 :            : static struct ssize_constmap ssize_constants [] = {
    5728                 :            :     {"MAX_PREC", MPD_MAX_PREC},
    5729                 :            :     {"MAX_EMAX", MPD_MAX_EMAX},
    5730                 :            :     {"MIN_EMIN",  MPD_MIN_EMIN},
    5731                 :            :     {"MIN_ETINY", MPD_MIN_ETINY},
    5732                 :            :     {NULL}
    5733                 :            : };
    5734                 :            : 
    5735                 :            : struct int_constmap { const char *name; int val; };
    5736                 :            : static struct int_constmap int_constants [] = {
    5737                 :            :     /* int constants */
    5738                 :            : #ifdef EXTRA_FUNCTIONALITY
    5739                 :            :     {"DECIMAL32", MPD_DECIMAL32},
    5740                 :            :     {"DECIMAL64", MPD_DECIMAL64},
    5741                 :            :     {"DECIMAL128", MPD_DECIMAL128},
    5742                 :            :     {"IEEE_CONTEXT_MAX_BITS", MPD_IEEE_CONTEXT_MAX_BITS},
    5743                 :            :     /* int condition flags */
    5744                 :            :     {"DecClamped", MPD_Clamped},
    5745                 :            :     {"DecConversionSyntax", MPD_Conversion_syntax},
    5746                 :            :     {"DecDivisionByZero", MPD_Division_by_zero},
    5747                 :            :     {"DecDivisionImpossible", MPD_Division_impossible},
    5748                 :            :     {"DecDivisionUndefined", MPD_Division_undefined},
    5749                 :            :     {"DecFpuError", MPD_Fpu_error},
    5750                 :            :     {"DecInexact", MPD_Inexact},
    5751                 :            :     {"DecInvalidContext", MPD_Invalid_context},
    5752                 :            :     {"DecInvalidOperation", MPD_Invalid_operation},
    5753                 :            :     {"DecIEEEInvalidOperation", MPD_IEEE_Invalid_operation},
    5754                 :            :     {"DecMallocError", MPD_Malloc_error},
    5755                 :            :     {"DecFloatOperation", MPD_Float_operation},
    5756                 :            :     {"DecOverflow", MPD_Overflow},
    5757                 :            :     {"DecRounded", MPD_Rounded},
    5758                 :            :     {"DecSubnormal", MPD_Subnormal},
    5759                 :            :     {"DecUnderflow", MPD_Underflow},
    5760                 :            :     {"DecErrors", MPD_Errors},
    5761                 :            :     {"DecTraps", MPD_Traps},
    5762                 :            : #endif
    5763                 :            :     {NULL}
    5764                 :            : };
    5765                 :            : 
    5766                 :            : 
    5767                 :            : #define CHECK_INT(expr) \
    5768                 :            :     do { if ((expr) < 0) goto error; } while (0)
    5769                 :            : #define ASSIGN_PTR(result, expr) \
    5770                 :            :     do { result = (expr); if (result == NULL) goto error; } while (0)
    5771                 :            : #define CHECK_PTR(expr) \
    5772                 :            :     do { if ((expr) == NULL) goto error; } while (0)
    5773                 :            : 
    5774                 :            : 
    5775                 :            : static PyCFunction
    5776                 :          4 : cfunc_noargs(PyTypeObject *t, const char *name)
    5777                 :            : {
    5778                 :            :     struct PyMethodDef *m;
    5779                 :            : 
    5780         [ -  + ]:          4 :     if (t->tp_methods == NULL) {
    5781                 :          0 :         goto error;
    5782                 :            :     }
    5783                 :            : 
    5784         [ +  - ]:         16 :     for (m = t->tp_methods; m->ml_name != NULL; m++) {
    5785         [ +  + ]:         16 :         if (strcmp(name, m->ml_name) == 0) {
    5786         [ -  + ]:          4 :             if (!(m->ml_flags & METH_NOARGS)) {
    5787                 :          0 :                 goto error;
    5788                 :            :             }
    5789                 :          4 :             return m->ml_meth;
    5790                 :            :         }
    5791                 :            :     }
    5792                 :            : 
    5793                 :          0 : error:
    5794                 :          0 :     PyErr_Format(PyExc_RuntimeError,
    5795                 :            :         "internal error: could not find method %s", name);
    5796                 :          0 :     return NULL;
    5797                 :            : }
    5798                 :            : 
    5799                 :            : 
    5800                 :            : PyMODINIT_FUNC
    5801                 :          2 : PyInit__decimal(void)
    5802                 :            : {
    5803                 :          2 :     PyObject *m = NULL;
    5804                 :          2 :     PyObject *numbers = NULL;
    5805                 :          2 :     PyObject *Number = NULL;
    5806                 :          2 :     PyObject *collections = NULL;
    5807                 :          2 :     PyObject *collections_abc = NULL;
    5808                 :          2 :     PyObject *MutableMapping = NULL;
    5809                 :          2 :     PyObject *obj = NULL;
    5810                 :            :     DecCondMap *cm;
    5811                 :            :     struct ssize_constmap *ssize_cm;
    5812                 :            :     struct int_constmap *int_cm;
    5813                 :            :     int i;
    5814                 :            : 
    5815                 :            : 
    5816                 :            :     /* Init libmpdec */
    5817                 :          2 :     mpd_traphandler = dec_traphandler;
    5818                 :          2 :     mpd_mallocfunc = PyMem_Malloc;
    5819                 :          2 :     mpd_reallocfunc = PyMem_Realloc;
    5820                 :          2 :     mpd_callocfunc = mpd_callocfunc_em;
    5821                 :          2 :     mpd_free = PyMem_Free;
    5822                 :          2 :     mpd_setminalloc(_Py_DEC_MINALLOC);
    5823                 :            : 
    5824                 :            : 
    5825                 :            :     /* Init external C-API functions */
    5826                 :          2 :     _py_long_multiply = PyLong_Type.tp_as_number->nb_multiply;
    5827                 :          2 :     _py_long_floor_divide = PyLong_Type.tp_as_number->nb_floor_divide;
    5828                 :          2 :     _py_long_power = PyLong_Type.tp_as_number->nb_power;
    5829                 :          2 :     _py_float_abs = PyFloat_Type.tp_as_number->nb_absolute;
    5830         [ -  + ]:          2 :     ASSIGN_PTR(_py_float_as_integer_ratio, cfunc_noargs(&PyFloat_Type,
    5831                 :            :                                                         "as_integer_ratio"));
    5832         [ -  + ]:          2 :     ASSIGN_PTR(_py_long_bit_length, cfunc_noargs(&PyLong_Type, "bit_length"));
    5833                 :            : 
    5834                 :            : 
    5835                 :            :     /* Init types */
    5836                 :          2 :     PyDec_Type.tp_base = &PyBaseObject_Type;
    5837                 :          2 :     PyDecContext_Type.tp_base = &PyBaseObject_Type;
    5838                 :          2 :     PyDecContextManager_Type.tp_base = &PyBaseObject_Type;
    5839                 :          2 :     PyDecSignalDictMixin_Type.tp_base = &PyBaseObject_Type;
    5840                 :            : 
    5841         [ -  + ]:          2 :     CHECK_INT(PyType_Ready(&PyDec_Type));
    5842         [ -  + ]:          2 :     CHECK_INT(PyType_Ready(&PyDecContext_Type));
    5843         [ -  + ]:          2 :     CHECK_INT(PyType_Ready(&PyDecSignalDictMixin_Type));
    5844         [ -  + ]:          2 :     CHECK_INT(PyType_Ready(&PyDecContextManager_Type));
    5845                 :            : 
    5846         [ -  + ]:          2 :     ASSIGN_PTR(obj, PyUnicode_FromString("decimal"));
    5847         [ -  + ]:          2 :     CHECK_INT(PyDict_SetItemString(PyDec_Type.tp_dict, "__module__", obj));
    5848         [ -  + ]:          2 :     CHECK_INT(PyDict_SetItemString(PyDecContext_Type.tp_dict,
    5849                 :            :                                    "__module__", obj));
    5850         [ +  - ]:          2 :     Py_CLEAR(obj);
    5851                 :            : 
    5852                 :            : 
    5853                 :            :     /* Numeric abstract base classes */
    5854         [ -  + ]:          2 :     ASSIGN_PTR(numbers, PyImport_ImportModule("numbers"));
    5855         [ -  + ]:          2 :     ASSIGN_PTR(Number, PyObject_GetAttrString(numbers, "Number"));
    5856                 :            :     /* Register Decimal with the Number abstract base class */
    5857         [ -  + ]:          2 :     ASSIGN_PTR(obj, PyObject_CallMethod(Number, "register", "(O)",
    5858                 :            :                                         (PyObject *)&PyDec_Type));
    5859         [ +  - ]:          2 :     Py_CLEAR(obj);
    5860                 :            :     /* Rational is a global variable used for fraction comparisons. */
    5861         [ -  + ]:          2 :     ASSIGN_PTR(Rational, PyObject_GetAttrString(numbers, "Rational"));
    5862                 :            :     /* Done with numbers, Number */
    5863         [ +  - ]:          2 :     Py_CLEAR(numbers);
    5864         [ +  - ]:          2 :     Py_CLEAR(Number);
    5865                 :            : 
    5866                 :            :     /* DecimalTuple */
    5867         [ -  + ]:          2 :     ASSIGN_PTR(collections, PyImport_ImportModule("collections"));
    5868         [ -  + ]:          2 :     ASSIGN_PTR(DecimalTuple, (PyTypeObject *)PyObject_CallMethod(collections,
    5869                 :            :                                  "namedtuple", "(ss)", "DecimalTuple",
    5870                 :            :                                  "sign digits exponent"));
    5871                 :            : 
    5872         [ -  + ]:          2 :     ASSIGN_PTR(obj, PyUnicode_FromString("decimal"));
    5873         [ -  + ]:          2 :     CHECK_INT(PyDict_SetItemString(DecimalTuple->tp_dict, "__module__", obj));
    5874         [ +  - ]:          2 :     Py_CLEAR(obj);
    5875                 :            : 
    5876                 :            :     /* MutableMapping */
    5877         [ -  + ]:          2 :     ASSIGN_PTR(collections_abc, PyImport_ImportModule("collections.abc"));
    5878         [ -  + ]:          2 :     ASSIGN_PTR(MutableMapping, PyObject_GetAttrString(collections_abc,
    5879                 :            :                                                       "MutableMapping"));
    5880                 :            :     /* Create SignalDict type */
    5881         [ -  + ]:          2 :     ASSIGN_PTR(PyDecSignalDict_Type,
    5882                 :            :                    (PyTypeObject *)PyObject_CallFunction(
    5883                 :            :                    (PyObject *)&PyType_Type, "s(OO){}",
    5884                 :            :                    "SignalDict", &PyDecSignalDictMixin_Type,
    5885                 :            :                    MutableMapping));
    5886                 :            : 
    5887                 :            :     /* Done with collections, MutableMapping */
    5888         [ +  - ]:          2 :     Py_CLEAR(collections);
    5889         [ +  - ]:          2 :     Py_CLEAR(collections_abc);
    5890         [ +  - ]:          2 :     Py_CLEAR(MutableMapping);
    5891                 :            : 
    5892                 :            : 
    5893                 :            :     /* Create the module */
    5894         [ -  + ]:          2 :     ASSIGN_PTR(m, PyModule_Create(&_decimal_module));
    5895                 :            : 
    5896                 :            :     /* Add types to the module */
    5897         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "Decimal", Py_NewRef(&PyDec_Type)));
    5898         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "Context",
    5899                 :            :                                  Py_NewRef(&PyDecContext_Type)));
    5900         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "DecimalTuple", Py_NewRef(DecimalTuple)));
    5901                 :            : 
    5902                 :            :     /* Create top level exception */
    5903         [ -  + ]:          2 :     ASSIGN_PTR(DecimalException, PyErr_NewException(
    5904                 :            :                                      "decimal.DecimalException",
    5905                 :            :                                      PyExc_ArithmeticError, NULL));
    5906         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "DecimalException", Py_NewRef(DecimalException)));
    5907                 :            : 
    5908                 :            :     /* Create signal tuple */
    5909         [ -  + ]:          2 :     ASSIGN_PTR(SignalTuple, PyTuple_New(SIGNAL_MAP_LEN));
    5910                 :            : 
    5911                 :            :     /* Add exceptions that correspond to IEEE signals */
    5912         [ +  + ]:         20 :     for (i = SIGNAL_MAP_LEN-1; i >= 0; i--) {
    5913                 :            :         PyObject *base;
    5914                 :            : 
    5915                 :         18 :         cm = signal_map + i;
    5916                 :            : 
    5917   [ +  +  +  +  :         18 :         switch (cm->flag) {
                      + ]
    5918                 :          2 :         case MPD_Float_operation:
    5919                 :          2 :             base = PyTuple_Pack(2, DecimalException, PyExc_TypeError);
    5920                 :          2 :             break;
    5921                 :          2 :         case MPD_Division_by_zero:
    5922                 :          2 :             base = PyTuple_Pack(2, DecimalException, PyExc_ZeroDivisionError);
    5923                 :          2 :             break;
    5924                 :          2 :         case MPD_Overflow:
    5925                 :          2 :             base = PyTuple_Pack(2, signal_map[INEXACT].ex,
    5926                 :            :                                    signal_map[ROUNDED].ex);
    5927                 :          2 :             break;
    5928                 :          2 :         case MPD_Underflow:
    5929                 :          2 :             base = PyTuple_Pack(3, signal_map[INEXACT].ex,
    5930                 :            :                                    signal_map[ROUNDED].ex,
    5931                 :            :                                    signal_map[SUBNORMAL].ex);
    5932                 :          2 :             break;
    5933                 :         10 :         default:
    5934                 :         10 :             base = PyTuple_Pack(1, DecimalException);
    5935                 :         10 :             break;
    5936                 :            :         }
    5937                 :            : 
    5938         [ -  + ]:         18 :         if (base == NULL) {
    5939                 :          0 :             goto error; /* GCOV_NOT_REACHED */
    5940                 :            :         }
    5941                 :            : 
    5942         [ -  + ]:         18 :         ASSIGN_PTR(cm->ex, PyErr_NewException(cm->fqname, base, NULL));
    5943                 :         18 :         Py_DECREF(base);
    5944                 :            : 
    5945                 :            :         /* add to module */
    5946         [ -  + ]:         18 :         CHECK_INT(PyModule_AddObject(m, cm->name, Py_NewRef(cm->ex)));
    5947                 :            : 
    5948                 :            :         /* add to signal tuple */
    5949                 :         18 :         PyTuple_SET_ITEM(SignalTuple, i, Py_NewRef(cm->ex));
    5950                 :            :     }
    5951                 :            : 
    5952                 :            :     /*
    5953                 :            :      * Unfortunately, InvalidOperation is a signal that comprises
    5954                 :            :      * several conditions, including InvalidOperation! Naming the
    5955                 :            :      * signal IEEEInvalidOperation would prevent the confusion.
    5956                 :            :      */
    5957                 :          2 :     cond_map[0].ex = signal_map[0].ex;
    5958                 :            : 
    5959                 :            :     /* Add remaining exceptions, inherit from InvalidOperation */
    5960         [ +  + ]:         10 :     for (cm = cond_map+1; cm->name != NULL; cm++) {
    5961                 :            :         PyObject *base;
    5962         [ +  + ]:          8 :         if (cm->flag == MPD_Division_undefined) {
    5963                 :          2 :             base = PyTuple_Pack(2, signal_map[0].ex, PyExc_ZeroDivisionError);
    5964                 :            :         }
    5965                 :            :         else {
    5966                 :          6 :             base = PyTuple_Pack(1, signal_map[0].ex);
    5967                 :            :         }
    5968         [ -  + ]:          8 :         if (base == NULL) {
    5969                 :          0 :             goto error; /* GCOV_NOT_REACHED */
    5970                 :            :         }
    5971                 :            : 
    5972         [ -  + ]:          8 :         ASSIGN_PTR(cm->ex, PyErr_NewException(cm->fqname, base, NULL));
    5973                 :          8 :         Py_DECREF(base);
    5974                 :            : 
    5975         [ -  + ]:          8 :         CHECK_INT(PyModule_AddObject(m, cm->name, Py_NewRef(cm->ex)));
    5976                 :            :     }
    5977                 :            : 
    5978                 :            : 
    5979                 :            :     /* Init default context template first */
    5980         [ -  + ]:          2 :     ASSIGN_PTR(default_context_template,
    5981                 :            :                PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
    5982         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "DefaultContext",
    5983                 :            :                                  Py_NewRef(default_context_template)));
    5984                 :            : 
    5985                 :            : #ifndef WITH_DECIMAL_CONTEXTVAR
    5986                 :            :     ASSIGN_PTR(tls_context_key, PyUnicode_FromString("___DECIMAL_CTX__"));
    5987                 :            :     CHECK_INT(PyModule_AddObject(m, "HAVE_CONTEXTVAR", Py_NewRef(Py_False)));
    5988                 :            : #else
    5989         [ -  + ]:          2 :     ASSIGN_PTR(current_context_var, PyContextVar_New("decimal_context", NULL));
    5990         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "HAVE_CONTEXTVAR", Py_NewRef(Py_True)));
    5991                 :            : #endif
    5992         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "HAVE_THREADS", Py_NewRef(Py_True)));
    5993                 :            : 
    5994                 :            :     /* Init basic context template */
    5995         [ -  + ]:          2 :     ASSIGN_PTR(basic_context_template,
    5996                 :            :                PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
    5997                 :          2 :     init_basic_context(basic_context_template);
    5998         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "BasicContext",
    5999                 :            :                                  Py_NewRef(basic_context_template)));
    6000                 :            : 
    6001                 :            :     /* Init extended context template */
    6002         [ -  + ]:          2 :     ASSIGN_PTR(extended_context_template,
    6003                 :            :                PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
    6004                 :          2 :     init_extended_context(extended_context_template);
    6005         [ -  + ]:          2 :     CHECK_INT(PyModule_AddObject(m, "ExtendedContext",
    6006                 :            :                                  Py_NewRef(extended_context_template)));
    6007                 :            : 
    6008                 :            : 
    6009                 :            :     /* Init mpd_ssize_t constants */
    6010         [ +  + ]:         10 :     for (ssize_cm = ssize_constants; ssize_cm->name != NULL; ssize_cm++) {
    6011         [ -  + ]:          8 :         ASSIGN_PTR(obj, PyLong_FromSsize_t(ssize_cm->val));
    6012         [ -  + ]:          8 :         CHECK_INT(PyModule_AddObject(m, ssize_cm->name, obj));
    6013                 :          8 :         obj = NULL;
    6014                 :            :     }
    6015                 :            : 
    6016                 :            :     /* Init int constants */
    6017         [ -  + ]:          2 :     for (int_cm = int_constants; int_cm->name != NULL; int_cm++) {
    6018         [ #  # ]:          0 :         CHECK_INT(PyModule_AddIntConstant(m, int_cm->name,
    6019                 :            :                                           int_cm->val));
    6020                 :            :     }
    6021                 :            : 
    6022                 :            :     /* Init string constants */
    6023         [ +  + ]:         18 :     for (i = 0; i < _PY_DEC_ROUND_GUARD; i++) {
    6024         [ -  + ]:         16 :         ASSIGN_PTR(round_map[i], PyUnicode_InternFromString(mpd_round_string[i]));
    6025         [ -  + ]:         16 :         CHECK_INT(PyModule_AddObject(m, mpd_round_string[i], Py_NewRef(round_map[i])));
    6026                 :            :     }
    6027                 :            : 
    6028                 :            :     /* Add specification version number */
    6029         [ -  + ]:          2 :     CHECK_INT(PyModule_AddStringConstant(m, "__version__", "1.70"));
    6030         [ -  + ]:          2 :     CHECK_INT(PyModule_AddStringConstant(m, "__libmpdec_version__", mpd_version()));
    6031                 :            : 
    6032                 :            : 
    6033                 :          2 :     return m;
    6034                 :            : 
    6035                 :            : 
    6036                 :          0 : error:
    6037         [ #  # ]:          0 :     Py_CLEAR(obj); /* GCOV_NOT_REACHED */
    6038         [ #  # ]:          0 :     Py_CLEAR(numbers); /* GCOV_NOT_REACHED */
    6039         [ #  # ]:          0 :     Py_CLEAR(Number); /* GCOV_NOT_REACHED */
    6040         [ #  # ]:          0 :     Py_CLEAR(Rational); /* GCOV_NOT_REACHED */
    6041         [ #  # ]:          0 :     Py_CLEAR(collections); /* GCOV_NOT_REACHED */
    6042         [ #  # ]:          0 :     Py_CLEAR(collections_abc); /* GCOV_NOT_REACHED */
    6043         [ #  # ]:          0 :     Py_CLEAR(MutableMapping); /* GCOV_NOT_REACHED */
    6044         [ #  # ]:          0 :     Py_CLEAR(SignalTuple); /* GCOV_NOT_REACHED */
    6045         [ #  # ]:          0 :     Py_CLEAR(DecimalTuple); /* GCOV_NOT_REACHED */
    6046         [ #  # ]:          0 :     Py_CLEAR(default_context_template); /* GCOV_NOT_REACHED */
    6047                 :            : #ifndef WITH_DECIMAL_CONTEXTVAR
    6048                 :            :     Py_CLEAR(tls_context_key); /* GCOV_NOT_REACHED */
    6049                 :            : #else
    6050         [ #  # ]:          0 :     Py_CLEAR(current_context_var); /* GCOV_NOT_REACHED */
    6051                 :            : #endif
    6052         [ #  # ]:          0 :     Py_CLEAR(basic_context_template); /* GCOV_NOT_REACHED */
    6053         [ #  # ]:          0 :     Py_CLEAR(extended_context_template); /* GCOV_NOT_REACHED */
    6054         [ #  # ]:          0 :     Py_CLEAR(m); /* GCOV_NOT_REACHED */
    6055                 :            : 
    6056                 :          0 :     return NULL; /* GCOV_NOT_REACHED */
    6057                 :            : }

Generated by: LCOV version 1.14