``H`` (integer) [unsigned short int]
Convert a C :ctype:`unsigned short int` to a Python integer object.
- ``I`` (integer/long) [unsigned int]
- Convert a C :ctype:`unsigned int` to a Python long integer object.
+ ``I`` (integer) [unsigned int]
+ Convert a C :ctype:`unsigned int` to a Python integer object.
- ``k`` (integer/long) [unsigned long]
- Convert a C :ctype:`unsigned long` to a Python long integer object.
+ ``k`` (integer) [unsigned long]
+ Convert a C :ctype:`unsigned long` to a Python integer object.
``L`` (long) [PY_LONG_LONG]
Convert a C :ctype:`long long` to a Python integer object. Only available
* Sanity checks of the input arguments are added to frame creation.
-* The storage for long ints is initialized with a known invalid pattern to catch
+* The storage for ints is initialized with a known invalid pattern to catch
reference to uninitialized digits.
* Low-level tracing and extra exception checking are added to the runtime
.. cfunction:: PyObject* PyNumber_Index(PyObject *o)
- Returns the *o* converted to a Python int or long on success or *NULL* with a
+ Returns the *o* converted to a Python int on success or *NULL* with a
:exc:`TypeError` exception raised on failure.
.. cfunction:: Py_ssize_t PyNumber_AsSsize_t(PyObject *o, PyObject *exc)
Returns *o* converted to a Py_ssize_t value if *o* can be interpreted as an
- integer. If *o* can be converted to a Python int or long but the attempt to
+ integer. If *o* can be converted to a Python int but the attempt to
convert to a Py_ssize_t value would raise an :exc:`OverflowError`, then the
*exc* argument is the type of exception that will be raised (usually
:exc:`IndexError` or :exc:`OverflowError`). If *exc* is *NULL*, then the
:attr:`ob_size` field, and the instance size is :attr:`tp_basicsize` plus N
times :attr:`tp_itemsize`, where N is the "length" of the object. The value of
N is typically stored in the instance's :attr:`ob_size` field. There are
- exceptions: for example, long ints use a negative :attr:`ob_size` to indicate a
+ exceptions: for example, ints use a negative :attr:`ob_size` to indicate a
negative number, and N is ``abs(ob_size)`` there. Also, the presence of an
:attr:`ob_size` field in the instance layout doesn't mean that the instance
structure is variable-length (for example, the structure for the list type has
where :attr:`tp_basicsize`, :attr:`tp_itemsize` and :attr:`tp_dictoffset` are
taken from the type object, and :attr:`ob_size` is taken from the instance. The
- absolute value is taken because long ints use the sign of :attr:`ob_size` to
+ absolute value is taken because ints use the sign of :attr:`ob_size` to
store the sign of the number. (There's never a need to do this calculation
yourself; it is done for you by :cfunc:`_PyObject_GetDictPtr`.)
binaryfunc nb_xor;
binaryfunc nb_or;
unaryfunc nb_int;
- unaryfunc nb_long;
+ void *nb_reserved;
unaryfunc nb_float;
binaryfunc nb_inplace_add;
``Py_NotImplemented``, if another error occurred they must return ``NULL``
and set an exception.
+ .. note::
+
+ The :cdata:`nb_reserved` field should always be ``NULL``. It
+ was previously called :cdata:`nb_long`, and was renamed in
+ Python 3.0.1.
+
.. _mapping-structs:
.. function:: trunc(x)
Return the :class:`Real` value *x* truncated to an :class:`Integral` (usually
- a long integer). Delegates to ``x.__trunc__()``.
+ an integer). Delegates to ``x.__trunc__()``.
Note that :func:`frexp` and :func:`modf` have a different call/return pattern
.. attribute:: Repr.maxlong
- Maximum number of characters in the representation for a long integer. Digits
+ Maximum number of characters in the representation for an integer. Digits
are dropped from the middle. The default is ``40``.
binaryfunc nb_xor;
binaryfunc nb_or;
unaryfunc nb_int;
- unaryfunc nb_long;
+ void *nb_reserved; /* the slot formerly known as nb_long */
unaryfunc nb_float;
binaryfunc nb_inplace_add;
Core and Builtins
-----------------
+- Issue #4910: Rename nb_long slot to nb_reserved, and change its
+ type to (void *).
+
- Issue #4935: The overflow checking code in the expandtabs() method common
to str, bytes and bytearray could be optimized away by the compiler, letting
the interpreter segfault instead of raising an error.
0, /*nb_xor*/
0, /*nb_or*/
0, /*nb_int*/
- 0, /*nb_long*/
+ 0, /*nb_reserved*/
0, /*nb_float*/
0, /*nb_inplace_add*/
0, /*nb_inplace_subtract*/
bool_xor, /* nb_xor */
bool_or, /* nb_or */
0, /* nb_int */
- 0, /* nb_long */
+ 0, /* nb_reserved */
0, /* nb_float */
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
0, /* nb_xor */
0, /* nb_or */
complex_int, /* nb_int */
- 0, /* nb_long */
+ 0, /* nb_reserved */
complex_float, /* nb_float */
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
py_exponent = NULL;
}
- /* Returns ints instead of longs where possible */
- INPLACE_UPDATE(numerator, PyNumber_Int(numerator));
- if (numerator == NULL) goto error;
- INPLACE_UPDATE(denominator, PyNumber_Int(denominator));
- if (denominator == NULL) goto error;
-
result_pair = PyTuple_Pack(2, numerator, denominator);
#undef INPLACE_UPDATE
0, /*nb_xor*/
0, /*nb_or*/
float_trunc, /*nb_int*/
- 0, /*nb_long*/
+ 0, /*nb_reserved*/
float_float, /*nb_float*/
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
long_xor, /*nb_xor*/
long_or, /*nb_or*/
long_long, /*nb_int*/
- 0, /*nb_long*/
+ 0, /*nb_reserved*/
long_float, /*nb_float*/
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
(binaryfunc)set_xor, /*nb_xor*/
(binaryfunc)set_or, /*nb_or*/
0, /*nb_int*/
- 0, /*nb_long*/
+ 0, /*nb_reserved*/
0, /*nb_float*/
0, /*nb_inplace_add*/
(binaryfunc)set_isub, /*nb_inplace_subtract*/
COPYNUM(nb_xor);
COPYNUM(nb_or);
COPYNUM(nb_int);
- COPYNUM(nb_long);
COPYNUM(nb_float);
COPYNUM(nb_inplace_add);
COPYNUM(nb_inplace_subtract);
SLOT1BIN(slot_nb_or, nb_or, "__or__", "__ror__")
SLOT0(slot_nb_int, "__int__")
-SLOT0(slot_nb_long, "__long__")
SLOT0(slot_nb_float, "__float__")
SLOT1(slot_nb_inplace_add, "__iadd__", PyObject *, "O")
SLOT1(slot_nb_inplace_subtract, "__isub__", PyObject *, "O")
RBINSLOT("__ror__", nb_or, slot_nb_or, "|"),
UNSLOT("__int__", nb_int, slot_nb_int, wrap_unaryfunc,
"int(x)"),
- UNSLOT("__long__", nb_long, slot_nb_long, wrap_unaryfunc,
- "int(x)"),
UNSLOT("__float__", nb_float, slot_nb_float, wrap_unaryfunc,
"float(x)"),
NBSLOT("__index__", nb_index, slot_nb_index, wrap_unaryfunc,
proxy_xor, /*nb_xor*/
proxy_or, /*nb_or*/
proxy_int, /*nb_int*/
- 0, /*nb_long*/
+ 0, /*nb_reserved*/
proxy_float, /*nb_float*/
proxy_iadd, /*nb_inplace_add*/
proxy_isub, /*nb_inplace_subtract*/
PyHKEY_binaryFailureFunc, /* nb_xor */
PyHKEY_binaryFailureFunc, /* nb_or */
PyHKEY_intFunc, /* nb_int */
- 0, /* nb_long */
+ 0, /* nb_reserved */
PyHKEY_unaryFailureFunc, /* nb_float */
};
projects / thirdparty / Python / cpython.git / commitdiff
