error messages and comments.
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
- class.
+ Field values can be ints, strings, or instances of the Binary class.
.. class:: Binary(filename)
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.
*/
/*
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.
*/
/* 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
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
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 {
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
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,
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);
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.
#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
#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
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
- 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
"""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__ + (
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.
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
>>> 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:
- # the pickle may have been written on a 64-bit box. There's also a hack
- # for True and False here.
+ # There's a hack for True and False here.
if s == b"00":
return False
elif s == b"01":
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):
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.]:
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)
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)
% (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)
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)
- r1 = repr(count(i)).replace('L', '')
- r2 = 'count(%r)'.__mod__(i).replace('L', '')
+ # Test repr
+ r1 = repr(count(i))
+ r2 = 'count(%r)'.__mod__(i)
self.assertEqual(r1, r2)
# check copy, deepcopy, pickle
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)
- r1 = repr(count(i, j)).replace('L', '')
+ # Test repr
+ 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))
"".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:
def test_mixed_compares(self):
eq = self.assertEqual
- # We're mostly concerned with that mixing floats and longs does the
- # right stuff, even when longs are too large to fit in a float.
+ # We're mostly concerned with that mixing floats and ints does the
+ # 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):
# 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
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)
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")
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
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;
}
}
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_day = NULL; /* 1e6 * 3600 * 24 as Python long */
-static PyObject *us_per_week = NULL; /* 1e6*3600*24*7 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 int */
+static PyObject *us_per_week = NULL; /* 1e6*3600*24*7 as Python int */
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.
*/
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)
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 */
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 */
/*************************************************************************
- A custom hashtable mapping void* to longs. This is used by the pickler for
- memoization. Using a custom hashtable rather than PyDict allows us to skip
+ A custom hashtable mapping void* to Python ints. This is used by the pickler
+ 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. */
* 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
- * of the form -(2**(8*j-1)) for j > 0. Such a long is
+ * opposite of the one we need. The exception is ints
+ * 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
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);
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.
*/
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);
{"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 */
};
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;
}
}
{-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},
}
else {
PyErr_SetString(PyExc_TypeError,
- "Expected an int or long as second argument "
- "to ldexp.");
+ "Expected an int as second argument to ldexp.");
return NULL;
}
"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
- in that long is larger than PY_SSIZE_T_MAX. */
+ However, intermediate overflow is possible for an int if the number of bits
+ 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;
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));
}
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));
}
return type_error("bad operand type for abs(): '%.200s'", o);
}
-/* Return a Python Int or Long from the object item
- Raise TypeError if the result is not an int-or-long
+/* Return a Python int from the object item
+ Raise TypeError if the result is not an int
or if the object cannot be interpreted as an index.
*/
PyObject *
/* 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 "
- "int or long");
+ PyErr_SetString(PyExc_ValueError, "PyNumber_ToBase: index not int");
Py_DECREF(index);
return res;
}
}
/* 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.
*/
/* 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) \
* 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
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.
*/
{
}
} /* else if (PyLong_Check(w)) */
- else /* w isn't float, int, or long */
+ else /* w isn't float or int */
goto Unimplemented;
Compare:
#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)
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. */
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 \
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)
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)
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)
#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
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
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
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
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
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
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
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 */
++numsignificantbytes;
}
- /* How many Python long digits do we need? We have
- 8*numsignificantbytes bits, and each Python long digit has
+ /* How many Python int digits do we need? We have
+ 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) {
/* 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;
++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;
}
}
-/* Create a new long int object from a C pointer */
+/* Create a new int object from a C pointer */
PyObject *
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)
#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)
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)
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)
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)
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
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
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
}
#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
/* 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
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. */
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.) */
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. */
/* *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.
*/
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;
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
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
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
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.
(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,
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 *
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
}
-/* Add the absolute values of two long integers. */
+/* Add the absolute values of two integers. */
static PyLongObject *
x_add(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];
}
/* 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.
}
}
-/* Wimpy, slow approach to tp_new calls for subtypes of long:
- first create a regular long from whatever arguments we got,
+/* Wimpy, slow approach to tp_new calls for subtypes of int:
+ 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)
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;
/*********************** 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.
*/
#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
"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,
"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"
-"On 64 bit windows, the result of this function is a long integer");
+"handle object.");
/************************************************************************
"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).");
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);
case 'x':
case 'X':
case 'n':
- /* no type conversion needed, already an int (or long). do
- the formatting */
+ /* no type conversion needed, already an int. do the formatting */
result = format_long_internal(obj, &format, writer);
break;
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. */
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)
{
projects / python / commitdiff