Remove mentions of "long integer" in the docs.
Credits to HappySmileMan from GHOP.
diff --git a/Doc/library/_winreg.rst b/Doc/library/_winreg.rst
index 033446f..1a384fe 100644
--- a/Doc/library/_winreg.rst
+++ b/Doc/library/_winreg.rst
@@ -219,7 +219,7 @@
| ``1`` | An integer giving the number of values this |
| | key has. |
+-------+---------------------------------------------+
- | ``2`` | A long integer giving when the key was last |
+ | ``2`` | An integer giving when the key was last |
| | modified (if available) as 100's of |
| | nanoseconds since Jan 1, 1600. |
+-------+---------------------------------------------+
diff --git a/Doc/library/array.rst b/Doc/library/array.rst
index 4747b63..e86d0cc 100644
--- a/Doc/library/array.rst
+++ b/Doc/library/array.rst
@@ -45,10 +45,7 @@
The actual representation of values is determined by the machine architecture
(strictly speaking, by the C implementation). The actual size can be accessed
-through the :attr:`itemsize` attribute. The values stored for ``'L'`` and
-``'I'`` items will be represented as Python long integers when retrieved,
-because Python's plain integer type cannot represent the full range of C's
-unsigned (long) integers.
+through the :attr:`itemsize` attribute.
The module defines the following type:
diff --git a/Doc/library/bz2.rst b/Doc/library/bz2.rst
index ff3c773..ac1695b 100644
--- a/Doc/library/bz2.rst
+++ b/Doc/library/bz2.rst
@@ -99,7 +99,7 @@
.. method:: BZ2File.tell()
- Return the current file position, an integer (may be a long integer).
+ Return the current file position, an integer.
.. method:: BZ2File.write(data)
diff --git a/Doc/library/easydialogs.rst b/Doc/library/easydialogs.rst
index dbc996c..2a3b66b 100644
--- a/Doc/library/easydialogs.rst
+++ b/Doc/library/easydialogs.rst
@@ -160,14 +160,14 @@
.. attribute:: ProgressBar.curval
- The current value (of type integer or long integer) of the progress bar. The
+ The current value (of type integer) of the progress bar. The
normal access methods coerce :attr:`curval` between ``0`` and :attr:`maxval`.
This attribute should not be altered directly.
.. attribute:: ProgressBar.maxval
- The maximum value (of type integer or long integer) of the progress bar; the
+ The maximum value (of type integer) of the progress bar; the
progress bar (thermometer style) is full when :attr:`curval` equals
:attr:`maxval`. If :attr:`maxval` is ``0``, the bar will be indeterminate
(barber-pole). This attribute should not be altered directly.
diff --git a/Doc/library/exceptions.rst b/Doc/library/exceptions.rst
index 9453b7a..5620b1b 100644
--- a/Doc/library/exceptions.rst
+++ b/Doc/library/exceptions.rst
@@ -217,7 +217,7 @@
.. exception:: OverflowError
Raised when the result of an arithmetic operation is too large to be
- represented. This cannot occur for long integers (which would rather raise
+ represented. This cannot occur for integers (which would rather raise
:exc:`MemoryError` than give up). Because of the lack of standardization of
floating point exception handling in C, most floating point operations also
aren't checked.
diff --git a/Doc/library/functions.rst b/Doc/library/functions.rst
index 08566fa..4236253 100644
--- a/Doc/library/functions.rst
+++ b/Doc/library/functions.rst
@@ -65,7 +65,7 @@
.. function:: abs(x)
- Return the absolute value of a number. The argument may be a plain or long
+ Return the absolute value of a number. The argument may be an
integer or a floating point number. If the argument is a complex number, its
magnitude is returned.
@@ -320,8 +320,8 @@
Take two (non complex) numbers as arguments and return a pair of numbers
consisting of their quotient and remainder when using long division. With mixed
- operand types, the rules for binary arithmetic operators apply. For plain and
- long integers, the result is the same as ``(a // b, a % b)``. For floating point
+ operand types, the rules for binary arithmetic operators apply. For integers,
+ the result is the same as ``(a // b, a % b)``. For floating point
numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a / b)``
but may be 1 less than that. In any case ``q * b + a % b`` is very close to
*a*, if ``a % b`` is non-zero it has the same sign as *b*, and ``0 <= abs(a % b)
@@ -435,7 +435,7 @@
Convert a string or a number to floating point. If the argument is a string, it
must contain a possibly signed decimal or floating point number, possibly
- embedded in whitespace. Otherwise, the argument may be a plain or long integer
+ embedded in whitespace. Otherwise, the argument may be an integer
or a floating point number, and a floating point number with the same value
(within Python's floating point precision) is returned. If no argument is
given, returns ``0.0``.
@@ -530,7 +530,7 @@
.. function:: id(object)
- Return the "identity" of an object. This is an integer (or long integer) which
+ Return the "identity" of an object. This is an integer which
is guaranteed to be unique and constant for this object during its lifetime.
Two objects with non-overlapping lifetimes may have the same :func:`id` value.
(Implementation note: this is the address of the object.)
@@ -783,7 +783,7 @@
form ``pow(x, y)`` is equivalent to using the power operator: ``x**y``.
The arguments must have numeric types. With mixed operand types, the coercion
- rules for binary arithmetic operators apply. For int and long int operands, the
+ rules for binary arithmetic operators apply. For :class:`int` operands, the
result has the same type as the operands (after coercion) unless the second
argument is negative; in that case, all arguments are converted to float and a
float result is delivered. For example, ``10**2`` returns ``100``, but
diff --git a/Doc/library/marshal.rst b/Doc/library/marshal.rst
index bc43184..8f669b2 100644
--- a/Doc/library/marshal.rst
+++ b/Doc/library/marshal.rst
@@ -37,24 +37,13 @@
Not all Python object types are supported; in general, only objects whose value
is independent from a particular invocation of Python can be written and read by
-this module. The following types are supported: ``None``, integers, long
-integers, floating point numbers, strings, Unicode objects, tuples, lists, sets,
+this module. The following types are supported: ``None``, integers,
+floating point numbers, strings, Unicode objects, tuples, lists, sets,
dictionaries, and code objects, where it should be understood that tuples, lists
and dictionaries are only supported as long as the values contained therein are
themselves supported; and recursive lists and dictionaries should not be written
(they will cause infinite loops).
-.. warning::
-
- On machines where C's ``long int`` type has more than 32 bits (such as the
- DEC Alpha), it is possible to create plain Python integers that are longer
- than 32 bits. If such an integer is marshaled and read back in on a machine
- where C's ``long int`` type has only 32 bits, a Python long integer object
- is returned instead. While of a different type, the numeric value is the
- same. (This behavior is new in Python 2.2. In earlier versions, all but the
- least-significant 32 bits of the value were lost, and a warning message was
- printed.)
-
There are functions that read/write files as well as functions operating on
strings.
diff --git a/Doc/library/pickle.rst b/Doc/library/pickle.rst
index e186937..c88fc29 100644
--- a/Doc/library/pickle.rst
+++ b/Doc/library/pickle.rst
@@ -328,7 +328,7 @@
* ``None``, ``True``, and ``False``
-* integers, long integers, floating point numbers, complex numbers
+* integers, floating point numbers, complex numbers
* normal and Unicode strings
diff --git a/Doc/library/repr.rst b/Doc/library/repr.rst
index 0ad08c6..3f7fc22 100644
--- a/Doc/library/repr.rst
+++ b/Doc/library/repr.rst
@@ -65,7 +65,7 @@
.. 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``.
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 4f09205..e94560b 100644
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -246,7 +246,6 @@
.. index::
single: arithmetic
builtin: int
- builtin: long
builtin: float
builtin: complex
@@ -326,7 +325,7 @@
pair: numeric; conversions
pair: C; language
- Conversion from floating point to (long or plain) integer may round or truncate
+ Conversion from floating point to integer may round or truncate
as in C; see functions :func:`floor` and :func:`ceil` in the :mod:`math` module
for well-defined conversions.
diff --git a/Doc/library/struct.rst b/Doc/library/struct.rst
index b28f9b4..9e527f1 100644
--- a/Doc/library/struct.rst
+++ b/Doc/library/struct.rst
@@ -81,15 +81,15 @@
+--------+-------------------------+--------------------+-------+
| ``i`` | :ctype:`int` | integer | |
+--------+-------------------------+--------------------+-------+
-| ``I`` | :ctype:`unsigned int` | long | |
+| ``I`` | :ctype:`unsigned int` | integer | |
+--------+-------------------------+--------------------+-------+
| ``l`` | :ctype:`long` | integer | |
+--------+-------------------------+--------------------+-------+
-| ``L`` | :ctype:`unsigned long` | long | |
+| ``L`` | :ctype:`unsigned long` | integer | |
+--------+-------------------------+--------------------+-------+
-| ``q`` | :ctype:`long long` | long | \(2) |
+| ``q`` | :ctype:`long long` | integer | \(2) |
+--------+-------------------------+--------------------+-------+
-| ``Q`` | :ctype:`unsigned long | long | \(2) |
+| ``Q`` | :ctype:`unsigned long | integer | \(2) |
| | long` | | |
+--------+-------------------------+--------------------+-------+
| ``f`` | :ctype:`float` | float | |
@@ -139,16 +139,7 @@
used. Note that for :func:`unpack`, the ``'p'`` format character consumes count
bytes, but that the string returned can never contain more than 255 characters.
-For the ``'I'``, ``'L'``, ``'q'`` and ``'Q'`` format characters, the return
-value is a Python long integer.
-For the ``'P'`` format character, the return value is a Python integer or long
-integer, depending on the size needed to hold a pointer when it has been cast to
-an integer type. A *NULL* pointer will always be returned as the Python integer
-``0``. When packing pointer-sized values, Python integer or long integer objects
-may be used. For example, the Alpha and Merced processors use 64-bit pointer
-values, meaning a Python long integer will be used to hold the pointer; other
-platforms use 32-bit pointers and will use a Python integer.
For the ``'t'`` format character, the return value is either :const:`True` or
:const:`False`. When packing, the truth value of the argument object is used.