/*[clinic input]

preserve

[clinic start generated code]*/

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#endif

#include "pycore_abstract.h" // _PyNumber_Index()

#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()

PyDoc_STRVAR(_decimal_Context_Etiny__doc__,

"Etiny($self, /)\n"

"--\n"

"\n"

"Return a value equal to Emin - prec + 1.\n"

"\n"

"This is the minimum exponent value for subnormal results. When\n"

"underflow occurs, the exponent is set to Etiny.");

#define _DECIMAL_CONTEXT_ETINY_METHODDEF \

{"Etiny", (PyCFunction)_decimal_Context_Etiny, METH_NOARGS, _decimal_Context_Etiny__doc__},

static PyObject *

_decimal_Context_Etiny_impl(PyObject *self);

static PyObject *

_decimal_Context_Etiny(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _decimal_Context_Etiny_impl(self);

}

PyDoc_STRVAR(_decimal_Context_Etop__doc__,

"Etop($self, /)\n"

"--\n"

"\n"

"Return a value equal to Emax - prec + 1.\n"

"\n"

"This is the maximum exponent if the _clamp field of the context is set\n"

"to 1 (IEEE clamp mode). Etop() must not be negative.");

#define _DECIMAL_CONTEXT_ETOP_METHODDEF \

{"Etop", (PyCFunction)_decimal_Context_Etop, METH_NOARGS, _decimal_Context_Etop__doc__},

static PyObject *

_decimal_Context_Etop_impl(PyObject *self);

static PyObject *

_decimal_Context_Etop(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _decimal_Context_Etop_impl(self);

}

#if defined(CONFIG_32)

PyDoc_STRVAR(_decimal_Context__unsafe_setprec__doc__,

"_unsafe_setprec($self, x, /)\n"

"--\n"

"\n");

#define _DECIMAL_CONTEXT__UNSAFE_SETPREC_METHODDEF \

{"_unsafe_setprec", (PyCFunction)_decimal_Context__unsafe_setprec, METH_O, _decimal_Context__unsafe_setprec__doc__},

static PyObject *

_decimal_Context__unsafe_setprec_impl(PyObject *self, Py_ssize_t x);

static PyObject *

_decimal_Context__unsafe_setprec(PyObject *self, PyObject *arg)

{

PyObject *return_value = NULL;

Py_ssize_t x;

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(arg);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

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

goto exit;

}

x = ival;

}

return_value = _decimal_Context__unsafe_setprec_impl(self, x);

exit:

return return_value;

}

#endif /* defined(CONFIG_32) */

#if defined(CONFIG_32)

PyDoc_STRVAR(_decimal_Context__unsafe_setemin__doc__,

"_unsafe_setemin($self, x, /)\n"

"--\n"

"\n");

#define _DECIMAL_CONTEXT__UNSAFE_SETEMIN_METHODDEF \

{"_unsafe_setemin", (PyCFunction)_decimal_Context__unsafe_setemin, METH_O, _decimal_Context__unsafe_setemin__doc__},

static PyObject *

_decimal_Context__unsafe_setemin_impl(PyObject *self, Py_ssize_t x);

static PyObject *

_decimal_Context__unsafe_setemin(PyObject *self, PyObject *arg)

{

PyObject *return_value = NULL;

Py_ssize_t x;

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(arg);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

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

goto exit;

}

x = ival;

}

return_value = _decimal_Context__unsafe_setemin_impl(self, x);

exit:

return return_value;

}

#endif /* defined(CONFIG_32) */

#if defined(CONFIG_32)

PyDoc_STRVAR(_decimal_Context__unsafe_setemax__doc__,

"_unsafe_setemax($self, x, /)\n"

"--\n"

"\n");

#define _DECIMAL_CONTEXT__UNSAFE_SETEMAX_METHODDEF \

{"_unsafe_setemax", (PyCFunction)_decimal_Context__unsafe_setemax, METH_O, _decimal_Context__unsafe_setemax__doc__},

static PyObject *

_decimal_Context__unsafe_setemax_impl(PyObject *self, Py_ssize_t x);

static PyObject *

_decimal_Context__unsafe_setemax(PyObject *self, PyObject *arg)

{

PyObject *return_value = NULL;

Py_ssize_t x;

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(arg);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

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

goto exit;

}

x = ival;

}

return_value = _decimal_Context__unsafe_setemax_impl(self, x);

exit:

return return_value;

}

#endif /* defined(CONFIG_32) */

PyDoc_STRVAR(_decimal_Context_clear_traps__doc__,

"clear_traps($self, /)\n"

"--\n"

"\n"

"Set all traps to False.");

#define _DECIMAL_CONTEXT_CLEAR_TRAPS_METHODDEF \

{"clear_traps", (PyCFunction)_decimal_Context_clear_traps, METH_NOARGS, _decimal_Context_clear_traps__doc__},

static PyObject *

_decimal_Context_clear_traps_impl(PyObject *self);

static PyObject *

_decimal_Context_clear_traps(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _decimal_Context_clear_traps_impl(self);

}

PyDoc_STRVAR(_decimal_Context_clear_flags__doc__,

"clear_flags($self, /)\n"

"--\n"

"\n"

"Reset all flags to False.");

#define _DECIMAL_CONTEXT_CLEAR_FLAGS_METHODDEF \

{"clear_flags", (PyCFunction)_decimal_Context_clear_flags, METH_NOARGS, _decimal_Context_clear_flags__doc__},

static PyObject *

_decimal_Context_clear_flags_impl(PyObject *self);

static PyObject *

_decimal_Context_clear_flags(PyObject *self, PyObject *Py_UNUSED(ignored))

{

return _decimal_Context_clear_flags_impl(self);

}

PyDoc_STRVAR(context_init__doc__,

"Context(prec=None, rounding=None, Emin=None, Emax=None, capitals=None,\n"

" clamp=None, flags=None, traps=None)\n"

"--\n"

"\n"

"Create context.\n"

"\n"

"The context affects almost all operations and controls rounding,\n"

"Over/Underflow, raising of exceptions and much more. A new context\n"

"can be constructed as follows:\n"

"\n"

" >>> c = Context(prec=28, Emin=-425000000, Emax=425000000,\n"

" ... rounding=ROUND_HALF_EVEN, capitals=1, clamp=1,\n"

" ... traps=[InvalidOperation, DivisionByZero, Overflow],\n"

" ... flags=[])\n"

" >>>");

static int

context_init_impl(PyObject *self, PyObject *prec, PyObject *rounding,

PyObject *emin, PyObject *emax, PyObject *capitals,

PyObject *clamp, PyObject *status, PyObject *traps);

static int

context_init(PyObject *self, PyObject *args, PyObject *kwargs)

{

int return_value = -1;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 8

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(prec), &_Py_ID(rounding), &_Py_ID(Emin), &_Py_ID(Emax), &_Py_ID(capitals), &_Py_ID(clamp), &_Py_ID(flags), &_Py_ID(traps), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"prec", "rounding", "Emin", "Emax", "capitals", "clamp", "flags", "traps", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "Context",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[8];

PyObject * const *fastargs;

Py_ssize_t nargs = PyTuple_GET_SIZE(args);

Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;

PyObject *prec = Py_None;

PyObject *rounding = Py_None;

PyObject *emin = Py_None;

PyObject *emax = Py_None;

PyObject *capitals = Py_None;

PyObject *clamp = Py_None;

PyObject *status = Py_None;

PyObject *traps = Py_None;

fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,

/*minpos*/ 0, /*maxpos*/ 8, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!fastargs) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (fastargs[0]) {

prec = fastargs[0];

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (fastargs[1]) {

rounding = fastargs[1];

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (fastargs[2]) {

emin = fastargs[2];

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (fastargs[3]) {

emax = fastargs[3];

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (fastargs[4]) {

capitals = fastargs[4];

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (fastargs[5]) {

clamp = fastargs[5];

if (!--noptargs) {

goto skip_optional_pos;

}

}

if (fastargs[6]) {

status = fastargs[6];

if (!--noptargs) {

goto skip_optional_pos;

}

}

traps = fastargs[7];

skip_optional_pos:

return_value = context_init_impl(self, prec, rounding, emin, emax, capitals, clamp, status, traps);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_IEEEContext__doc__,

"IEEEContext($module, bits, /)\n"

"--\n"

"\n"

"Return a context, initialized as one of the IEEE interchange formats.\n"

"\n"

"The argument must be a multiple of 32 and less than\n"

"IEEE_CONTEXT_MAX_BITS.");

#define _DECIMAL_IEEECONTEXT_METHODDEF \

{"IEEEContext", (PyCFunction)_decimal_IEEEContext, METH_O, _decimal_IEEEContext__doc__},

static PyObject *

_decimal_IEEEContext_impl(PyObject *module, Py_ssize_t bits);

static PyObject *

_decimal_IEEEContext(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

Py_ssize_t bits;

{

Py_ssize_t ival = -1;

PyObject *iobj = _PyNumber_Index(arg);

if (iobj != NULL) {

ival = PyLong_AsSsize_t(iobj);

Py_DECREF(iobj);

}

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

goto exit;

}

bits = ival;

}

return_value = _decimal_IEEEContext_impl(module, bits);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Context_copy__doc__,

"copy($self, /)\n"

"--\n"

"\n"

"Return a duplicate of the context with all flags cleared.");

#define _DECIMAL_CONTEXT_COPY_METHODDEF \

{"copy", _PyCFunction_CAST(_decimal_Context_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Context_copy__doc__},

static PyObject *

_decimal_Context_copy_impl(PyObject *self, PyTypeObject *cls);

static PyObject *

_decimal_Context_copy(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");

return NULL;

}

return _decimal_Context_copy_impl(self, cls);

}

PyDoc_STRVAR(_decimal_Context___copy____doc__,

"__copy__($self, /)\n"

"--\n"

"\n");

#define _DECIMAL_CONTEXT___COPY___METHODDEF \

{"__copy__", _PyCFunction_CAST(_decimal_Context___copy__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Context___copy____doc__},

static PyObject *

_decimal_Context___copy___impl(PyObject *self, PyTypeObject *cls);

static PyObject *

_decimal_Context___copy__(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "__copy__() takes no arguments");

return NULL;

}

return _decimal_Context___copy___impl(self, cls);

}

PyDoc_STRVAR(_decimal_Context___reduce____doc__,

"__reduce__($self, /)\n"

"--\n"

"\n");

#define _DECIMAL_CONTEXT___REDUCE___METHODDEF \

{"__reduce__", _PyCFunction_CAST(_decimal_Context___reduce__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Context___reduce____doc__},

static PyObject *

_decimal_Context___reduce___impl(PyObject *self, PyTypeObject *cls);

static PyObject *

_decimal_Context___reduce__(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "__reduce__() takes no arguments");

return NULL;

}

return _decimal_Context___reduce___impl(self, cls);

}

PyDoc_STRVAR(_decimal_getcontext__doc__,

"getcontext($module, /)\n"

"--\n"

"\n"

"Get the current default context.");

#define _DECIMAL_GETCONTEXT_METHODDEF \

{"getcontext", (PyCFunction)_decimal_getcontext, METH_NOARGS, _decimal_getcontext__doc__},

static PyObject *

_decimal_getcontext_impl(PyObject *module);

static PyObject *

_decimal_getcontext(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return _decimal_getcontext_impl(module);

}

PyDoc_STRVAR(_decimal_setcontext__doc__,

"setcontext($module, context, /)\n"

"--\n"

"\n"

"Set a new default context.");

#define _DECIMAL_SETCONTEXT_METHODDEF \

{"setcontext", (PyCFunction)_decimal_setcontext, METH_O, _decimal_setcontext__doc__},

PyDoc_STRVAR(_decimal_localcontext__doc__,

"localcontext($module, /, ctx=None, **kwargs)\n"

"--\n"

"\n"

"Return a context manager for a copy of the supplied context.\n"

"\n"

"That will set the default context to a copy of ctx on entry to the\n"

"with-statement and restore the previous default context when exiting\n"

"the with-statement. If no context is specified, a copy of the current\n"

"default context is used.");

#define _DECIMAL_LOCALCONTEXT_METHODDEF \

{"localcontext", _PyCFunction_CAST(_decimal_localcontext), METH_FASTCALL|METH_KEYWORDS, _decimal_localcontext__doc__},

static PyObject *

_decimal_localcontext_impl(PyObject *module, PyObject *local, PyObject *prec,

PyObject *rounding, PyObject *Emin,

PyObject *Emax, PyObject *capitals,

PyObject *clamp, PyObject *flags, PyObject *traps);

static PyObject *

_decimal_localcontext(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 9

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(ctx), &_Py_ID(prec), &_Py_ID(rounding), &_Py_ID(Emin), &_Py_ID(Emax), &_Py_ID(capitals), &_Py_ID(clamp), &_Py_ID(flags), &_Py_ID(traps), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"ctx", "prec", "rounding", "Emin", "Emax", "capitals", "clamp", "flags", "traps", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "localcontext",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[9];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

PyObject *local = Py_None;

PyObject *prec = Py_None;

PyObject *rounding = Py_None;

PyObject *Emin = Py_None;

PyObject *Emax = Py_None;

PyObject *capitals = Py_None;

PyObject *clamp = Py_None;

PyObject *flags = Py_None;

PyObject *traps = Py_None;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (args[0]) {

local = args[0];

if (!--noptargs) {

goto skip_optional_pos;

}

}

skip_optional_pos:

if (!noptargs) {

goto skip_optional_kwonly;

}

if (args[1]) {

prec = args[1];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[2]) {

rounding = args[2];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[3]) {

Emin = args[3];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[4]) {

Emax = args[4];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[5]) {

capitals = args[5];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[6]) {

clamp = args[6];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[7]) {

flags = args[7];

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

traps = args[8];

skip_optional_kwonly:

return_value = _decimal_localcontext_impl(module, local, prec, rounding, Emin, Emax, capitals, clamp, flags, traps);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Decimal_from_float__doc__,

"from_float($type, f, /)\n"

"--\n"

"\n"

"Class method that converts a float to a decimal number, exactly.\n"

"\n"

"Since 0.1 is not exactly representable in binary floating point,\n"

"Decimal.from_float(0.1) is not the same as Decimal(\'0.1\').\n"

"\n"

" >>> Decimal.from_float(0.1)\n"

" Decimal(\'0.1000000000000000055511151231257827021181583404541015625\')\n"

" >>> Decimal.from_float(float(\'nan\'))\n"

" Decimal(\'NaN\')\n"

" >>> Decimal.from_float(float(\'inf\'))\n"

" Decimal(\'Infinity\')\n"

" >>> Decimal.from_float(float(\'-inf\'))\n"

" Decimal(\'-Infinity\')");

#define _DECIMAL_DECIMAL_FROM_FLOAT_METHODDEF \

{"from_float", _PyCFunction_CAST(_decimal_Decimal_from_float), METH_METHOD|METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _decimal_Decimal_from_float__doc__},

static PyObject *

_decimal_Decimal_from_float_impl(PyTypeObject *type, PyTypeObject *cls,

PyObject *pyfloat);

static PyObject *

_decimal_Decimal_from_float(PyObject *type, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)

#else

# define KWTUPLE NULL

#endif

static const char * const _keywords[] = {"", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "from_float",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

PyObject *pyfloat;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

pyfloat = args[0];

return_value = _decimal_Decimal_from_float_impl((PyTypeObject *)type, cls, pyfloat);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Decimal_from_number__doc__,

"from_number($type, number, /)\n"

"--\n"

"\n"

"Class method that converts a real number to a decimal number, exactly.\n"

"\n"

" >>> Decimal.from_number(314) # int\n"

" Decimal(\'314\')\n"

" >>> Decimal.from_number(0.1) # float\n"

" Decimal(\'0.1000000000000000055511151231257827021181583404541015625\')\n"

" >>> Decimal.from_number(Decimal(\'3.14\')) # another decimal instance\n"

" Decimal(\'3.14\')");

#define _DECIMAL_DECIMAL_FROM_NUMBER_METHODDEF \

{"from_number", _PyCFunction_CAST(_decimal_Decimal_from_number), METH_METHOD|METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _decimal_Decimal_from_number__doc__},

static PyObject *

_decimal_Decimal_from_number_impl(PyTypeObject *type, PyTypeObject *cls,

PyObject *number);

static PyObject *

_decimal_Decimal_from_number(PyObject *type, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)

#else

# define KWTUPLE NULL

#endif

static const char * const _keywords[] = {"", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "from_number",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

PyObject *number;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

number = args[0];

return_value = _decimal_Decimal_from_number_impl((PyTypeObject *)type, cls, number);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Context_create_decimal_from_float__doc__,

"create_decimal_from_float($self, f, /)\n"

"--\n"

"\n"

"Create a new Decimal instance from float f.\n"

"\n"

"Unlike the Decimal.from_float() class method, this function observes\n"

"the context limits.");

#define _DECIMAL_CONTEXT_CREATE_DECIMAL_FROM_FLOAT_METHODDEF \

{"create_decimal_from_float", _PyCFunction_CAST(_decimal_Context_create_decimal_from_float), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Context_create_decimal_from_float__doc__},

static PyObject *

_decimal_Context_create_decimal_from_float_impl(PyObject *context,

PyTypeObject *cls,

PyObject *f);

static PyObject *

_decimal_Context_create_decimal_from_float(PyObject *context, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)

#else

# define KWTUPLE NULL

#endif

static const char * const _keywords[] = {"", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "create_decimal_from_float",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

PyObject *f;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

f = args[0];

return_value = _decimal_Context_create_decimal_from_float_impl(context, cls, f);

exit:

return return_value;

}

PyDoc_STRVAR(dec_new__doc__,

"Decimal(value=\'0\', context=None)\n"

"--\n"

"\n"

"Construct a new Decimal object.\n"

"\n"

"value can be an integer, string, tuple, or another Decimal object. If\n"

"no value is given, return Decimal(\'0\'). The context does not affect\n"

"the conversion and is only passed to determine if the InvalidOperation\n"

"trap is active.");

static PyObject *

dec_new_impl(PyTypeObject *type, PyObject *value, PyObject *context);

static PyObject *

dec_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(value), &_Py_ID(context), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"value", "context", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "Decimal",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

PyObject * const *fastargs;

Py_ssize_t nargs = PyTuple_GET_SIZE(args);

Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;

PyObject *value = NULL;

PyObject *context = Py_None;

fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,

/*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!fastargs) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}

if (fastargs[0]) {

value = fastargs[0];

if (!--noptargs) {

goto skip_optional_pos;

}

}

context = fastargs[1];

skip_optional_pos:

return_value = dec_new_impl(type, value, context);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Context_create_decimal__doc__,

"create_decimal($self, num=\'0\', /)\n"

"--\n"

"\n"

"Create a new Decimal instance from num, using self as the context.\n"

"\n"

"Unlike the Decimal constructor, this function observes the context\n"

"limits.");

#define _DECIMAL_CONTEXT_CREATE_DECIMAL_METHODDEF \

{"create_decimal", _PyCFunction_CAST(_decimal_Context_create_decimal), METH_FASTCALL, _decimal_Context_create_decimal__doc__},

static PyObject *

_decimal_Context_create_decimal_impl(PyObject *context, PyObject *num);

static PyObject *

_decimal_Context_create_decimal(PyObject *context, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *num = NULL;

if (!_PyArg_CheckPositional("create_decimal", nargs, 0, 1)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

num = args[0];

skip_optional:

return_value = _decimal_Context_create_decimal_impl(context, num);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Decimal___format____doc__,

"__format__($self, format_spec, override=<unrepresentable>, /)\n"

"--\n"

"\n"

"Formats the Decimal according to format_spec.");

#define _DECIMAL_DECIMAL___FORMAT___METHODDEF \

{"__format__", _PyCFunction_CAST(_decimal_Decimal___format__), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal___format____doc__},

static PyObject *

_decimal_Decimal___format___impl(PyObject *dec, PyTypeObject *cls,

PyObject *fmtarg, PyObject *override);

static PyObject *

_decimal_Decimal___format__(PyObject *dec, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)

#else

# define KWTUPLE NULL

#endif

static const char * const _keywords[] = {"", "", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "__format__",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

PyObject *fmtarg;

PyObject *override = NULL;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!PyUnicode_Check(args[0])) {

_PyArg_BadArgument("__format__", "argument 1", "str", args[0]);

goto exit;

}

fmtarg = args[0];

if (nargs < 2) {

goto skip_optional_posonly;

}

override = args[1];

skip_optional_posonly:

return_value = _decimal_Decimal___format___impl(dec, cls, fmtarg, override);

exit:

return return_value;

}

PyDoc_STRVAR(_decimal_Decimal_as_integer_ratio__doc__,

"as_integer_ratio($self, /)\n"

"--\n"

"\n"

"Return a pair of integers whose ratio is exactly equal to the original.\n"

"\n"

"The ratio is in lowest terms and with a positive denominator.\n"

"Raise OverflowError on infinities and a ValueError on NaNs.");

#define _DECIMAL_DECIMAL_AS_INTEGER_RATIO_METHODDEF \

{"as_integer_ratio", _PyCFunction_CAST(_decimal_Decimal_as_integer_ratio), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_as_integer_ratio__doc__},

static PyObject *

_decimal_Decimal_as_integer_ratio_impl(PyObject *self, PyTypeObject *cls);

static PyObject *

_decimal_Decimal_as_integer_ratio(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) {

PyErr_SetString(PyExc_TypeError, "as_integer_ratio() takes no arguments");

return NULL;

}

return _decimal_Decimal_as_integer_ratio_impl(self, cls);

}

PyDoc_STRVAR(_decimal_Decimal_to_integral_value__doc__,

"to_integral_value($self, /, rounding=None, context=None)\n"

"--\n"

"\n"

"Round to the nearest integer without signaling Inexact or Rounded.\n"

"\n"

"The rounding mode is determined by the rounding parameter if given,\n"

"else by the given context. If neither parameter is given, then the\n"

"rounding mode of the current default context is used.");

#define _DECIMAL_DECIMAL_TO_INTEGRAL_VALUE_METHODDEF \

{"to_integral_value", _PyCFunction_CAST(_decimal_Decimal_to_integral_value), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _decimal_Decimal_to_integral_value__doc__},

static PyObject *

_decimal_Decimal_to_integral_value_impl(PyObject *self, PyTypeObject *cls,

PyObject *rounding,

PyObject *context);

static PyObject *

_decimal_Decimal_to_integral_value(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

Py_hash_t ob_hash;

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_hash = -1,

.ob_item = { &_Py_ID(rounding), &_Py_ID(context), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"rounding", "context", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "to_integral_value",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;

PyObject *rounding = Py_None;

PyObject *context = Py_None;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,

/*minpos*/ 0, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);

if (!args) {

goto exit;

}

if (!noptargs) {

goto skip_optional_pos;

}