Merge C version of decimal into py3k.

Modules/_decimal/_decimal.c

 /*
  * Copyright (c) 2008-2010 Stefan Krah. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
@@ skipping 146 matching lines @@
   {"Clamped", "decimal.Clamped", MPD_Clamped, NULL},
   {NULL}
 };
 
 /* Exceptions that inherit from InvalidOperation */
 static DecCondMap cond_map[] = {
   {"InvalidOperation", "decimal.InvalidOperation", MPD_Invalid_operation, NULL},
   {"ConversionSyntax", "decimal.ConversionSyntax", MPD_Conversion_syntax, NULL},
   {"DivisionImpossible", "decimal.DivisionImpossible", MPD_Division_impossible, NULL},
   {"DivisionUndefined", "decimal.DivisionUndefined", MPD_Division_undefined, NULL},
-  {"FpuError", "decimal.FpuError", MPD_Fpu_error, NULL},
   {"InvalidContext", "decimal.InvalidContext", MPD_Invalid_context, NULL},
   {"MallocError", "decimal.MallocError", MPD_Malloc_error, NULL},
   {NULL}
 };
 
 static const char *dec_signal_string[MPD_NUM_FLAGS] = {
         "Clamped",
         "InvalidOperation",
         "DivisionByZero",
         "InvalidOperation",
@@ skipping 15 matching lines @@
   [ROUND_CEILING, ROUND_FLOOR, ROUND_UP, ROUND_DOWN,\n\
    ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN,\n\
    ROUND_05UP]";
 
 static const char *invalid_signals_err =
 "valid values for signals are:\n\
   [InvalidOperation, FloatOperation, DivisionByZero,\n\
    Overflow, Underflow, Subnormal, Inexact, Rounded,\n\
    Clamped]";
 
+#ifdef EXTRA_FUNCTIONALITY
 static const char *invalid_flags_err =
 "valid values for _flags or _traps are:\n\
   signals:\n\
     [DecIEEEInvalidOperation, DecFloatOperation, DecDivisionByZero,\n\
      DecOverflow, DecUnderflow, DecSubnormal, DecInexact, DecRounded,\n\
      DecClamped]\n\
   conditions which trigger DecIEEEInvalidOperation:\n\
     [DecInvalidOperation, DecConversionSyntax, DecDivisionImpossible,\n\
      DecDivisionUndefined, DecFpuError, DecInvalidContext, DecMallocError]";
+#endif
 
 static int
 value_error_int(const char *mesg)
 {
         PyErr_SetString(PyExc_ValueError, mesg);
         return -1;
+}
+
+static PyObject *
+value_error_ptr(const char *mesg)
+{
+        PyErr_SetString(PyExc_ValueError, mesg);
+        return NULL;
 }
 
 static int
 type_error_int(const char *mesg)
 {
         PyErr_SetString(PyExc_TypeError, mesg);
         return -1;
 }
 
 static PyObject *
@@ skipping 187 matching lines @@
                         return DEC_ERR_OCCURRED;
                 }
                 if (x == 1) {
                         flags |= cm->flag;
                 }
         }
 
         return flags;
 }
 
+#ifdef EXTRA_FUNCTIONALITY
 static uint32_t
 long_as_flags(PyObject *v)
 {
         long x;
 
         x = PyLong_AsLong(v);
         if (x == -1 && PyErr_Occurred()) {
                 return DEC_ERR_OCCURRED;
         }
         if (x < 0 || x > (long)MPD_Max_status) {
                 PyErr_SetString(PyExc_TypeError, invalid_flags_err);
                 return DEC_INVALID_SIGNALS;
         }
 
         return x;
 }
+#endif
 
 static int
 dec_addstatus(PyObject *context, uint32_t status)
 {
         mpd_context_t *ctx = CTX(context);
 
         ctx->status |= status;
         if (ctx->traps&status) {
                 PyObject *ex, *siglist;
 
@@ skipping 222 matching lines @@
 {                                                                \
         return PyLong_FromUnsignedLong(mpd_get##mem(CTX(self))); \
 }
 
 Dec_CONTEXT_GET_SSIZE(prec)
 Dec_CONTEXT_GET_SSIZE(emax)
 Dec_CONTEXT_GET_SSIZE(emin)
 Dec_CONTEXT_GET_SSIZE(round)
 Dec_CONTEXT_GET_SSIZE(clamp)
 
+#ifdef EXTRA_FUNCTIONALITY
 Dec_CONTEXT_GET_ULONG(traps)
 Dec_CONTEXT_GET_ULONG(status)
+#endif
 
 static PyObject *
 context_getcapitals(PyObject *self, void *closure UNUSED)
 {
         return PyLong_FromLong(CtxCaps(self));
 }
 
+#ifdef EXTRA_FUNCTIONALITY
 static PyObject *
 context_getallcr(PyObject *self, void *closure UNUSED)
 {
         return PyLong_FromLong(mpd_getcr(CTX(self)));
 }
+#endif
 
 static PyObject *
 context_getetiny(PyObject *self, PyObject *dummy UNUSED)
 {
         return PyLong_FromSsize_t(mpd_etiny(CTX(self)));
 }
 
 static PyObject *
 context_getetop(PyObject *self, PyObject *dummy UNUSED)
 {
@@ skipping 53 matching lines @@
 
         ctx = CTX(self);
         if (!mpd_qsetemax(ctx, x)) {
                 return value_error_int(
                     "valid range for Emax is [0, MAX_EMAX]");
         }
 
         return 0;
 }
 
+#ifdef CONFIG_32
 static PyObject *
 context_unsafe_setprec(PyObject *self, PyObject *value)
 {
         mpd_context_t *ctx = CTX(self);
         mpd_ssize_t x;
 
         x = PyLong_AsSsize_t(value);
         if (x == -1 && PyErr_Occurred()) {
                 return NULL;
         }
 
+        if (x < 1 || x > 1070000000L) {
+                return value_error_ptr(
+                    "valid range for unsafe prec is [1, 1070000000]");
+        }
+
         ctx->prec = x;
         Py_RETURN_NONE;
 }
 
 static PyObject *
 context_unsafe_setemin(PyObject *self, PyObject *value)
 {
         mpd_context_t *ctx = CTX(self);
         mpd_ssize_t x;
 
         x = PyLong_AsSsize_t(value);
         if (x == -1 && PyErr_Occurred()) {
                 return NULL;
         }
 
+        if (x < -1070000000L || x > 0) {
+                return value_error_ptr(
+                    "valid range for unsafe emin is [-1070000000, 0]");
+        }
+
         ctx->emin = x;
         Py_RETURN_NONE;
 }
 
 static PyObject *
 context_unsafe_setemax(PyObject *self, PyObject *value)
 {
         mpd_context_t *ctx = CTX(self);
         mpd_ssize_t x;
 
         x = PyLong_AsSsize_t(value);
         if (x == -1 && PyErr_Occurred()) {
                 return NULL;
         }
 
+        if (x < 0 || x > 1070000000L) {
+                return value_error_ptr(
+                    "valid range for unsafe emax is [0, 1070000000]");
+        }
+
         ctx->emax = x;
         Py_RETURN_NONE;
 }
+#endif
 
 static int
 context_setround(PyObject *self, PyObject *value, void *closure UNUSED)
 {
         mpd_context_t *ctx;
         mpd_ssize_t x;
 
         x = PyLong_AsSsize_t(value);
         if (x == -1 && PyErr_Occurred()) {
                 return -1;
@@ skipping 20 matching lines @@
 
         if (x != 0 && x != 1) {
                 return value_error_int(
                     "valid values for capitals are 0 or 1");
         }
         CtxCaps(self) = (int)x;
 
         return 0;
 }
 
+#ifdef EXTRA_FUNCTIONALITY
 static int
 context_settraps(PyObject *self, PyObject *value, void *closure UNUSED)
 {
         mpd_context_t *ctx;
         uint32_t flags;
 
         flags = long_as_flags(value);
         if (flags & DEC_ERRORS) {
                 return -1;
         }
 
         ctx = CTX(self);
         if (!mpd_qsettraps(ctx, flags)) {
                 INTERNAL_ERROR_INT("context_settraps");
         }
 
         return 0;
 }
+#endif
 
 static int
 context_settraps_list(PyObject *self, PyObject *value)
 {
         mpd_context_t *ctx;
         uint32_t flags;
 
         flags = list_as_flags(value);
         if (flags & DEC_ERRORS) {
                 return -1;
@@ skipping 24 matching lines @@
         }
 
         ctx = CTX(self);
         if (!mpd_qsettraps(ctx, flags)) {
                 INTERNAL_ERROR_INT("context_settraps_dict");
         }
 
         return 0;
 }
 
+#ifdef EXTRA_FUNCTIONALITY
 static int
 context_setstatus(PyObject *self, PyObject *value, void *closure UNUSED)
 {
         mpd_context_t *ctx;
         uint32_t flags;
 
         flags = long_as_flags(value);
         if (flags & DEC_ERRORS) {
                 return -1;
         }
 
         ctx = CTX(self);
         if (!mpd_qsetstatus(ctx, flags)) {
                 INTERNAL_ERROR_INT("context_setstatus");
         }
 
         return 0;
 }
+#endif
 
 static int
 context_setstatus_list(PyObject *self, PyObject *value)
 {
         mpd_context_t *ctx;
         uint32_t flags;
 
         flags = list_as_flags(value);
         if (flags & DEC_ERRORS) {
                 return -1;
@@ skipping 44 matching lines @@
         BOUNDS_CHECK(x, INT_MIN, INT_MAX);
 
         ctx = CTX(self);
         if (!mpd_qsetclamp(ctx, (int)x)) {
                 return value_error_int("valid values for clamp are 0 or 1");
         }
 
         return 0;
 }
 
+#ifdef EXTRA_FUNCTIONALITY
 static int
 context_setallcr(PyObject *self, PyObject *value, void *closure UNUSED)
 {
         mpd_context_t *ctx;
         mpd_ssize_t x;
 
         x = PyLong_AsSsize_t(value);
         if (x == -1 && PyErr_Occurred()) {
                 return -1;
         }
         BOUNDS_CHECK(x, INT_MIN, INT_MAX);
 
         ctx = CTX(self);
         if (!mpd_qsetcr(ctx, (int)x)) {
                 return value_error_int("valid values for _allcr are 0 or 1");
         }
 
         return 0;
 }
+#endif
 
 static PyObject *
 context_getattr(PyObject *self, PyObject *name)
 {
         PyObject *retval;
 
         if (PyUnicode_Check(name)) {
                 if (PyUnicode_CompareWithASCIIString(name, "traps") == 0) {
                         retval = ((PyDecContextObject *)self)->traps;
                         Py_INCREF(retval);
@@ skipping 171 matching lines @@
             !mpd_qsetstatus(ctx, t.status)) {
                 return type_error_int("invalid context");
         }
 
         if (capitals != 0 && capitals != 1) {
                 return value_error_int("invalid context");
         }
         CtxCaps(self) = capitals;
 
         if (traps != NULL) {
-                if (PyLong_Check(traps)) {
+                if (PyList_Check(traps)) {
+                        ret = context_settraps_list(self, traps);
+                }
+#ifdef EXTRA_FUNCTIONALITY
+                else if (PyLong_Check(traps)) {
                         ret = context_settraps(self, traps, NULL);
                 }
-                else if (PyList_Check(traps)) {
-                        ret = context_settraps_list(self, traps);
-                }
+#endif
                 else {
                         ret = context_settraps_dict(self, traps);
                 }
                 if (ret < 0) {
                         return ret;
                 }
         }
         if (status != NULL) {
-                if (PyLong_Check(status)) {
+                if (PyList_Check(status)) {
+                        ret = context_setstatus_list(self, status);
+                }
+#ifdef EXTRA_FUNCTIONALITY
+                else if (PyLong_Check(status)) {
                         ret = context_setstatus(self, status, NULL);
                 }
-                else if (PyList_Check(status)) {
-                        ret = context_setstatus_list(self, status);
-                }
+#endif
                 else {
                         ret = context_setstatus_dict(self, status);
                 }
                 if (ret < 0) {
                         return ret;
                 }
         }
 
         return 0;
 }
@@ skipping 45 matching lines @@
 {
         mpd_context_t ctx = dflt_ctx;
 
         ctx.prec = 9;
         ctx.traps = 0;
 
         *CTX(v) = ctx;
         CtxCaps(v) = 1;
 }
 
+#ifdef EXTRA_FUNCTIONALITY
 /* Factory function for creating IEEE interchange format contexts */
 static PyObject *
 ieee_context(PyObject *dummy UNUSED, PyObject *v)
 {
         PyObject *context;
         mpd_ssize_t bits;
         mpd_context_t ctx;
 
         bits = PyLong_AsSsize_t(v);
         if (bits == -1 && PyErr_Occurred()) {
@@ skipping 14 matching lines @@
 
         return context;
 
 error:
         PyErr_Format(PyExc_ValueError,
             "argument must be a multiple of 32, with a maximum of %d",
             MPD_IEEE_CONTEXT_MAX_BITS);
 
         return NULL;
 }
+#endif
 
 static PyObject *
 context_copy(PyObject *self)
 {
         PyObject *copy;
 
         copy = PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL);
         if (copy == NULL) {
                 return NULL;
         }
@@ skipping 39 matching lines @@
 
 
 static PyGetSetDef context_getsets [] =
 {
   { "prec", (getter)context_getprec, (setter)context_setprec, NULL, NULL},
   { "Emax", (getter)context_getemax, (setter)context_setemax, NULL, NULL},
   { "Emin", (getter)context_getemin, (setter)context_setemin, NULL, NULL},
   { "rounding", (getter)context_getround, (setter)context_setround, NULL, NULL},
   { "capitals", (getter)context_getcapitals, (setter)context_setcapitals, NULL, NULL},
   { "clamp", (getter)context_getclamp, (setter)context_setclamp, NULL, NULL},
+#ifdef EXTRA_FUNCTIONALITY
   { "_allcr", (getter)context_getallcr, (setter)context_setallcr, NULL, NULL},
   { "_traps", (getter)context_gettraps, (setter)context_settraps, NULL, NULL},
   { "_flags", (getter)context_getstatus, (setter)context_setstatus, NULL, NULL},
+#endif
   {NULL}
 };
 
 
 #define CONTEXT_CHECK(obj) \
         if (!PyDecContext_Check(obj)) {            \
                 PyErr_SetString(PyExc_TypeError,   \
                     "argument must be a context"); \
                 return NULL;                       \
         }
@@ skipping 1625 matching lines @@
                         if ((sep = PyUnicode_AsUTF8String(sep)) == NULL) {
                                 goto finish;
                         }
                         spec.sep = PyBytes_AS_STRING(sep);
                 }
                 if ((grouping = PyDict_GetItemString(override, "grouping"))) {
                         if ((grouping = PyUnicode_AsUTF8String(grouping)) == NULL) {
                                 goto finish;
                         }
                         spec.grouping = PyBytes_AS_STRING(grouping);
+                }
+                if (mpd_validate_lconv(&spec) < 0) {
+                        PyErr_SetString(PyExc_ValueError,
+                            "invalid override dict");
+                        goto finish;
                 }
         }
         else {
                 n = strlen(spec.dot);
                 if (n > 1 || (n == 1 && !isascii((uchar)spec.dot[0]))) {
                         /* fix locale dependent non-ascii characters */
                         dot = dotsep_as_utf8(spec.dot);
                         if (dot == NULL) {
                                 goto finish;
                         }
@@ skipping 692 matching lines @@
                 Py_DECREF(b);
                 Py_XDECREF(c);
                 return NULL;
         }
 
         if (c == NULL) {
                 mpd_qpow(MPD(result), MPD(a), MPD(b),
                          CTX(context), &status);
         }
         else {
-                mpd_context_t maxctx;
-                mpd_maxcontext(&maxctx);
                 mpd_qpowmod(MPD(result), MPD(a), MPD(b), MPD(c),
                             CTX(context), &status);
+                status = (status == MPD_Clamped) ? 0 : status;
                 /* remove ideal exponent for compatibility with decimal.py */
                 mpd_qquantize(MPD(result), MPD(result), &zero,
-                              &maxctx, &status);
+                              CTX(context), &status);
                 Py_DECREF(c);
         }
         Py_DECREF(a);
         Py_DECREF(b);
         if (dec_addstatus(context, status)) {
                 Py_DECREF(result);
                 return NULL;
         }
 
         return result;
@@ skipping 305 matching lines @@
                 r = (r == -1);
                 break;
         case Py_GT:
                 r = (r == 1);
                 break;
         }
 
         return PyBool_FromLong(r);
 }
 
+/* __ceil__ */
+static PyObject *
+dec_ceil(PyObject *self, PyObject *dummy UNUSED)
+{
+        PyObject *context;
+
+        CURRENT_CONTEXT(context);
+        return dec_as_long(self, context, MPD_ROUND_CEILING);
+}
+
 /* __complex__ */
 static PyObject *
 dec_complex(PyObject *self, PyObject *dummy UNUSED)
 {
         PyObject *f;
         double x;
 
         f = PyDec_AsFloat(self);
         if (f == NULL) {
                 return NULL;
         }
 
         x = PyFloat_AsDouble(f);
         Py_DECREF(f);
         if (x == -1.0 && PyErr_Occurred()) {
                 return NULL;
         }
 
         return PyComplex_FromDoubles(x, 0);
 }
 
 /* __copy__ and __deepcopy__ */
 static PyObject *
 dec_copy(PyObject *self, PyObject *dummy UNUSED)
 {
         Py_INCREF(self);
         return self;
+}
+
+/* __floor__ */
+static PyObject *
+dec_floor(PyObject *self, PyObject *dummy UNUSED)
+{
+        PyObject *context;
+
+        CURRENT_CONTEXT(context);
+        return dec_as_long(self, context, MPD_ROUND_FLOOR);
 }
 
 /* Always uses the module context */
 static Py_hash_t
 dec_hash(PyObject *v)
 {
 #if defined(CONFIG_64) && _PyHASH_BITS == 61
         /* 2**61 - 1 */
         mpd_uint_t p_data[1] = {2305843009213693951ULL};
         mpd_t p = {MPD_POS|MPD_STATIC|MPD_CONST_DATA, 0, 19, 1, 1, p_data};
@@ skipping 116 matching lines @@
         }
 
         result = Py_BuildValue("O(O)", Py_TYPE(self), str);
         Py_DECREF(str);
 
         return result;
 }
 
 /* __trunc__ */
 static PyObject *
-dec_trunc(PyObject *dec, PyObject *dummy UNUSED)
+dec_trunc(PyObject *self, PyObject *dummy UNUSED)
 {
         PyObject *context;
 
         CURRENT_CONTEXT(context);
-        return dec_as_long(dec, context, MPD_ROUND_DOWN);
+        return dec_as_long(self, context, MPD_ROUND_DOWN);
 }
 
 /* real and imag */
 static PyObject *
 dec_real(PyObject *self, void *closure UNUSED)
 {
         Py_INCREF(self);
         return self;
 }
 
@@ skipping 131 matching lines @@
   /* Miscellaneous */
   { "from_float", dec_from_float, METH_O|METH_CLASS, doc_from_float },
   { "as_tuple", PyDec_AsTuple, METH_NOARGS, doc_as_tuple },
 
   /* Special methods */
   { "__copy__", dec_copy, METH_NOARGS, NULL },
   { "__deepcopy__", dec_copy, METH_O, NULL },
   { "__format__", dec_format, METH_VARARGS, NULL },
   { "__reduce__", dec_reduce, METH_NOARGS, NULL },
   { "__round__", PyDec_Round, METH_VARARGS, NULL },
+  { "__ceil__", dec_ceil, METH_NOARGS, NULL },
+  { "__floor__", dec_floor, METH_NOARGS, NULL },
   { "__trunc__", dec_trunc, METH_NOARGS, NULL },
   { "__complex__", dec_complex, METH_NOARGS, NULL },
 
   { NULL, NULL, 1 }
 };
 
 static PyTypeObject PyDec_Type =
 {
         PyVarObject_HEAD_INIT(NULL, 0)
         "decimal.Decimal",                      /* tp_name */
@@ skipping 308 matching lines @@
                 Py_DECREF(b);
                 Py_XDECREF(c);
                 return NULL;
         }
 
         if (c == NULL) {
                 mpd_qpow(MPD(result), MPD(a), MPD(b),
                          CTX(context), &status);
         }
         else {
-                mpd_context_t maxctx;
-                mpd_maxcontext(&maxctx);
                 mpd_qpowmod(MPD(result), MPD(a), MPD(b), MPD(c),
                             CTX(context), &status);
+                status = (status == MPD_Clamped) ? 0 : status;
                 /* remove ideal exponent for compatibility with decimal.py */
                 mpd_qquantize(MPD(result), MPD(result), &zero,
-                              &maxctx, &status);
+                              CTX(context), &status);
                 Py_DECREF(c);
         }
         Py_DECREF(a);
         Py_DECREF(b);
         if (dec_addstatus(context, status)) {
                 Py_DECREF(result);
                 return NULL;
         }
 
         return result;
@@ skipping 296 matching lines @@
   { "is_nan", ctx_mpd_isnan, METH_O, doc_ctx_is_nan },
   { "is_normal", ctx_mpd_isnormal, METH_O, doc_ctx_is_normal },
   { "is_qnan", ctx_mpd_isqnan, METH_O, doc_ctx_is_qnan },
   { "is_signed", ctx_mpd_issigned, METH_O, doc_ctx_is_signed },
   { "is_snan", ctx_mpd_issnan, METH_O, doc_ctx_is_snan },
   { "is_subnormal", ctx_mpd_issubnormal, METH_O, doc_ctx_is_subnormal },
   { "is_zero", ctx_mpd_iszero, METH_O, doc_ctx_is_zero },
 
   /* Functions with a single decimal argument */
   { "_apply", PyDecContext_Apply, METH_O, NULL }, /* alias for apply */
+#ifdef EXTRA_FUNCTIONALITY
   { "apply", PyDecContext_Apply, METH_O, doc_ctx_apply },
+#endif
   { "canonical", ctx_canonical, METH_O, doc_ctx_canonical },
   { "copy_abs", ctx_mpd_qcopy_abs, METH_O, doc_ctx_copy_abs },
   { "copy_decimal", ctx_copy_decimal, METH_O, doc_ctx_copy_decimal },
   { "copy_negate", ctx_mpd_qcopy_negate, METH_O, doc_ctx_copy_negate },
   { "logb", ctx_mpd_qlogb, METH_O, doc_ctx_logb },
   { "logical_invert", ctx_mpd_qinvert, METH_O, doc_ctx_logical_invert },
   { "number_class", ctx_mpd_class, METH_O, doc_ctx_number_class },
   { "to_sci_string", ctx_mpd_to_sci, METH_O, doc_ctx_to_sci_string },
   { "to_eng_string", ctx_mpd_to_eng, METH_O, doc_ctx_to_eng_string },
 
   /* Functions with two decimal arguments */
   { "compare_total", ctx_mpd_compare_total, METH_VARARGS, doc_ctx_compare_total },
   { "compare_total_mag", ctx_mpd_compare_total_mag, METH_VARARGS, doc_ctx_compare_total_mag },
   { "copy_sign", ctx_mpd_qcopy_sign, METH_VARARGS, doc_ctx_copy_sign },
   { "logical_and", ctx_mpd_qand, METH_VARARGS, doc_ctx_logical_and },
   { "logical_or", ctx_mpd_qor, METH_VARARGS, doc_ctx_logical_or },
   { "logical_xor", ctx_mpd_qxor, METH_VARARGS, doc_ctx_logical_xor },
   { "rotate", ctx_mpd_qrotate, METH_VARARGS, doc_ctx_rotate },
   { "same_quantum", ctx_mpd_same_quantum, METH_VARARGS, doc_ctx_same_quantum },
   { "scaleb", ctx_mpd_qscaleb, METH_VARARGS, doc_ctx_scaleb },
   { "shift", ctx_mpd_qshift, METH_VARARGS, doc_ctx_shift },
 
   /* Set context values */
   { "clear_flags", context_clear_flags, METH_NOARGS, doc_ctx_clear_flags },
   { "clear_traps", context_clear_traps, METH_NOARGS, doc_ctx_clear_traps },
 
-  /* Unsafe set functions with no range checks */
-  { "unsafe_setprec", context_unsafe_setprec, METH_O, NULL },
-  { "unsafe_setemin", context_unsafe_setemin, METH_O, NULL },
-  { "unsafe_setemax", context_unsafe_setemax, METH_O, NULL },
+#ifdef CONFIG_32
+  /* Unsafe set functions with relaxed range checks */
+  { "_unsafe_setprec", context_unsafe_setprec, METH_O, NULL },
+  { "_unsafe_setemin", context_unsafe_setemin, METH_O, NULL },
+  { "_unsafe_setemax", context_unsafe_setemax, METH_O, NULL },
+#endif
 
   /* Miscellaneous */
   { "__copy__", (PyCFunction)context_copy, METH_NOARGS, NULL },
   { "__reduce__", context_reduce, METH_NOARGS, NULL },
   { "copy", (PyCFunction)context_copy, METH_NOARGS, doc_ctx_copy },
   { "create_decimal", ctx_create_decimal, METH_VARARGS, doc_ctx_create_decimal },
   { "create_decimal_from_float", ctx_from_float, METH_O, doc_ctx_create_decimal_from_float },
 
   { NULL, NULL, 1 }
 };
@@ skipping 40 matching lines @@
         context_new,                               /* tp_new */
         0                                          /* tp_free */
 };
 
 
 static PyMethodDef _decimal_methods [] =
 {
   { "getcontext", (PyCFunction)PyDec_GetCurrentContext, METH_NOARGS, doc_getcontext},
   { "setcontext", (PyCFunction)PyDec_SetCurrentContext, METH_O, doc_setcontext},
   { "localcontext", (PyCFunction)ctxmanager_new, METH_VARARGS, doc_localcontext},
+#ifdef EXTRA_FUNCTIONALITY
   { "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context},
+#endif
   { NULL, NULL, 1, NULL }
 };
 
 static struct PyModuleDef _decimal_module = {
         PyModuleDef_HEAD_INIT,
         "decimal",
         doc__decimal,
         -1,
         _decimal_methods,
         NULL,
         NULL,
         NULL,
         NULL
 };
 
 struct ssize_constmap { const char *name; mpd_ssize_t val; };
 static struct ssize_constmap ssize_constants [] = {
         {"MAX_PREC", MPD_MAX_PREC},
         {"MAX_EMAX", MPD_MAX_EMAX},
         {"MIN_EMIN",  MPD_MIN_EMIN},
         {"MIN_ETINY", MPD_MIN_ETINY},
         {NULL}
 };
 
 struct int_constmap { const char *name; int val; };
 static struct int_constmap int_constants [] = {
         /* int constants */
+#ifdef EXTRA_FUNCTIONALITY
         {"DECIMAL32", MPD_DECIMAL32},
         {"DECIMAL64", MPD_DECIMAL64},
         {"DECIMAL128", MPD_DECIMAL128},
         {"IEEE_CONTEXT_MAX_BITS", MPD_IEEE_CONTEXT_MAX_BITS},
+#endif
         {"ROUND_CEILING", MPD_ROUND_CEILING},
         {"ROUND_FLOOR", MPD_ROUND_FLOOR},
         {"ROUND_UP", MPD_ROUND_UP},
         {"ROUND_DOWN", MPD_ROUND_DOWN},
         {"ROUND_HALF_UP", MPD_ROUND_HALF_UP},
         {"ROUND_HALF_DOWN", MPD_ROUND_HALF_DOWN},
         {"ROUND_HALF_EVEN", MPD_ROUND_HALF_EVEN},
         {"ROUND_05UP", MPD_ROUND_05UP},
+#ifdef EXTRA_FUNCTIONALITY
         {"ROUND_TRUNC", MPD_ROUND_TRUNC},
         /* int condition flags */
         {"DecClamped", MPD_Clamped},
         {"DecConversionSyntax", MPD_Conversion_syntax},
         {"DecDivisionByZero", MPD_Division_by_zero},
         {"DecDivisionImpossible", MPD_Division_impossible},
         {"DecDivisionUndefined", MPD_Division_undefined},
         {"DecFpuError", MPD_Fpu_error},
         {"DecInexact", MPD_Inexact},
         {"DecInvalidContext", MPD_Invalid_context},
         {"DecInvalidOperation", MPD_Invalid_operation},
         {"DecIEEEInvalidOperation", MPD_IEEE_Invalid_operation},
         {"DecMallocError", MPD_Malloc_error},
         {"DecFloatOperation", MPD_Float_operation},
         {"DecOverflow", MPD_Overflow},
         {"DecRounded", MPD_Rounded},
         {"DecSubnormal", MPD_Subnormal},
         {"DecUnderflow", MPD_Underflow},
         {"DecErrors", MPD_Errors},
         {"DecTraps", MPD_Traps},
+#endif
         {NULL}
 };
 
 
 #define CHECK_INT(expr) \
     do { if ((expr) < 0) goto error; } while (0)
 #define ASSIGN_PTR(result, expr) \
     do { result = (expr); if (result == NULL) goto error; } while (0)
 #define CHECK_PTR(expr) \
     do { if ((expr) == NULL) goto error; } while (0)
@@ skipping 76 matching lines @@
         /* Create the module */
         ASSIGN_PTR(m, PyModule_Create(&_decimal_module));
 
 
         /* Add types to the module */
         Py_INCREF(&PyDec_Type);
         CHECK_INT(PyModule_AddObject(m, "Decimal", (PyObject *)&PyDec_Type));
         Py_INCREF(&PyDecContext_Type);
         CHECK_INT(PyModule_AddObject(m, "Context",
                                      (PyObject *)&PyDecContext_Type));
+        Py_INCREF(DecimalTuple);
+        CHECK_INT(PyModule_AddObject(m, "DecimalTuple", DecimalTuple));
 
 
         /* Create top level exception */
         ASSIGN_PTR(DecimalException, PyErr_NewException(
                                          "decimal.DecimalException",
                                          PyExc_ArithmeticError, NULL));
         Py_INCREF(DecimalException);
         CHECK_INT(PyModule_AddObject(m, "DecimalException", DecimalException));
 
         /* Create signal tuple */
@@ skipping 33 matching lines @@
         ASSIGN_PTR(default_context_template,
                    PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
         Py_INCREF(default_context_template);
         CHECK_INT(PyModule_AddObject(m, "DefaultContext",
                                      default_context_template));
 
 #ifdef WITHOUT_THREADS
         /* Init module context */
         ASSIGN_PTR(module_context,
                    PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
-        CHECK_INT(PyModule_AddIntConstant(m, "HAVE_THREADS", 0));
+        Py_INCREF(Py_False);
+        CHECK_INT(PyModule_AddObject(m, "HAVE_THREADS", Py_False));
 #else
         ASSIGN_PTR(tls_context_key, PyUnicode_FromString("___DECIMAL_CTX__"));
-        CHECK_INT(PyModule_AddIntConstant(m, "HAVE_THREADS", 1));
+        Py_INCREF(Py_True);
+        CHECK_INT(PyModule_AddObject(m, "HAVE_THREADS", Py_True));
 #endif
 
         /* Init basic context template */
         ASSIGN_PTR(basic_context_template,
                    PyObject_CallObject((PyObject *)&PyDecContext_Type, NULL));
         init_basic_context(basic_context_template);
         Py_INCREF(basic_context_template);
         CHECK_INT(PyModule_AddObject(m, "BasicContext",
                                      basic_context_template));
 
@@ skipping 10 matching lines @@
         for (ssize_cm = ssize_constants; ssize_cm->name != NULL; ssize_cm++) {
                 ASSIGN_PTR(obj, PyLong_FromSsize_t(ssize_cm->val));
                 CHECK_INT(PyModule_AddObject(m, ssize_cm->name, obj));
         }
 
         /* Init int constants */
         for (int_cm = int_constants; int_cm->name != NULL; int_cm++) {
                 CHECK_INT(PyModule_AddIntConstant(m, int_cm->name,
                                                   int_cm->val));
         }
+
+        /* Add specification version number */
+        CHECK_INT(PyModule_AddStringConstant(m, "__version__", " 1.70"));
 
 
         return m;
 
 
 error:
         Py_XDECREF(obj); /* GCOV_NOT_REACHED */
         Py_XDECREF(numbers); /* GCOV_NOT_REACHED */
         Py_XDECREF(Number); /* GCOV_NOT_REACHED */
         Py_XDECREF(Rational); /* GCOV_NOT_REACHED */
         Py_XDECREF(collections); /* GCOV_NOT_REACHED */
         Py_XDECREF(MutableMapping); /* GCOV_NOT_REACHED */
         Py_XDECREF(SignalTuple); /* GCOV_NOT_REACHED */
         Py_XDECREF(DecimalTuple); /* GCOV_NOT_REACHED */
 #ifdef WITHOUT_THREADS
         Py_XDECREF(module_context); /* GCOV_NOT_REACHED */
 #else
         Py_XDECREF(default_context_template); /* GCOV_NOT_REACHED */
         Py_XDECREF(tls_context_key); /* GCOV_NOT_REACHED */
 #endif
         Py_XDECREF(basic_context_template); /* GCOV_NOT_REACHED */
         Py_XDECREF(extended_context_template); /* GCOV_NOT_REACHED */
         Py_XDECREF(m); /* GCOV_NOT_REACHED */
 
         return NULL; /* GCOV_NOT_REACHED */
 }