Integer Objects
***************

All integers are implemented as "long" integer objects of arbitrary
size.

On error, most "PyLong_As*" APIs return "(return type)-1" which cannot
be distinguished from a number.  Use "PyErr_Occurred()" to
disambiguate.

type PyLongObject
    * Part of the Limited API (as an opaque struct).*

   This subtype of "PyObject" represents a Python integer object.

PyTypeObject PyLong_Type
    * Part of the Stable ABI.*

   This instance of "PyTypeObject" represents the Python integer type.
   This is the same object as "int" in the Python layer.

int PyLong_Check(PyObject *p)

   Return true if its argument is a "PyLongObject" or a subtype of
   "PyLongObject".  This function always succeeds.

int PyLong_CheckExact(PyObject *p)

   Return true if its argument is a "PyLongObject", but not a subtype
   of "PyLongObject".  This function always succeeds.

PyObject *PyLong_FromLong(long v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from *v*, or "NULL" on failure.

   The current implementation keeps an array of integer objects for
   all integers between "-5" and "256". When you create an int in that
   range you actually just get back a reference to the existing
   object.

PyObject *PyLong_FromUnsignedLong(unsigned long v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from a C unsigned long, or
   "NULL" on failure.

PyObject *PyLong_FromSsize_t(Py_ssize_t v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from a C "Py_ssize_t", or "NULL"
   on failure.

PyObject *PyLong_FromSize_t(size_t v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from a C "size_t", or "NULL" on
   failure.

PyObject *PyLong_FromLongLong(long long v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from a C long long, or "NULL" on
   failure.

PyObject *PyLong_FromUnsignedLongLong(unsigned long long v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from a C unsigned long long, or
   "NULL" on failure.

PyObject *PyLong_FromDouble(double v)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" object from the integer part of *v*, or
   "NULL" on failure.

PyObject *PyLong_FromString(const char *str, char **pend, int base)
    *Return value: New reference.** Part of the Stable ABI.*

   Return a new "PyLongObject" based on the string value in *str*,
   which is interpreted according to the radix in *base*, or "NULL" on
   failure.  If *pend* is non-"NULL", **pend* will point to the end of
   *str* on success or to the first character that could not be
   processed on error.  If *base* is "0", *str* is interpreted using
   the Integer literals definition; in this case, leading zeros in a
   non-zero decimal number raises a "ValueError".  If *base* is not
   "0", it must be between "2" and "36", inclusive.  Leading and
   trailing whitespace and single underscores after a base specifier
   and between digits are ignored.  If there are no digits or *str* is
   not NULL-terminated following the digits and trailing whitespace,
   "ValueError" will be raised.

   See also:

     Python methods "int.to_bytes()" and "int.from_bytes()" to convert
     a "PyLongObject" to/from an array of bytes in base "256". You can
     call those from C using "PyObject_CallMethod()".

PyObject *PyLong_FromUnicodeObject(PyObject *u, int base)
    *Return value: New reference.*

   Convert a sequence of Unicode digits in the string *u* to a Python
   integer value.

   New in version 3.3.

PyObject *PyLong_FromVoidPtr(void *p)
    *Return value: New reference.** Part of the Stable ABI.*

   Create a Python integer from the pointer *p*. The pointer value can
   be retrieved from the resulting value using "PyLong_AsVoidPtr()".

PyObject *PyLong_FromNativeBytes(const void *buffer, size_t n_bytes, int endianness)

   Create a Python integer from the value contained in the first
   *n_bytes* of *buffer*, interpreted as a two's-complement signed
   number.

   *endianness* may be passed "-1" for the native endian that CPython
   was compiled with, or else "0" for big endian and "1" for little.

   New in version 3.13.

PyObject *PyLong_FromUnsignedNativeBytes(const void *buffer, size_t n_bytes, int endianness)

   Create a Python integer from the value contained in the first
   *n_bytes* of *buffer*, interpreted as an unsigned number.

   *endianness* may be passed "-1" for the native endian that CPython
   was compiled with, or else "0" for big endian and "1" for little.

   New in version 3.13.

long PyLong_AsLong(PyObject *obj)
    * Part of the Stable ABI.*

   Return a C long representation of *obj*.  If *obj* is not an
   instance of "PyLongObject", first call its "__index__()" method (if
   present) to convert it to a "PyLongObject".

   Raise "OverflowError" if the value of *obj* is out of range for a
   long.

   Returns "-1" on error.  Use "PyErr_Occurred()" to disambiguate.

   Changed in version 3.8: Use "__index__()" if available.

   Changed in version 3.10: This function will no longer use
   "__int__()".

int PyLong_AsInt(PyObject *obj)
    * Part of the Stable ABI since version 3.13.*

   Similar to "PyLong_AsLong()", but store the result in a C int
   instead of a C long.

   New in version 3.13.

long PyLong_AsLongAndOverflow(PyObject *obj, int *overflow)
    * Part of the Stable ABI.*

   Return a C long representation of *obj*.  If *obj* is not an
   instance of "PyLongObject", first call its "__index__()" method (if
   present) to convert it to a "PyLongObject".

   If the value of *obj* is greater than "LONG_MAX" or less than
   "LONG_MIN", set **overflow* to "1" or "-1", respectively, and
   return "-1"; otherwise, set **overflow* to "0".  If any other
   exception occurs set **overflow* to "0" and return "-1" as usual.

   Returns "-1" on error.  Use "PyErr_Occurred()" to disambiguate.

   Changed in version 3.8: Use "__index__()" if available.

   Changed in version 3.10: This function will no longer use
   "__int__()".

long long PyLong_AsLongLong(PyObject *obj)
    * Part of the Stable ABI.*

   Return a C long long representation of *obj*.  If *obj* is not an
   instance of "PyLongObject", first call its "__index__()" method (if
   present) to convert it to a "PyLongObject".

   Raise "OverflowError" if the value of *obj* is out of range for a
   long long.

   Returns "-1" on error.  Use "PyErr_Occurred()" to disambiguate.

   Changed in version 3.8: Use "__index__()" if available.

   Changed in version 3.10: This function will no longer use
   "__int__()".

long long PyLong_AsLongLongAndOverflow(PyObject *obj, int *overflow)
    * Part of the Stable ABI.*

   Return a C long long representation of *obj*.  If *obj* is not an
   instance of "PyLongObject", first call its "__index__()" method (if
   present) to convert it to a "PyLongObject".

   If the value of *obj* is greater than "LLONG_MAX" or less than
   "LLONG_MIN", set **overflow* to "1" or "-1", respectively, and
   return "-1"; otherwise, set **overflow* to "0".  If any other
   exception occurs set **overflow* to "0" and return "-1" as usual.

   Returns "-1" on error.  Use "PyErr_Occurred()" to disambiguate.

   New in version 3.2.

   Changed in version 3.8: Use "__index__()" if available.

   Changed in version 3.10: This function will no longer use
   "__int__()".

Py_ssize_t PyLong_AsSsize_t(PyObject *pylong)
    * Part of the Stable ABI.*

   Return a C "Py_ssize_t" representation of *pylong*.  *pylong* must
   be an instance of "PyLongObject".

   Raise "OverflowError" if the value of *pylong* is out of range for
   a "Py_ssize_t".

   Returns "-1" on error.  Use "PyErr_Occurred()" to disambiguate.

unsigned long PyLong_AsUnsignedLong(PyObject *pylong)
    * Part of the Stable ABI.*

   Return a C unsigned long representation of *pylong*.  *pylong* must
   be an instance of "PyLongObject".

   Raise "OverflowError" if the value of *pylong* is out of range for
   a unsigned long.

   Returns "(unsigned long)-1" on error. Use "PyErr_Occurred()" to
   disambiguate.

size_t PyLong_AsSize_t(PyObject *pylong)
    * Part of the Stable ABI.*

   Return a C "size_t" representation of *pylong*.  *pylong* must be
   an instance of "PyLongObject".

   Raise "OverflowError" if the value of *pylong* is out of range for
   a "size_t".

   Returns "(size_t)-1" on error. Use "PyErr_Occurred()" to
   disambiguate.

unsigned long long PyLong_AsUnsignedLongLong(PyObject *pylong)
    * Part of the Stable ABI.*

   Return a C unsigned long long representation of *pylong*.  *pylong*
   must be an instance of "PyLongObject".

   Raise "OverflowError" if the value of *pylong* is out of range for
   an unsigned long long.

   Returns "(unsigned long long)-1" on error. Use "PyErr_Occurred()"
   to disambiguate.

   Changed in version 3.1: A negative *pylong* now raises
   "OverflowError", not "TypeError".

unsigned long PyLong_AsUnsignedLongMask(PyObject *obj)
    * Part of the Stable ABI.*

   Return a C unsigned long representation of *obj*.  If *obj* is not
   an instance of "PyLongObject", first call its "__index__()" method
   (if present) to convert it to a "PyLongObject".

   If the value of *obj* is out of range for an unsigned long, return
   the reduction of that value modulo "ULONG_MAX + 1".

   Returns "(unsigned long)-1" on error.  Use "PyErr_Occurred()" to
   disambiguate.

   Changed in version 3.8: Use "__index__()" if available.

   Changed in version 3.10: This function will no longer use
   "__int__()".

unsigned long long PyLong_AsUnsignedLongLongMask(PyObject *obj)
    * Part of the Stable ABI.*

   Return a C unsigned long long representation of *obj*.  If *obj* is
   not an instance of "PyLongObject", first call its "__index__()"
   method (if present) to convert it to a "PyLongObject".

   If the value of *obj* is out of range for an unsigned long long,
   return the reduction of that value modulo "ULLONG_MAX + 1".

   Returns "(unsigned long long)-1" on error.  Use "PyErr_Occurred()"
   to disambiguate.

   Changed in version 3.8: Use "__index__()" if available.

   Changed in version 3.10: This function will no longer use
   "__int__()".

double PyLong_AsDouble(PyObject *pylong)
    * Part of the Stable ABI.*

   Return a C double representation of *pylong*.  *pylong* must be an
   instance of "PyLongObject".

   Raise "OverflowError" if the value of *pylong* is out of range for
   a double.

   Returns "-1.0" on error.  Use "PyErr_Occurred()" to disambiguate.

void *PyLong_AsVoidPtr(PyObject *pylong)
    * Part of the Stable ABI.*

   Convert a Python integer *pylong* to a C void pointer. If *pylong*
   cannot be converted, an "OverflowError" will be raised.  This is
   only assured to produce a usable void pointer for values created
   with "PyLong_FromVoidPtr()".

   Returns "NULL" on error.  Use "PyErr_Occurred()" to disambiguate.

Py_ssize_t PyLong_AsNativeBytes(PyObject *pylong, void *buffer, Py_ssize_t n_bytes, int endianness)

   Copy the Python integer value to a native *buffer* of size
   *n_bytes*:

      int32_t value;
      Py_ssize_t bytes = PyLong_AsNativeBits(pylong, &value, sizeof(value), -1);
      if (bytes < 0) {
          // A Python exception was set with the reason.
          return NULL;
      }
      else if (bytes <= (Py_ssize_t)sizeof(value)) {
          // Success!
      }
      else {
          // Overflow occurred, but 'value' contains the truncated
          // lowest bits of pylong.
      }

   The above example may look *similar* to "PyLong_As*" but instead
   fills in a specific caller defined type and never raises an error
   about of the "int" *pylong*'s value regardless of *n_bytes* or the
   returned byte count.

   To get at the entire potentially big Python value, this can be used
   to reserve enough space and copy it:

      // Ask how much space we need.
      Py_ssize_t expected = PyLong_AsNativeBits(pylong, NULL, 0, -1);
      if (expected < 0) {
          // A Python exception was set with the reason.
          return NULL;
      }
      assert(expected != 0);  // Impossible per the API definition.
      uint8_t *bignum = malloc(expected);
      if (!bignum) {
          PyErr_SetString(PyExc_MemoryError, "bignum malloc failed.");
          return NULL;
      }
      // Safely get the entire value.
      Py_ssize_t bytes = PyLong_AsNativeBits(pylong, bignum, expected, -1);
      if (bytes < 0) {  // Exception set.
          free(bignum);
          return NULL;
      }
      else if (bytes > expected) {  // Be safe, should not be possible.
          PyErr_SetString(PyExc_RuntimeError,
              "Unexpected bignum truncation after a size check.");
          free(bignum);
          return NULL;
      }
      // The expected success given the above pre-check.
      // ... use bignum ...
      free(bignum);

   *endianness* may be passed "-1" for the native endian that CPython
   was compiled with, or "0" for big endian and "1" for little.

   Returns "-1" with an exception raised if *pylong* cannot be
   interpreted as an integer. Otherwise, return the size of the buffer
   required to store the value. If this is equal to or less than
   *n_bytes*, the entire value was copied. "0" will never be returned.

   Unless an exception is raised, all *n_bytes* of the buffer will
   always be written. In the case of truncation, as many of the lowest
   bits of the value as could fit are written. This allows the caller
   to ignore all non-negative results if the intent is to match the
   typical behavior of a C-style downcast. No exception is set on
   truncation.

   Values are always copied as two's-complement and sufficient buffer
   will be requested to include a sign bit. For example, this may
   cause an value that fits into 8 bytes when treated as unsigned to
   request 9 bytes, even though all eight bytes were copied into the
   buffer. What has been omitted is the zero sign bit -- redundant if
   the caller's intention is to treat the value as unsigned.

   Passing zero to *n_bytes* will return the size of a buffer that
   would be large enough to hold the value. This may be larger than
   technically necessary, but not unreasonably so.

   Note:

     Passing *n_bytes=0* to this function is not an accurate way to
     determine the bit length of a value.

   New in version 3.13.

int PyUnstable_Long_IsCompact(const PyLongObject *op)

   *This is Unstable API. It may change without warning in minor
   releases.*

   Return 1 if *op* is compact, 0 otherwise.

   This function makes it possible for performance-critical code to
   implement a “fast path” for small integers. For compact values use
   "PyUnstable_Long_CompactValue()"; for others fall back to a
   "PyLong_As*" function or "calling" "int.to_bytes()".

   The speedup is expected to be negligible for most users.

   Exactly what values are considered compact is an implementation
   detail and is subject to change.

Py_ssize_t PyUnstable_Long_CompactValue(const PyLongObject *op)

   *This is Unstable API. It may change without warning in minor
   releases.*

   If *op* is compact, as determined by "PyUnstable_Long_IsCompact()",
   return its value.

   Otherwise, the return value is undefined.
