Issue #18783: Removed existing mentions of Python long type in docstrings,

error messages and comments.

Doc/library/msilib.rst

@@ -88,8 +88,7 @@ structures.
    record according to the schema of the table.  For optional fields,
    ``None`` can be passed.
 
-   Field values can be int or long numbers, strings, or instances of the Binary
+   Field values can be ints, strings, or instances of the Binary class.
-   class.
 
 
 .. class:: Binary(filename)

Include/abstract.h

@@ -771,7 +771,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
      PyAPI_FUNC(PyObject *) PyNumber_Index(PyObject *o);
 
        /*
-     Returns the object converted to a Python long or int
+     Returns the object converted to a Python int
      or NULL with an error raised on failure.
        */
 
@@ -780,7 +780,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        /*
     Returns the object converted to Py_ssize_t by going through
     PyNumber_Index first.  If an overflow error occurs while
-    converting the int-or-long to Py_ssize_t, then the second argument
+    converting the int to Py_ssize_t, then the second argument
     is the error-type to return.  If it is NULL, then the overflow error
     is cleared and the value is clipped.
        */

Include/longintrepr.h

@@ -8,7 +8,7 @@ extern "C" {
 
 /* This is published for the benefit of "friends" marshal.c and _decimal.c. */
 
-/* Parameters of the long integer representation.  There are two different
+/* Parameters of the integer representation.  There are two different
    sets of parameters: one set for 30-bit digits, stored in an unsigned 32-bit
    integer type, and one set for 15-bit digits with each digit stored in an
    unsigned short.  The value of PYLONG_BITS_IN_DIGIT, defined either at
@@ -29,7 +29,7 @@ extern "C" {
      of bits in an unsigned long, as do the PyLong <-> long (or unsigned long)
      conversion functions
 
-   - the long <-> size_t/Py_ssize_t conversion functions expect that
+   - the Python int <-> size_t/Py_ssize_t conversion functions expect that
      PyLong_SHIFT is strictly less than the number of bits in a size_t
 
    - the marshal code currently expects that PyLong_SHIFT is a multiple of 15
@@ -83,7 +83,7 @@ typedef long stwodigits; /* signed variant of twodigits */
    so that ob_digit[0] ... ob_digit[abs(ob_size)-1] are actually available.
 
    CAUTION:  Generic code manipulating subtypes of PyVarObject has to
-   aware that longs abuse  ob_size's sign bit.
+   aware that ints abuse  ob_size's sign bit.
 */
 
 struct _longobject {

Include/longobject.h

@@ -113,7 +113,7 @@ PyAPI_FUNC(size_t) _PyLong_NumBits(PyObject *v);
 PyAPI_FUNC(PyObject *) _PyLong_DivmodNear(PyObject *, PyObject *);
 
 /* _PyLong_FromByteArray:  View the n unsigned bytes as a binary integer in
-   base 256, and return a Python long with the same numeric value.
+   base 256, and return a Python int with the same numeric value.
    If n is 0, the integer is 0.  Else:
    If little_endian is 1/true, bytes[n-1] is the MSB and bytes[0] the LSB;
    else (little_endian is 0/false) bytes[0] is the MSB and bytes[n-1] the
@@ -123,7 +123,7 @@ PyAPI_FUNC(PyObject *) _PyLong_DivmodNear(PyObject *, PyObject *);
    non-negative if bit 0x80 of the MSB is clear, negative if set.
    Error returns:
    + Return NULL with the appropriate exception set if there's not
-     enough memory to create the Python long.
+     enough memory to create the Python int.
 */
 PyAPI_FUNC(PyObject *) _PyLong_FromByteArray(
     const unsigned char* bytes, size_t n,
@@ -173,7 +173,7 @@ PyAPI_FUNC(int) _PyLong_FormatAdvancedWriter(
     Py_ssize_t end);
 #endif /* Py_LIMITED_API */
 
-/* These aren't really part of the long object, but they're handy. The
+/* These aren't really part of the int object, but they're handy. The
    functions are in Python/mystrtoul.c.
  */
 PyAPI_FUNC(unsigned long) PyOS_strtoul(char *, char **, int);

Include/objimpl.h

@@ -171,7 +171,7 @@ PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
    value is rounded up to the closest multiple of sizeof(void *), in order to
    ensure that pointer fields at the end of the object are correctly aligned
    for the platform (this is of special importance for subclasses of, e.g.,
-   str or long, so that pointers can be stored after the embedded data).
+   str or int, so that pointers can be stored after the embedded data).
 
    Note that there's no memory wastage in doing this, as malloc has to
    return (at worst) pointer-aligned memory anyway.

Include/pyport.h

@@ -80,7 +80,7 @@ Used in:  PY_LONG_LONG
 #endif
 #endif /* HAVE_LONG_LONG */
 
-/* a build with 30-bit digits for Python long integers needs an exact-width
+/* a build with 30-bit digits for Python integers needs an exact-width
  * 32-bit unsigned integer type to store those digits.  (We could just use
  * type 'unsigned long', but that would be wasteful on a system where longs
  * are 64-bits.)  On Unix systems, the autoconf macro AC_TYPE_UINT32_T defines
@@ -98,7 +98,7 @@ Used in:  PY_LONG_LONG
 #endif
 
 /* Macros for a 64-bit unsigned integer type; used for type 'twodigits' in the
- * long integer implementation, when 30-bit digits are enabled.
+ * integer implementation, when 30-bit digits are enabled.
  */
 #ifdef uint64_t
 #define HAVE_UINT64_T 1

Lib/ctypes/test/test_numbers.py

@@ -104,7 +104,7 @@ class NumberTestCase(unittest.TestCase):
 
     def test_floats(self):
         # c_float and c_double can be created from
-        # Python int, long and float
+        # Python int and float
         class FloatLike(object):
             def __float__(self):
                 return 2.0

Lib/datetime.py

@@ -287,7 +287,7 @@ class timedelta:
     - add, subtract timedelta
     - unary plus, minus, abs
     - compare to timedelta
-    - multiply, divide by int/long
+    - multiply, divide by int
 
     In addition, datetime supports subtraction of two datetime objects
     returning a timedelta, and addition or subtraction of a datetime
@@ -1290,7 +1290,7 @@ class datetime(date):
     """datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])
 
     The year, month and day arguments are required. tzinfo may be None, or an
-    instance of a tzinfo subclass. The remaining arguments may be ints or longs.
+    instance of a tzinfo subclass. The remaining arguments may be ints.
     """
 
     __slots__ = date.__slots__ + (

Lib/pickle.py

@@ -1270,7 +1270,7 @@ class _Unpickler:
         raise _Stop(value)
     dispatch[STOP[0]] = load_stop
 
-# Encode/decode longs.
+# Encode/decode ints.
 
 def encode_long(x):
     r"""Encode a long to a two's complement little-endian binary string.
@@ -1303,7 +1303,7 @@ def encode_long(x):
     return result
 
 def decode_long(data):
-    r"""Decode a long from a two's complement little-endian binary string.
+    r"""Decode an int from a two's complement little-endian binary string.
 
     >>> decode_long(b'')
     0

Lib/pickletools.py

@@ -580,16 +580,12 @@ def read_decimalnl_short(f):
     >>> read_decimalnl_short(io.BytesIO(b"1234L\n56"))
     Traceback (most recent call last):
     ...
-    ValueError: trailing 'L' not allowed in b'1234L'
+    ValueError: invalid literal for int() with base 10: b'1234L'
     """
 
     s = read_stringnl(f, decode=False, stripquotes=False)
-    if s.endswith(b"L"):
-        raise ValueError("trailing 'L' not allowed in %r" % s)
 
-    # It's not necessarily true that the result fits in a Python short int:
+    # There's a hack for True and False here.
-    # the pickle may have been written on a 64-bit box.  There's also a hack
-    # for True and False here.
     if s == b"00":
         return False
     elif s == b"01":

Lib/random.py

@@ -633,7 +633,7 @@ class SystemRandom(Random):
         return (int.from_bytes(_urandom(7), 'big') >> 3) * RECIP_BPF
 
     def getrandbits(self, k):
-        """getrandbits(k) -> x.  Generates a long int with k random bits."""
+        """getrandbits(k) -> x.  Generates an int with k random bits."""
         if k <= 0:
             raise ValueError('number of bits must be greater than zero')
         if k != int(k):

Lib/test/test_cmath.py

@@ -253,7 +253,7 @@ class CMathTests(unittest.TestCase):
             self.assertRaises(SomeException, f, MyComplexExceptionOS())
 
     def test_input_type(self):
-        # ints and longs should be acceptable inputs to all cmath
+        # ints should be acceptable inputs to all cmath
         # functions, by virtue of providing a __float__ method
         for f in self.test_functions:
             for arg in [2, 2.]:

Lib/test/test_compile.py

@@ -198,7 +198,7 @@ if 1:
         else:
             self.fail("How many bits *does* this machine have???")
         # Verify treatment of constant folding on -(sys.maxsize+1)
-        # i.e. -2147483648 on 32 bit platforms.  Should return int, not long.
+        # i.e. -2147483648 on 32 bit platforms.  Should return int.
         self.assertIsInstance(eval("%s" % (-sys.maxsize - 1)), int)
         self.assertIsInstance(eval("%s" % (-sys.maxsize - 2)), int)
 

Lib/test/test_decimal.py

@@ -1838,7 +1838,7 @@ class UsabilityTest(unittest.TestCase):
         self.assertIs(max(d1,d2), d2)
         self.assertIs(max(d2,d1), d2)
 
-        #between Decimal and long
+        #between Decimal and int
         self.assertIs(min(d1,l2), d1)
         self.assertIs(min(l2,d1), d1)
         self.assertIs(max(l1,d2), d2)

Lib/test/test_gdb.py

@@ -227,7 +227,7 @@ class PrettyPrintTests(DebuggerTests):
                           % (gdb_repr, exp_repr, gdb_output)))
 
     def test_int(self):
-        'Verify the pretty-printing of various "int"/long values'
+        'Verify the pretty-printing of various int values'
         self.assertGdbRepr(42)
         self.assertGdbRepr(0)
         self.assertGdbRepr(-7)

Lib/test/test_itertools.py

@@ -505,9 +505,9 @@ class TestBasicOps(unittest.TestCase):
         self.assertEqual(repr(count(10.25)), 'count(10.25)')
         self.assertEqual(next(c), -8)
         for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
-            # Test repr (ignoring the L in longs)
+            # Test repr
-            r1 = repr(count(i)).replace('L', '')
+            r1 = repr(count(i))
-            r2 = 'count(%r)'.__mod__(i).replace('L', '')
+            r2 = 'count(%r)'.__mod__(i)
             self.assertEqual(r1, r2)
 
         # check copy, deepcopy, pickle
@@ -555,12 +555,12 @@ class TestBasicOps(unittest.TestCase):
         self.assertEqual(repr(count(10.5, 1.00)), 'count(10.5, 1.0)')   # do show float values lilke 1.0
         for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
             for j in  (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 1, 10, sys.maxsize-5, sys.maxsize+5):
-                # Test repr (ignoring the L in longs)
+                # Test repr
-                r1 = repr(count(i, j)).replace('L', '')
+                r1 = repr(count(i, j))
                 if j == 1:
-                    r2 = ('count(%r)' % i).replace('L', '')
+                    r2 = ('count(%r)' % i)
                 else:
-                    r2 = ('count(%r, %r)' % (i, j)).replace('L', '')
+                    r2 = ('count(%r, %r)' % (i, j))
                 self.assertEqual(r1, r2)
                 self.pickletest(count(i, j))
 

Lib/test/test_long.py

@@ -322,20 +322,13 @@ class LongTest(unittest.TestCase):
                "".join("0123456789abcdef"[i] for i in digits)
 
     def check_format_1(self, x):
-        for base, mapper in (8, oct), (10, repr), (16, hex):
+        for base, mapper in (2, bin), (8, oct), (10, str), (10, repr), (16, hex):
             got = mapper(x)
             expected = self.slow_format(x, base)
             msg = Frm("%s returned %r but expected %r for %r",
                 mapper.__name__, got, expected, x)
             self.assertEqual(got, expected, msg)
             self.assertEqual(int(got, 0), x, Frm('int("%s", 0) != %r', got, x))
-        # str() has to be checked a little differently since there's no
-        # trailing "L"
-        got = str(x)
-        expected = self.slow_format(x, 10)
-        msg = Frm("%s returned %r but expected %r for %r",
-            mapper.__name__, got, expected, x)
-        self.assertEqual(got, expected, msg)
 
     def test_format(self):
         for x in special:
@@ -553,11 +546,11 @@ class LongTest(unittest.TestCase):
     def test_mixed_compares(self):
         eq = self.assertEqual
 
-        # We're mostly concerned with that mixing floats and longs does the
+        # We're mostly concerned with that mixing floats and ints does the
-        # right stuff, even when longs are too large to fit in a float.
+        # right stuff, even when ints are too large to fit in a float.
         # The safest way to check the results is to use an entirely different
         # method, which we do here via a skeletal rational class (which
-        # represents all Python ints, longs and floats exactly).
+        # represents all Python ints and floats exactly).
         class Rat:
             def __init__(self, value):
                 if isinstance(value, int):

Lib/test/test_struct.py

@@ -278,7 +278,7 @@ class StructTest(unittest.TestCase):
 
                 # Objects with an '__index__' method should be allowed
                 # to pack as integers.  That is assuming the implemented
-                # '__index__' method returns and 'int' or 'long'.
+                # '__index__' method returns an 'int'.
                 class Indexable(object):
                     def __init__(self, value):
                         self._value = value

Lib/test/test_sys.py

@@ -767,7 +767,7 @@ class SizeofTest(unittest.TestCase):
         check(iter([]), size('lP'))
         # listreverseiterator (list)
         check(reversed([]), size('nP'))
-        # long
+        # int
         check(0, vsize(''))
         check(1, vsize('') + self.longdigit)
         check(-1, vsize('') + self.longdigit)

Lib/xmlrpc/client.py

@@ -539,7 +539,7 @@ class Marshaller:
 
     def dump_long(self, value, write):
         if value > MAXINT or value < MININT:
-            raise OverflowError("long int exceeds XML-RPC limits")
+            raise OverflowError("int exceeds XML-RPC limits")
         write("<value><int>")
         write(str(int(value)))
         write("</int></value>\n")

Misc/NEWS

@@ -360,6 +360,9 @@ Tests
 Documentation
 -------------
 
+- Issue #18783: Removed existing mentions of Python long type in docstrings,
+  error messages and comments.
+
 - Issue #17701: Improving strftime documentation.
 
 - Issue #18440: Clarify that `hash()` can truncate the value returned from an

Modules/_ctypes/callproc.c

@@ -650,7 +650,7 @@ static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
             pa->value.i = PyLong_AsLong(obj);
             if (pa->value.i == -1 && PyErr_Occurred()) {
                 PyErr_SetString(PyExc_OverflowError,
-                                "long int too long to convert");
+                                "int too long to convert");
                 return -1;
             }
         }

Modules/_datetimemodule.c

@@ -1401,9 +1401,9 @@ static PyObject *us_per_us = NULL;      /* 1 */
 static PyObject *us_per_ms = NULL;      /* 1000 */
 static PyObject *us_per_second = NULL;  /* 1000000 */
 static PyObject *us_per_minute = NULL;  /* 1e6 * 60 as Python int */
-static PyObject *us_per_hour = NULL;    /* 1e6 * 3600 as Python long */
+static PyObject *us_per_hour = NULL;    /* 1e6 * 3600 as Python int */
-static PyObject *us_per_day = NULL;     /* 1e6 * 3600 * 24 as Python long */
+static PyObject *us_per_day = NULL;     /* 1e6 * 3600 * 24 as Python int */
-static PyObject *us_per_week = NULL;    /* 1e6*3600*24*7 as Python long */
+static PyObject *us_per_week = NULL;    /* 1e6*3600*24*7 as Python int */
 static PyObject *seconds_per_day = NULL; /* 3600*24 as Python int */
 
 /* ---------------------------------------------------------------------------
@@ -1416,7 +1416,7 @@ static PyObject *seconds_per_day = NULL; /* 3600*24 as Python int */
 
 /* Convert a timedelta to a number of us,
  *      (24*3600*self.days + self.seconds)*1000000 + self.microseconds
- * as a Python int or long.
+ * as a Python int.
  * Doing mixed-radix arithmetic by hand instead is excruciating in C,
  * due to ubiquitous overflow possibilities.
  */
@@ -1468,7 +1468,7 @@ Done:
     return result;
 }
 
-/* Convert a number of us (as a Python int or long) to a timedelta.
+/* Convert a number of us (as a Python int) to a timedelta.
  */
 static PyObject *
 microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type)
@@ -3886,7 +3886,7 @@ static char time_doc[] =
 PyDoc_STR("time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\
 \n\
 All arguments are optional. tzinfo may be None, or an instance of\n\
-a tzinfo subclass. The remaining arguments may be ints or longs.\n");
+a tzinfo subclass. The remaining arguments may be ints.\n");
 
 static PyNumberMethods time_as_number = {
     0,                                          /* nb_add */
@@ -5069,7 +5069,7 @@ static char datetime_doc[] =
 PyDoc_STR("datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\
 \n\
 The year, month and day arguments are required. tzinfo may be None, or an\n\
-instance of a tzinfo subclass. The remaining arguments may be ints or longs.\n");
+instance of a tzinfo subclass. The remaining arguments may be ints.\n");
 
 static PyNumberMethods datetime_as_number = {
     datetime_add,                               /* nb_add */

Modules/_pickle.c

@@ -387,8 +387,8 @@ static PyTypeObject Unpickler_Type;
 
 
 /*************************************************************************
- A custom hashtable mapping void* to longs. This is used by the pickler for
+ A custom hashtable mapping void* to Python ints. This is used by the pickler
- memoization. Using a custom hashtable rather than PyDict allows us to skip
+ for memoization. Using a custom hashtable rather than PyDict allows us to skip
  a bunch of unnecessary object creation. This makes a huge performance
  difference. */
 
@@ -1581,8 +1581,8 @@ save_long(PicklerObject *self, PyObject *obj)
          * need another byte even if there aren't any leftovers:
          * the most-significant bit of the most-significant byte
          * acts like a sign bit, and it's usually got a sense
-         * opposite of the one we need.  The exception is longs
+         * opposite of the one we need.  The exception is ints
-         * of the form -(2**(8*j-1)) for j > 0.  Such a long is
+         * of the form -(2**(8*j-1)) for j > 0.  Such an int is
          * its own 256's-complement, so has the right sign bit
          * even without the extra byte.  That's a pain to check
          * for in advance, though, so we always grab an extra
@@ -1591,7 +1591,7 @@ save_long(PicklerObject *self, PyObject *obj)
         nbytes = (nbits >> 3) + 1;
         if (nbytes > 0x7fffffffL) {
             PyErr_SetString(PyExc_OverflowError,
-                            "long too large to pickle");
+                            "int too large to pickle");
             goto error;
         }
         repr = PyBytes_FromStringAndSize(NULL, (Py_ssize_t)nbytes);
@@ -1603,7 +1603,7 @@ save_long(PicklerObject *self, PyObject *obj)
                                 1 /* little endian */ , 1 /* signed */ );
         if (i < 0)
             goto error;
-        /* If the long is negative, this may be a byte more than
+        /* If the int is negative, this may be a byte more than
          * needed.  This is so iff the MSB is all redundant sign
          * bits.
          */
@@ -3917,7 +3917,7 @@ load_int(UnpicklerObject *self)
 
     if (errno || (*endptr != '\n' && *endptr != '\0')) {
         /* Hm, maybe we've got something long.  Let's try reading
-         * it as a Python long object. */
+         * it as a Python int object. */
         errno = 0;
         /* XXX: Same thing about the base here. */
         value = PyLong_FromString(s, NULL, 0);

Modules/_randommodule.c

@@ -444,7 +444,7 @@ static PyMethodDef random_methods[] = {
     {"setstate",          (PyCFunction)random_setstate,  METH_O,
         PyDoc_STR("setstate(state) -> None.  Restores generator state.")},
     {"getrandbits",     (PyCFunction)random_getrandbits,  METH_VARARGS,
-        PyDoc_STR("getrandbits(k) -> x.  Generates a long int with "
+        PyDoc_STR("getrandbits(k) -> x.  Generates an int with "
                   "k random bits.")},
     {NULL,              NULL}           /* sentinel */
 };

Modules/_struct.c

@@ -1631,7 +1631,7 @@ s_pack_internal(PyStructObject *soself, PyObject *args, int offset, char* buf)
             if (e->pack(res, v, e) < 0) {
                 if (PyLong_Check(v) && PyErr_ExceptionMatches(PyExc_OverflowError))
                     PyErr_SetString(StructError,
-                                    "long too large to convert to int");
+                                    "int too large to convert");
                 return -1;
             }
         }

Modules/_testcapimodule.c

@@ -1635,7 +1635,7 @@ test_long_numbits(PyObject *self)
                      {-3L, 2, -1},
                      {4L, 3, 1},
                      {-4L, 3, -1},
-                     {0x7fffL, 15, 1},          /* one Python long digit */
+                     {0x7fffL, 15, 1},          /* one Python int digit */
              {-0x7fffL, 15, -1},
              {0xffffL, 16, 1},
              {-0xffffL, 16, -1},

Modules/mathmodule.c

@@ -1535,8 +1535,7 @@ math_ldexp(PyObject *self, PyObject *args)
     }
     else {
         PyErr_SetString(PyExc_TypeError,
-                        "Expected an int or long as second argument "
+                        "Expected an int as second argument to ldexp.");
-                        "to ldexp.");
         return NULL;
     }
 
@@ -1598,19 +1597,19 @@ PyDoc_STRVAR(math_modf_doc,
 "Return the fractional and integer parts of x.  Both results carry the sign\n"
 "of x and are floats.");
 
-/* A decent logarithm is easy to compute even for huge longs, but libm can't
+/* A decent logarithm is easy to compute even for huge ints, but libm can't
    do that by itself -- loghelper can.  func is log or log10, and name is
-   "log" or "log10".  Note that overflow of the result isn't possible: a long
+   "log" or "log10".  Note that overflow of the result isn't possible: an int
    can contain no more than INT_MAX * SHIFT bits, so has value certainly less
    than 2**(2**64 * 2**16) == 2**2**80, and log2 of that is 2**80, which is
    small enough to fit in an IEEE single.  log and log10 are even smaller.
-   However, intermediate overflow is possible for a long if the number of bits
+   However, intermediate overflow is possible for an int if the number of bits
-   in that long is larger than PY_SSIZE_T_MAX. */
+   in that int is larger than PY_SSIZE_T_MAX. */
 
 static PyObject*
 loghelper(PyObject* arg, double (*func)(double), char *funcname)
 {
-    /* If it is long, do it ourselves. */
+    /* If it is int, do it ourselves. */
     if (PyLong_Check(arg)) {
         double x, result;
         Py_ssize_t e;

Modules/socketmodule.c

@@ -4693,14 +4693,14 @@ socket_ntohl(PyObject *self, PyObject *arg)
             y = x & 0xFFFFFFFFUL;
             if (y ^ x)
                 return PyErr_Format(PyExc_OverflowError,
-                            "long int larger than 32 bits");
+                            "int larger than 32 bits");
             x = y;
         }
 #endif
     }
     else
         return PyErr_Format(PyExc_TypeError,
-                            "expected int/long, %s found",
+                            "expected int, %s found",
                             Py_TYPE(arg)->tp_name);
     return PyLong_FromUnsignedLong(ntohl(x));
 }
@@ -4750,14 +4750,14 @@ socket_htonl(PyObject *self, PyObject *arg)
             y = x & 0xFFFFFFFFUL;
             if (y ^ x)
                 return PyErr_Format(PyExc_OverflowError,
-                            "long int larger than 32 bits");
+                            "int larger than 32 bits");
             x = y;
         }
 #endif
     }
     else
         return PyErr_Format(PyExc_TypeError,
-                            "expected int/long, %s found",
+                            "expected int, %s found",
                             Py_TYPE(arg)->tp_name);
     return PyLong_FromUnsignedLong(htonl((unsigned long)x));
 }

Objects/abstract.c

@@ -1132,8 +1132,8 @@ PyNumber_Absolute(PyObject *o)
     return type_error("bad operand type for abs(): '%.200s'", o);
 }
 
-/* Return a Python Int or Long from the object item
+/* Return a Python int from the object item
-   Raise TypeError if the result is not an int-or-long
+   Raise TypeError if the result is not an int
    or if the object cannot be interpreted as an index.
 */
 PyObject *
@@ -1343,8 +1343,7 @@ PyNumber_ToBase(PyObject *n, int base)
         /* It should not be possible to get here, as
            PyNumber_Index already has a check for the same
            condition */
-        PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not "
+        PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not int");
-                        "int or long");
     Py_DECREF(index);
     return res;
 }

Objects/fileobject.c

@@ -186,9 +186,9 @@ PyFile_WriteString(const char *s, PyObject *f)
 }
 
 /* Try to get a file-descriptor from a Python object.  If the object
-   is an integer or long integer, its value is returned.  If not, the
+   is an integer, its value is returned.  If not, the
    object's fileno() method is called if it exists; the method must return
-   an integer or long integer, which is returned as the file descriptor value.
+   an integer, which is returned as the file descriptor value.
    -1 is returned on failure.
 */
 

Objects/floatobject.c

@@ -232,7 +232,7 @@ PyFloat_AsDouble(PyObject *op)
 /* Macro and helper that convert PyObject obj to a C double and store
    the value in dbl.  If conversion to double raises an exception, obj is
    set to NULL, and the function invoking this macro returns NULL.  If
-   obj is not of float, int or long type, Py_NotImplemented is incref'ed,
+   obj is not of float or int type, Py_NotImplemented is incref'ed,
    stored in obj, and returned from the function invoking this macro.
 */
 #define CONVERT_TO_DOUBLE(obj, dbl)                     \
@@ -287,7 +287,7 @@ float_repr(PyFloatObject *v)
  * When mixing float with an integer type, there's no good *uniform* approach.
  * Converting the double to an integer obviously doesn't work, since we
  * may lose info from fractional bits.  Converting the integer to a double
- * also has two failure modes:  (1) a long int may trigger overflow (too
+ * also has two failure modes:  (1) an int may trigger overflow (too
  * large to fit in the dynamic range of a C double); (2) even a C long may have
  * more bits than fit in a C double (e.g., on a 64-bit box long may have
  * 63 bits of precision, but a C double probably has only 53), and then
@@ -385,7 +385,7 @@ float_richcompare(PyObject *v, PyObject *w, int op)
             goto Compare;
         }
         /* v and w have the same number of bits before the radix
-         * point.  Construct two longs that have the same comparison
+         * point.  Construct two ints that have the same comparison
          * outcome.
          */
         {
@@ -450,7 +450,7 @@ float_richcompare(PyObject *v, PyObject *w, int op)
         }
     } /* else if (PyLong_Check(w)) */
 
-    else        /* w isn't float, int, or long */
+    else        /* w isn't float or int */
         goto Unimplemented;
 
  Compare:

Objects/longobject.c

@@ -68,16 +68,16 @@ maybe_small_long(PyLongObject *v)
 #define maybe_small_long(val) (val)
 #endif
 
-/* If a freshly-allocated long is already shared, it must
+/* If a freshly-allocated int is already shared, it must
    be a small integer, so negating it must go to PyLong_FromLong */
 #define NEGATE(x) \
     do if (Py_REFCNT(x) == 1) Py_SIZE(x) = -Py_SIZE(x);  \
        else { PyObject* tmp=PyLong_FromLong(-MEDIUM_VALUE(x));  \
            Py_DECREF(x); (x) = (PyLongObject*)tmp; }               \
     while(0)
-/* For long multiplication, use the O(N**2) school algorithm unless
+/* For int multiplication, use the O(N**2) school algorithm unless
  * both operands contain more than KARATSUBA_CUTOFF digits (this
- * being an internal Python long digit, in base BASE).
+ * being an internal Python int digit, in base BASE).
  */
 #define KARATSUBA_CUTOFF 70
 #define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF)
@@ -99,7 +99,7 @@ maybe_small_long(PyLongObject *v)
         if (PyErr_CheckSignals()) PyTryBlock    \
     } while(0)
 
-/* Normalize (remove leading zeros from) a long int object.
+/* Normalize (remove leading zeros from) an int object.
    Doesn't attempt to free the storage--in most cases, due to the nature
    of the algorithms used, this could save at most be one word anyway. */
 
@@ -116,7 +116,7 @@ long_normalize(register PyLongObject *v)
     return v;
 }
 
-/* Allocate a new long int object with size digits.
+/* Allocate a new int object with size digits.
    Return NULL and set exception if we run out of memory. */
 
 #define MAX_LONG_DIGITS \
@@ -168,7 +168,7 @@ _PyLong_Copy(PyLongObject *src)
     return (PyObject *)result;
 }
 
-/* Create a new long int object from a C long int */
+/* Create a new int object from a C long int */
 
 PyObject *
 PyLong_FromLong(long ival)
@@ -237,7 +237,7 @@ PyLong_FromLong(long ival)
     return (PyObject *)v;
 }
 
-/* Create a new long int object from a C unsigned long int */
+/* Create a new int object from a C unsigned long int */
 
 PyObject *
 PyLong_FromUnsignedLong(unsigned long ival)
@@ -266,7 +266,7 @@ PyLong_FromUnsignedLong(unsigned long ival)
     return (PyObject *)v;
 }
 
-/* Create a new long int object from a C double */
+/* Create a new int object from a C double */
 
 PyObject *
 PyLong_FromDouble(double dval)
@@ -320,7 +320,7 @@ PyLong_FromDouble(double dval)
 #define PY_ABS_LONG_MIN         (0-(unsigned long)LONG_MIN)
 #define PY_ABS_SSIZE_T_MIN      (0-(size_t)PY_SSIZE_T_MIN)
 
-/* Get a C long int from a long int object or any object that has an __int__
+/* Get a C long int from an int object or any object that has an __int__
    method.
 
    On overflow, return -1 and set *overflow to 1 or -1 depending on the sign of
@@ -417,7 +417,7 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow)
     return res;
 }
 
-/* Get a C long int from a long int object or any object that has an __int__
+/* Get a C long int from an int object or any object that has an __int__
    method.  Return -1 and set an error if overflow occurs. */
 
 long
@@ -434,7 +434,7 @@ PyLong_AsLong(PyObject *obj)
     return result;
 }
 
-/* Get a C int from a long int object or any object that has an __int__
+/* Get a C int from an int object or any object that has an __int__
    method.  Return -1 and set an error if overflow occurs. */
 
 int
@@ -452,7 +452,7 @@ _PyLong_AsInt(PyObject *obj)
     return (int)result;
 }
 
-/* Get a Py_ssize_t from a long int object.
+/* Get a Py_ssize_t from an int object.
    Returns -1 and sets an error condition if overflow occurs. */
 
 Py_ssize_t
@@ -507,7 +507,7 @@ PyLong_AsSsize_t(PyObject *vv) {
     return -1;
 }
 
-/* Get a C unsigned long int from a long int object.
+/* Get a C unsigned long int from an int object.
    Returns -1 and sets an error condition if overflow occurs. */
 
 unsigned long
@@ -551,7 +551,7 @@ PyLong_AsUnsignedLong(PyObject *vv)
     return x;
 }
 
-/* Get a C size_t from a long int object. Returns (size_t)-1 and sets
+/* Get a C size_t from an int object. Returns (size_t)-1 and sets
    an error condition if overflow occurs. */
 
 size_t
@@ -594,7 +594,7 @@ PyLong_AsSize_t(PyObject *vv)
     return x;
 }
 
-/* Get a C unsigned long int from a long int object, ignoring the high bits.
+/* Get a C unsigned long int from an int object, ignoring the high bits.
    Returns -1 and sets an error condition if an error occurs. */
 
 static unsigned long
@@ -712,7 +712,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
     int incr;                           /* direction to move pstartbyte */
     const unsigned char* pendbyte;      /* MSB of bytes */
     size_t numsignificantbytes;         /* number of bytes that matter */
-    Py_ssize_t ndigits;                 /* number of Python long digits */
+    Py_ssize_t ndigits;                 /* number of Python int digits */
     PyLongObject* v;                    /* result */
     Py_ssize_t idigit = 0;              /* next free index in v->ob_digit */
 
@@ -756,8 +756,8 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
             ++numsignificantbytes;
     }
 
-    /* How many Python long digits do we need?  We have
+    /* How many Python int digits do we need?  We have
-       8*numsignificantbytes bits, and each Python long digit has
+       8*numsignificantbytes bits, and each Python int digit has
        PyLong_SHIFT bits, so it's the ceiling of the quotient. */
     /* catch overflow before it happens */
     if (numsignificantbytes > (PY_SSIZE_T_MAX - PyLong_SHIFT) / 8) {
@@ -857,7 +857,7 @@ _PyLong_AsByteArray(PyLongObject* v,
 
     /* Copy over all the Python digits.
        It's crucial that every Python digit except for the MSD contribute
-       exactly PyLong_SHIFT bits to the total, so first assert that the long is
+       exactly PyLong_SHIFT bits to the total, so first assert that the int is
        normalized. */
     assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
     j = 0;
@@ -912,7 +912,7 @@ _PyLong_AsByteArray(PyLongObject* v,
         ++j;
         if (do_twos_comp) {
             /* Fill leading bits of the byte with sign bits
-               (appropriately pretending that the long had an
+               (appropriately pretending that the int had an
                infinite supply of sign bits). */
             accum |= (~(twodigits)0) << accumbits;
         }
@@ -948,7 +948,7 @@ _PyLong_AsByteArray(PyLongObject* v,
 
 }
 
-/* Create a new long int object from a C pointer */
+/* Create a new int object from a C pointer */
 
 PyObject *
 PyLong_FromVoidPtr(void *p)
@@ -974,7 +974,7 @@ PyLong_FromVoidPtr(void *p)
 
 }
 
-/* Get a C pointer from a long int object. */
+/* Get a C pointer from an int object. */
 
 void *
 PyLong_AsVoidPtr(PyObject *vv)
@@ -1017,7 +1017,7 @@ PyLong_AsVoidPtr(PyObject *vv)
 #define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one
 #define PY_ABS_LLONG_MIN (0-(unsigned PY_LONG_LONG)PY_LLONG_MIN)
 
-/* Create a new long int object from a C PY_LONG_LONG int. */
+/* Create a new int object from a C PY_LONG_LONG int. */
 
 PyObject *
 PyLong_FromLongLong(PY_LONG_LONG ival)
@@ -1061,7 +1061,7 @@ PyLong_FromLongLong(PY_LONG_LONG ival)
     return (PyObject *)v;
 }
 
-/* Create a new long int object from a C unsigned PY_LONG_LONG int. */
+/* Create a new int object from a C unsigned PY_LONG_LONG int. */
 
 PyObject *
 PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
@@ -1090,7 +1090,7 @@ PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
     return (PyObject *)v;
 }
 
-/* Create a new long int object from a C Py_ssize_t. */
+/* Create a new int object from a C Py_ssize_t. */
 
 PyObject *
 PyLong_FromSsize_t(Py_ssize_t ival)
@@ -1130,7 +1130,7 @@ PyLong_FromSsize_t(Py_ssize_t ival)
     return (PyObject *)v;
 }
 
-/* Create a new long int object from a C size_t. */
+/* Create a new int object from a C size_t. */
 
 PyObject *
 PyLong_FromSize_t(size_t ival)
@@ -1159,7 +1159,7 @@ PyLong_FromSize_t(size_t ival)
     return (PyObject *)v;
 }
 
-/* Get a C long long int from a long int object or any object that has an
+/* Get a C long long int from an int object or any object that has an
    __int__ method.  Return -1 and set an error if overflow occurs. */
 
 PY_LONG_LONG
@@ -1211,7 +1211,7 @@ PyLong_AsLongLong(PyObject *vv)
         return bytes;
 }
 
-/* Get a C unsigned PY_LONG_LONG int from a long int object.
+/* Get a C unsigned PY_LONG_LONG int from an int object.
    Return -1 and set an error if overflow occurs. */
 
 unsigned PY_LONG_LONG
@@ -1247,7 +1247,7 @@ PyLong_AsUnsignedLongLong(PyObject *vv)
         return bytes;
 }
 
-/* Get a C unsigned long int from a long int object, ignoring the high bits.
+/* Get a C unsigned long int from an int object, ignoring the high bits.
    Returns -1 and sets an error condition if an error occurs. */
 
 static unsigned PY_LONG_LONG
@@ -1316,7 +1316,7 @@ PyLong_AsUnsignedLongLongMask(register PyObject *op)
 }
 #undef IS_LITTLE_ENDIAN
 
-/* Get a C long long int from a long int object or any object that has an
+/* Get a C long long int from an int object or any object that has an
    __int__ method.
 
    On overflow, return -1 and set *overflow to 1 or -1 depending on the sign of
@@ -1533,7 +1533,7 @@ v_rshift(digit *z, digit *a, Py_ssize_t m, int d)
 /* Divide long pin, w/ size digits, by non-zero digit n, storing quotient
    in pout, and returning the remainder.  pin and pout point at the LSD.
    It's OK for pin == pout on entry, which saves oodles of mallocs/frees in
-   _PyLong_Format, but that should be done with great care since longs are
+   _PyLong_Format, but that should be done with great care since ints are
    immutable. */
 
 static digit
@@ -1553,7 +1553,7 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
     return (digit)rem;
 }
 
-/* Divide a long integer by a digit, returning both the quotient
+/* Divide an integer by a digit, returning both the quotient
    (as function result) and the remainder (through *prem).
    The sign of a is ignored; n should not be zero. */
 
@@ -1571,7 +1571,7 @@ divrem1(PyLongObject *a, digit n, digit *prem)
     return long_normalize(z);
 }
 
-/* Convert a long integer to a base 10 string.  Returns a new non-shared
+/* Convert an integer to a base 10 string.  Returns a new non-shared
    string.  (Return value is non-shared so that callers can modify the
    returned value if necessary.) */
 
@@ -1740,7 +1740,7 @@ long_to_decimal_string(PyObject *aa)
     return v;
 }
 
-/* Convert a long int object to a string, using a given conversion base,
+/* Convert an int object to a string, using a given conversion base,
    which should be one of 2, 8 or 16.  Return a string object.
    If base is 2, 8 or 16, add the proper prefix '0b', '0o' or '0x'
    if alternate is nonzero. */
@@ -1941,7 +1941,7 @@ unsigned char _PyLong_DigitValue[256] = {
 
 /* *str points to the first digit in a string of base `base` digits.  base
  * is a power of 2 (2, 4, 8, 16, or 32).  *str is set to point to the first
- * non-digit (which may be *str!).  A normalized long is returned.
+ * non-digit (which may be *str!).  A normalized int is returned.
  * The point to this routine is that it takes time linear in the number of
  * string characters.
  */
@@ -1976,7 +1976,7 @@ long_from_binary_base(char **str, int base)
     z = _PyLong_New(n);
     if (z == NULL)
         return NULL;
-    /* Read string from right, and fill in long from left; i.e.,
+    /* Read string from right, and fill in int from left; i.e.,
      * from least to most significant in both.
      */
     accum = 0;
@@ -2005,7 +2005,7 @@ long_from_binary_base(char **str, int base)
     return long_normalize(z);
 }
 
-/* Parses a long from a bytestring. Leading and trailing whitespace will be
+/* Parses an int from a bytestring. Leading and trailing whitespace will be
  * ignored.
  *
  * If successful, a PyLong object will be returned and 'pend' will be pointing
@@ -2075,7 +2075,7 @@ case number of Python digits needed to hold it is the smallest integer n s.t.
     n >= log(B**N)/log(BASE) = N * log(B)/log(BASE)
 
 The static array log_base_BASE[base] == log(base)/log(BASE) so we can compute
-this quickly.  A Python long with that much space is reserved near the start,
+this quickly.  A Python int with that much space is reserved near the start,
 and the result is computed into it.
 
 The input string is actually treated as being in base base**i (i.e., i digits
@@ -2140,7 +2140,7 @@ is very close to an integer.  If we were working with IEEE single-precision,
 rounding errors could kill us.  Finding worst cases in IEEE double-precision
 requires better-than-double-precision log() functions, and Tim didn't bother.
 Instead the code checks to see whether the allocated space is enough as each
-new Python digit is added, and copies the whole thing to a larger long if not.
+new Python digit is added, and copies the whole thing to a larger int if not.
 This should happen extremely rarely, and in fact I don't have a test case
 that triggers it(!).  Instead the code was tested by artificially allocating
 just 1 digit at the start, so that the copying code was exercised for every
@@ -2181,7 +2181,7 @@ digit beyond the first.
         while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base)
             ++scan;
 
-        /* Create a long object that can contain the largest possible
+        /* Create an int object that can contain the largest possible
          * integer with this base and length.  Note that there's no
          * need to initialize z->ob_digit -- no slot is read up before
          * being stored into.
@@ -2374,7 +2374,7 @@ static PyLongObject *x_divrem
     (PyLongObject *, PyLongObject *, PyLongObject **);
 static PyObject *long_long(PyObject *v);
 
-/* Long division with remainder, top-level routine */
+/* Int division with remainder, top-level routine */
 
 static int
 long_divrem(PyLongObject *a, PyLongObject *b,
@@ -2427,7 +2427,7 @@ long_divrem(PyLongObject *a, PyLongObject *b,
     return 0;
 }
 
-/* Unsigned long division with remainder -- the algorithm.  The arguments v1
+/* Unsigned int division with remainder -- the algorithm.  The arguments v1
    and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */
 
 static PyLongObject *
@@ -2678,7 +2678,7 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e)
     return -1.0;
 }
 
-/* Get a C double from a long int object.  Rounds to the nearest double,
+/* Get a C double from an int object.  Rounds to the nearest double,
    using the round-half-to-even rule in the case of a tie. */
 
 double
@@ -2834,7 +2834,7 @@ long_hash(PyLongObject *v)
 }
 
 
-/* Add the absolute values of two long integers. */
+/* Add the absolute values of two integers. */
 
 static PyLongObject *
 x_add(PyLongObject *a, PyLongObject *b)
@@ -3042,7 +3042,7 @@ x_mul(PyLongObject *a, PyLongObject *b)
             assert((carry >> PyLong_SHIFT) == 0);
         }
     }
-    else {      /* a is not the same as b -- gradeschool long mult */
+    else {      /* a is not the same as b -- gradeschool int mult */
         for (i = 0; i < size_a; ++i) {
             twodigits carry = 0;
             twodigits f = a->ob_digit[i];
@@ -3070,7 +3070,7 @@ x_mul(PyLongObject *a, PyLongObject *b)
 }
 
 /* A helper for Karatsuba multiplication (k_mul).
-   Takes a long "n" and an integer "size" representing the place to
+   Takes an int "n" and an integer "size" representing the place to
    split, and sets low and high such that abs(n) == (high << size) + low,
    viewing the shift as being by digits.  The sign bit is ignored, and
    the return values are >= 0.
@@ -4368,10 +4368,10 @@ long_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     }
 }
 
-/* Wimpy, slow approach to tp_new calls for subtypes of long:
+/* Wimpy, slow approach to tp_new calls for subtypes of int:
-   first create a regular long from whatever arguments we got,
+   first create a regular int from whatever arguments we got,
    then allocate a subtype instance and initialize it from
-   the regular long.  The regular long is then thrown away.
+   the regular int.  The regular int is then thrown away.
 */
 static PyObject *
 long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
@@ -4822,7 +4822,7 @@ long_from_bytes(PyTypeObject *type, PyObject *args, PyObject *kwds)
     Py_DECREF(bytes);
 
     /* If from_bytes() was used on subclass, allocate new subclass
-     * instance, initialize it with decoded long value and return it.
+     * instance, initialize it with decoded int value and return it.
      */
     if (type != &PyLong_Type && PyType_IsSubtype(type, &PyLong_Type)) {
         PyLongObject *newobj;

Objects/rangeobject.c

@@ -933,7 +933,7 @@ PyTypeObject PyRange_Type = {
 /*********************** range Iterator **************************/
 
 /* There are 2 types of iterators, one for C longs, the other for
-   Python longs (ie, PyObjects).  This should make iteration fast
+   Python ints (ie, PyObjects).  This should make iteration fast
    in the normal case, but possible for any numeric value.
 */
 

PC/pyconfig.h

@@ -398,7 +398,7 @@ Py_NO_ENABLE_SHARED to find out.  Also support MS_NO_COREDLL for b/w compat */
 #endif
 
 /* define signed and unsigned exact-width 32-bit and 64-bit types, used in the
-   implementation of Python long integers. */
+   implementation of Python integers. */
 #ifndef PY_UINT32_T
 #if SIZEOF_INT == 4
 #define HAVE_UINT32_T 1

PC/winreg.c

@@ -253,7 +253,7 @@ PyDoc_STRVAR(QueryInfoKey_doc,
 "The result is a tuple of 3 items:"
 "An integer that identifies the number of sub keys this key has.\n"
 "An integer that identifies the number of values this key has.\n"
-"A long integer that identifies when the key was last modified (if available)\n"
+"An integer that identifies when the key was last modified (if available)\n"
 " as 100's of nanoseconds since Jan 1, 1600.");
 
 PyDoc_STRVAR(QueryValue_doc,
@@ -405,8 +405,7 @@ PyDoc_STRVAR(PyHKEY_Detach_doc,
 "After calling this function, the handle is effectively invalidated,\n"
 "but the handle is not closed.  You would call this function when you\n"
 "need the underlying win32 handle to exist beyond the lifetime of the\n"
-"handle object.\n"
+"handle object.");
-"On 64 bit windows, the result of this function is a long integer");
 
 
 /************************************************************************

Python/bltinmodule.c

@@ -1512,7 +1512,7 @@ PyDoc_STRVAR(pow_doc,
 "pow(x, y[, z]) -> number\n\
 \n\
 With two arguments, equivalent to x**y.  With three arguments,\n\
-equivalent to (x**y) % z, but may be more efficient (e.g. for longs).");
+equivalent to (x**y) % z, but may be more efficient (e.g. for ints).");
 
 
 

Python/compile.c

@@ -1013,7 +1013,7 @@ compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o)
     Py_ssize_t arg;
     double d;
 
-    /* necessary to make sure types aren't coerced (e.g., int and long) */
+    /* necessary to make sure types aren't coerced (e.g., float and complex) */
     /* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */
     if (PyFloat_Check(o)) {
         d = PyFloat_AS_DOUBLE(o);

Python/formatter_unicode.c

@@ -1439,8 +1439,7 @@ _PyLong_FormatAdvancedWriter(_PyUnicodeWriter *writer,
     case 'x':
     case 'X':
     case 'n':
-        /* no type conversion needed, already an int (or long).  do
+        /* no type conversion needed, already an int.  do the formatting */
-           the formatting */
         result = format_long_internal(obj, &format, writer);
         break;
 

Python/marshal.c

@@ -146,7 +146,7 @@ w_pstring(const char *s, Py_ssize_t n, WFILE *p)
         w_string(s, n, p);
 }
 
-/* We assume that Python longs are stored internally in base some power of
+/* We assume that Python ints are stored internally in base some power of
    2**15; for the sake of portability we'll always read and write them in base
    exactly 2**15. */
 
@@ -432,7 +432,7 @@ w_object(PyObject *v, WFILE *p)
     p->depth--;
 }
 
-/* version currently has no effect for writing longs. */
+/* version currently has no effect for writing ints. */
 void
 PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
 {