languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-09-04 15:56:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed PyInt_GetMax and sys.maxint

Browse source 
I replaced sys.maxint with sys.maxsize in Lib/*.py. Does anybody see a problem with the change on Win 64bit platforms? Win 64's long is just 32bit but the sys.maxsize is now 2**63-1 on every 64bit platform.
Also added docs for sys.maxsize.
This commit is contained in:
Christian Heimes 2007-12-04 23:02:19 +00:00
parent 327858ef2c
commit a37d4c693a
47 changed files with 142 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Doc/library/itertools.rst
View file

@ -235,7 +235,7 @@ loops that truncate the stream.
def islice(iterable, *args):
s = slice(*args)
it = iter(range(s.start or 0, s.stop or sys.maxint, s.step or 1))
it = iter(range(s.start or 0, s.stop or sys.maxsize, s.step or 1))
nexti = next(it)
for i, element in enumerate(iterable):
if i == nexti:

9
Doc/library/sys.rst
View file

@ -365,11 +365,12 @@ always available.
etc.)
.. data:: maxint
.. data:: maxsize
The largest positive integer supported by Python's regular integer type. This
is at least 2\*\*31-1. The largest negative integer is ``-maxint-1`` --- the
asymmetry results from the use of 2's complement binary arithmetic.
An integer giving the size of ``Py_ssize_t``. It's usually 2**31-1 on a 32
bit platform and 2**63-1 on a 64bit platform.
..versionadded:: 3.0
.. data:: maxunicode

2
Include/longobject.h
View file

@ -31,8 +31,6 @@ PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
cleanup to keep the extra information. [CH] */
#define PyLong_AS_LONG(op) PyLong_AsLong(op)
PyAPI_FUNC(long) PyInt_GetMax(void);
/* Used by socketmodule.c */
#if SIZEOF_SOCKET_T <= SIZEOF_LONG
#define PyLong_FromSocket_t(fd) PyLong_FromLong((SOCKET_T)(fd))

14
Lib/UserString.py
View file

@ -85,7 +85,7 @@ def __mod__(self, args):
def capitalize(self): return self.__class__(self.data.capitalize())
def center(self, width, *args):
return self.__class__(self.data.center(width, *args))
def count(self, sub, start=0, end=sys.maxint):
def count(self, sub, start=0, end=sys.maxsize):
if isinstance(sub, UserString):
sub = sub.data
return self.data.count(sub, start, end)
@ -105,15 +105,15 @@ def encode(self, encoding=None, errors=None): # XXX improve this?
return self.__class__(self.data.encode(encoding))
else:
return self.__class__(self.data.encode())
def endswith(self, suffix, start=0, end=sys.maxint):
def endswith(self, suffix, start=0, end=sys.maxsize):
return self.data.endswith(suffix, start, end)
def expandtabs(self, tabsize=8):
return self.__class__(self.data.expandtabs(tabsize))
def find(self, sub, start=0, end=sys.maxint):
def find(self, sub, start=0, end=sys.maxsize):
if isinstance(sub, UserString):
sub = sub.data
return self.data.find(sub, start, end)
def index(self, sub, start=0, end=sys.maxint):
def index(self, sub, start=0, end=sys.maxsize):
return self.data.index(sub, start, end)
def isalpha(self): return self.data.isalpha()
def isalnum(self): return self.data.isalnum()
@ -137,9 +137,9 @@ def replace(self, old, new, maxsplit=-1):
if isinstance(new, UserString):
new = new.data
return self.__class__(self.data.replace(old, new, maxsplit))
def rfind(self, sub, start=0, end=sys.maxint):
def rfind(self, sub, start=0, end=sys.maxsize):
return self.data.rfind(sub, start, end)
def rindex(self, sub, start=0, end=sys.maxint):
def rindex(self, sub, start=0, end=sys.maxsize):
return self.data.rindex(sub, start, end)
def rjust(self, width, *args):
return self.__class__(self.data.rjust(width, *args))
@ -151,7 +151,7 @@ def split(self, sep=None, maxsplit=-1):
def rsplit(self, sep=None, maxsplit=-1):
return self.data.rsplit(sep, maxsplit)
def splitlines(self, keepends=0): return self.data.splitlines(keepends)
def startswith(self, prefix, start=0, end=sys.maxint):
def startswith(self, prefix, start=0, end=sys.maxsize):
return self.data.startswith(prefix, start, end)
def strip(self, chars=None): return self.__class__(self.data.strip(chars))
def swapcase(self): return self.__class__(self.data.swapcase())

2
Lib/_abcoll.py
View file

@ -246,7 +246,7 @@ def _hash(self):
freedom for __eq__ or __hash__. We match the algorithm used
by the built-in frozenset type.
"""
MAX = sys.maxint
MAX = sys.maxsize
MASK = 2 * MAX + 1
n = len(self)
h = 1927868237 * (n + 1)

4
Lib/ctypes/__init__.py
View file

@ -348,8 +348,8 @@ def __init__(self, name, mode=DEFAULT_MODE, handle=None):
def __repr__(self):
return "<%s '%s', handle %x at %x>" % \
(self.__class__.__name__, self._name,
(self._handle & (_sys.maxint*2 + 1)),
id(self) & (_sys.maxint*2 + 1))
(self._handle & (_sys.maxsize*2 + 1)),
id(self) & (_sys.maxsize*2 + 1))
def __getattr__(self, name):
if name.startswith('__') and name.endswith('__'):

2
Lib/ctypes/util.py
View file

@ -98,7 +98,7 @@ def _num_version(libname):
nums.insert(0, int(parts.pop()))
except ValueError:
pass
return nums or [ sys.maxint ]
return nums or [ sys.maxsize ]
def find_library(name):
ename = re.escape(name)

4
Lib/email/generator.py
View file

@ -307,13 +307,13 @@ def _dispatch(self, msg):
# Helper
_width = len(repr(sys.maxint-1))
_width = len(repr(sys.maxsize-1))
_fmt = '%%0%dd' % _width
def _make_boundary(text=None):
# Craft a random boundary. If text is given, ensure that the chosen
# boundary doesn't appear in the text.
token = random.randrange(sys.maxint)
token = random.randrange(sys.maxsize)
boundary = ('=' * 15) + (_fmt % token) + '=='
if text is None:
return boundary

4
Lib/gzip.py
View file

@ -409,7 +409,7 @@ def seek(self, offset, whence=0):
def readline(self, size=-1):
if size < 0:
size = sys.maxint
size = sys.maxsize
readsize = self.min_readsize
else:
readsize = size
@ -441,7 +441,7 @@ def readline(self, size=-1):
def readlines(self, sizehint=0):
# Negative numbers result in reading all the lines
if sizehint <= 0:
sizehint = sys.maxint
sizehint = sys.maxsize
L = []
while sizehint > 0:
line = self.readline()

4
Lib/inspect.py
View file

@ -320,7 +320,7 @@ def getdoc(object):
return None
else:
# Find minimum indentation of any non-blank lines after first line.
margin = sys.maxint
margin = sys.maxsize
for line in lines[1:]:
content = len(line.lstrip())
if content:
@ -329,7 +329,7 @@ def getdoc(object):
# Remove indentation.
if lines:
lines[0] = lines[0].lstrip()
if margin < sys.maxint:
if margin < sys.maxsize:
for i in range(1, len(lines)): lines[i] = lines[i][margin:]
# Remove any trailing or leading blank lines.
while lines and not lines[-1]:

4
Lib/mhlib.py
View file

@ -365,7 +365,7 @@ def parsesequence(self, seq):
try:
count = int(tail)
except (ValueError, OverflowError):
# Can't use sys.maxint because of i+count below
# Can't use sys.maxsize because of i+count below
count = len(all)
try:
anchor = self._parseindex(head, all)
@ -428,7 +428,7 @@ def _parseindex(self, seq, all):
try:
return int(seq)
except (OverflowError, ValueError):
return sys.maxint
return sys.maxsize
if seq in ('cur', '.'):
return self.getcurrent()
if seq == 'first':

4
Lib/sre_parse.py
View file

@ -152,7 +152,7 @@ def getwidth(self):
REPEATCODES = (MIN_REPEAT, MAX_REPEAT)
for op, av in self.data:
if op is BRANCH:
i = sys.maxint
i = sys.maxsize
j = 0
for av in av[1]:
l, h = av.getwidth()
@ -177,7 +177,7 @@ def getwidth(self):
hi = hi + 1
elif op == SUCCESS:
break
self.width = int(min(lo, sys.maxint)), int(min(hi, sys.maxint))
self.width = int(min(lo, sys.maxsize)), int(min(hi, sys.maxsize))
return self.width
class Tokenizer:

4
Lib/subprocess.py
View file

@ -344,7 +344,7 @@ class pywintypes:
def _cleanup():
for inst in _active[:]:
res = inst.poll(_deadstate=sys.maxint)
res = inst.poll(_deadstate=sys.maxsize)
if res is not None and res >= 0:
try:
_active.remove(inst)
@ -562,7 +562,7 @@ def __del__(self, sys=sys):
# We didn't get to successfully create a child process.
return
# In case the child hasn't been waited on, check if it's done.
self.poll(_deadstate=sys.maxint)
self.poll(_deadstate=sys.maxsize)
if self.returncode is None and _active is not None:
# Child is still running, keep us alive until we can wait on it.
_active.append(self)

4
Lib/test/buffer_tests.py
View file

@ -172,9 +172,9 @@ def test_expandtabs(self):
self.assertRaises(TypeError, self.marshal(b'hello').expandtabs, 42, 42)
# This test is only valid when sizeof(int) == sizeof(void*) == 4.
if sys.maxint < (1 << 32) and struct.calcsize('P') == 4:
if sys.maxsize < (1 << 32) and struct.calcsize('P') == 4:
self.assertRaises(OverflowError,
self.marshal(b'\ta\n\tb').expandtabs, sys.maxint)
self.marshal(b'\ta\n\tb').expandtabs, sys.maxsize)
def test_title(self):
self.assertEqual(b' Hello ', self.marshal(b' hello ').title())

4
Lib/test/list_tests.py
View file

@ -388,8 +388,8 @@ def __eq__(self, other):
self.assertEqual(a.index(0, -3), 3)
self.assertEqual(a.index(0, 3, 4), 3)
self.assertEqual(a.index(0, -3, -2), 3)
self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
self.assertEqual(a.index(0, -4*sys.maxsize, 4*sys.maxsize), 2)
self.assertRaises(ValueError, a.index, 0, 4*sys.maxsize,-4*sys.maxsize)
self.assertRaises(ValueError, a.index, 2, 0, -10)
a.remove(0)
self.assertRaises(ValueError, a.index, 2, 0, 4)

2
Lib/test/pickletester.py
View file

@ -493,7 +493,7 @@ def test_unicode(self):
def test_ints(self):
import sys
for proto in protocols:
n = sys.maxint
n = sys.maxsize
while n:
for expected in (-n, n):
s = self.dumps(expected, proto)

2
Lib/test/regrtest.py
View file

@ -140,7 +140,7 @@
# putting them in test_grammar.py has no effect:
warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
".*test.test_grammar$")
if sys.maxint > 0x7fffffff:
if sys.maxsize > 0x7fffffff:
# Also suppress them in <string>, because for 64-bit platforms,
# that's where test_grammar.py hides them.
warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,

36
Lib/test/string_tests.py
View file

@ -265,9 +265,9 @@ def test_expandtabs(self):
self.checkraises(TypeError, 'hello', 'expandtabs', 42, 42)
# This test is only valid when sizeof(int) == sizeof(void*) == 4.
if sys.maxint < (1 << 32) and struct.calcsize('P') == 4:
if sys.maxsize < (1 << 32) and struct.calcsize('P') == 4:
self.checkraises(OverflowError,
'\ta\n\tb', 'expandtabs', sys.maxint)
'\ta\n\tb', 'expandtabs', sys.maxsize)
def test_split(self):
# by a char
@ -278,7 +278,7 @@ def test_split(self):
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|', 4)
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'split', '|',
sys.maxint-2)
sys.maxsize-2)
self.checkequal(['a|b|c|d'], 'a|b|c|d', 'split', '|', 0)
self.checkequal(['a', '', 'b||c||d'], 'a||b||c||d', 'split', '|', 2)
self.checkequal(['endcase ', ''], 'endcase |', 'split', '|')
@ -297,7 +297,7 @@ def test_split(self):
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//', 4)
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'split', '//',
sys.maxint-10)
sys.maxsize-10)
self.checkequal(['a//b//c//d'], 'a//b//c//d', 'split', '//', 0)
self.checkequal(['a', '', 'b////c////d'], 'a////b////c////d', 'split', '//', 2)
self.checkequal(['endcase ', ''], 'endcase test', 'split', 'test')
@ -334,7 +334,7 @@ def test_rsplit(self):
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|', 4)
self.checkequal(['a', 'b', 'c', 'd'], 'a|b|c|d', 'rsplit', '|',
sys.maxint-100)
sys.maxsize-100)
self.checkequal(['a|b|c|d'], 'a|b|c|d', 'rsplit', '|', 0)
self.checkequal(['a||b||c', '', 'd'], 'a||b||c||d', 'rsplit', '|', 2)
self.checkequal(['', ' begincase'], '| begincase', 'rsplit', '|')
@ -354,7 +354,7 @@ def test_rsplit(self):
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//', 4)
self.checkequal(['a', 'b', 'c', 'd'], 'a//b//c//d', 'rsplit', '//',
sys.maxint-5)
sys.maxsize-5)
self.checkequal(['a//b//c//d'], 'a//b//c//d', 'rsplit', '//', 0)
self.checkequal(['a////b////c', '', 'd'], 'a////b////c////d', 'rsplit', '//', 2)
self.checkequal(['', ' begincase'], 'test begincase', 'rsplit', 'test')
@ -392,7 +392,7 @@ def test_replace(self):
EQ("", "", "replace", "A", "")
EQ("", "", "replace", "A", "A")
EQ("", "", "replace", "", "", 100)
EQ("", "", "replace", "", "", sys.maxint)
EQ("", "", "replace", "", "", sys.maxsize)
# interleave (from=="", 'to' gets inserted everywhere)
EQ("A", "A", "replace", "", "")
@ -401,7 +401,7 @@ def test_replace(self):
EQ("*-#A*-#", "A", "replace", "", "*-#")
EQ("*-A*-A*-", "AA", "replace", "", "*-")
EQ("*-A*-A*-", "AA", "replace", "", "*-", -1)
EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxint)
EQ("*-A*-A*-", "AA", "replace", "", "*-", sys.maxsize)
EQ("*-A*-A*-", "AA", "replace", "", "*-", 4)
EQ("*-A*-A*-", "AA", "replace", "", "*-", 3)
EQ("*-A*-A", "AA", "replace", "", "*-", 2)
@ -412,7 +412,7 @@ def test_replace(self):
EQ("", "A", "replace", "A", "")
EQ("", "AAA", "replace", "A", "")
EQ("", "AAA", "replace", "A", "", -1)
EQ("", "AAA", "replace", "A", "", sys.maxint)
EQ("", "AAA", "replace", "A", "", sys.maxsize)
EQ("", "AAA", "replace", "A", "", 4)
EQ("", "AAA", "replace", "A", "", 3)
EQ("A", "AAA", "replace", "A", "", 2)
@ -421,7 +421,7 @@ def test_replace(self):
EQ("", "AAAAAAAAAA", "replace", "A", "")
EQ("BCD", "ABACADA", "replace", "A", "")
EQ("BCD", "ABACADA", "replace", "A", "", -1)
EQ("BCD", "ABACADA", "replace", "A", "", sys.maxint)
EQ("BCD", "ABACADA", "replace", "A", "", sys.maxsize)
EQ("BCD", "ABACADA", "replace", "A", "", 5)
EQ("BCD", "ABACADA", "replace", "A", "", 4)
EQ("BCDA", "ABACADA", "replace", "A", "", 3)
@ -444,7 +444,7 @@ def test_replace(self):
EQ("thaet", "thaet", "replace", "the", "")
EQ("here and re", "here and there", "replace", "the", "")
EQ("here and re and re", "here and there and there",
"replace", "the", "", sys.maxint)
"replace", "the", "", sys.maxsize)
EQ("here and re and re", "here and there and there",
"replace", "the", "", -1)
EQ("here and re and re", "here and there and there",
@ -469,7 +469,7 @@ def test_replace(self):
# single character replace in place (len(from)==len(to)==1)
EQ("Who goes there?", "Who goes there?", "replace", "o", "o")
EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O")
EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxint)
EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", sys.maxsize)
EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", -1)
EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 3)
EQ("WhO gOes there?", "Who goes there?", "replace", "o", "O", 2)
@ -486,7 +486,7 @@ def test_replace(self):
# substring replace in place (len(from)==len(to) > 1)
EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**")
EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxint)
EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", sys.maxsize)
EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", -1)
EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 4)
EQ("Th** ** a t**sue", "This is a tissue", "replace", "is", "**", 3)
@ -500,7 +500,7 @@ def test_replace(self):
# replace single character (len(from)==1, len(to)>1)
EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK")
EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", -1)
EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxint)
EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", sys.maxsize)
EQ("ReyKKjaviKK", "Reykjavik", "replace", "k", "KK", 2)
EQ("ReyKKjavik", "Reykjavik", "replace", "k", "KK", 1)
EQ("Reykjavik", "Reykjavik", "replace", "k", "KK", 0)
@ -512,7 +512,7 @@ def test_replace(self):
EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
"replace", "spam", "ham")
EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
"replace", "spam", "ham", sys.maxint)
"replace", "spam", "ham", sys.maxsize)
EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
"replace", "spam", "ham", -1)
EQ("ham, ham, eggs and ham", "spam, spam, eggs and spam",
@ -567,7 +567,7 @@ def test_replace(self):
def test_replace_overflow(self):
# Check for overflow checking on 32 bit machines
if sys.maxint != 2147483647 or struct.calcsize("P") > 4:
if sys.maxsize != 2147483647 or struct.calcsize("P") > 4:
return
A2_16 = "A" * (2**16)
self.checkraises(OverflowError, A2_16, "replace", "", A2_16)
@ -631,7 +631,7 @@ def test_additional_split(self):
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None, 4)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'split', None,
sys.maxint-1)
sys.maxsize-1)
self.checkequal(['a b c d'], 'a b c d', 'split', None, 0)
self.checkequal(['a b c d'], ' a b c d', 'split', None, 0)
self.checkequal(['a', 'b', 'c d'], 'a b c d', 'split', None, 2)
@ -662,7 +662,7 @@ def test_additional_rsplit(self):
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 3)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None, 4)
self.checkequal(['a', 'b', 'c', 'd'], 'a b c d', 'rsplit', None,
sys.maxint-20)
sys.maxsize-20)
self.checkequal(['a b c d'], 'a b c d', 'rsplit', None, 0)
self.checkequal(['a b c d'], 'a b c d ', 'rsplit', None, 0)
self.checkequal(['a b', 'c', 'd'], 'a b c d', 'rsplit', None, 2)

38
Lib/test/test_builtin.py
View file

@ -60,7 +60,7 @@ def write(self, line):
(' 314', 314),
('314 ', 314),
(' \t\t 314 \t\t ', 314),
(repr(sys.maxint), sys.maxint),
(repr(sys.maxsize), sys.maxsize),
(' 1x', ValueError),
(' 1 ', 1),
(' 1\02 ', ValueError),
@ -97,7 +97,7 @@ def test_abs(self):
self.assertEqual(abs(0), 0)
self.assertEqual(abs(1234), 1234)
self.assertEqual(abs(-1234), 1234)
self.assertTrue(abs(-sys.maxint-1) > 0)
self.assertTrue(abs(-sys.maxsize-1) > 0)
# float
self.assertEqual(abs(0.0), 0.0)
self.assertEqual(abs(3.14), 3.14)
@ -138,9 +138,9 @@ def test_any(self):
self.assertEqual(any(x > 42 for x in S), False)
def test_neg(self):
x = -sys.maxint-1
x = -sys.maxsize-1
self.assert_(isinstance(x, int))
self.assertEqual(-x, sys.maxint+1)
self.assertEqual(-x, sys.maxsize+1)
# XXX(nnorwitz): This test case for callable should probably be removed.
def test_callable(self):
@ -306,8 +306,8 @@ def test_divmod(self):
self.assertEqual(divmod(12, -7), (-2, -2))
self.assertEqual(divmod(-12, -7), (1, -5))
self.assertEqual(divmod(-sys.maxint-1, -1),
(sys.maxint+1, 0))
self.assertEqual(divmod(-sys.maxsize-1, -1),
(sys.maxsize+1, 0))
self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))
self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))
@ -644,12 +644,12 @@ def test_int(self):
except v:
pass
s = repr(-1-sys.maxint)
s = repr(-1-sys.maxsize)
x = int(s)
self.assertEqual(x+1, -sys.maxint)
self.assertEqual(x+1, -sys.maxsize)
self.assert_(isinstance(x, int))
# should return long
self.assertEqual(int(s[1:]), sys.maxint+1)
self.assertEqual(int(s[1:]), sys.maxsize+1)
# should return long
x = int(1e100)
@ -661,7 +661,7 @@ def test_int(self):
# SF bug 434186: 0x80000000/2 != 0x80000000>>1.
# Worked by accident in Windows release build, but failed in debug build.
# Failed in all Linux builds.
x = -1-sys.maxint
x = -1-sys.maxsize
self.assertEqual(x >> 1, x//2)
self.assertRaises(ValueError, int, '123\0')
@ -881,12 +881,12 @@ def test_list(self):
self.assertEqual(list(''), [])
self.assertEqual(list('spam'), ['s', 'p', 'a', 'm'])
if sys.maxint == 0x7fffffff:
if sys.maxsize == 0x7fffffff:
# This test can currently only work on 32-bit machines.
# XXX If/when PySequence_Length() returns a ssize_t, it should be
# XXX re-enabled.
# Verify clearing of bug #556025.
# This assumes that the max data size (sys.maxint) == max
# This assumes that the max data size (sys.maxsize) == max
# address size this also assumes that the address size is at
# least 4 bytes with 8 byte addresses, the bug is not well
# tested
@ -896,7 +896,7 @@ def test_list(self):
# thread for the details:
# http://sources.redhat.com/ml/newlib/2002/msg00369.html
self.assertRaises(MemoryError, list, range(sys.maxint // 2))
self.assertRaises(MemoryError, list, range(sys.maxsize // 2))
# This code used to segfault in Py2.4a3
x = []
@ -1384,9 +1384,9 @@ def test_range(self):
self.assertEqual(list(range(0, 2**100, -1)), [])
self.assertEqual(list(range(0, 2**100, -1)), [])
a = int(10 * sys.maxint)
b = int(100 * sys.maxint)
c = int(50 * sys.maxint)
a = int(10 * sys.maxsize)
b = int(100 * sys.maxsize)
c = int(50 * sys.maxsize)
self.assertEqual(list(range(a, a+2)), [a, a+1])
self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1])
@ -1428,10 +1428,10 @@ def __eq__(self, other):
self.assertRaises(TypeError, range, 0, "spam")
self.assertRaises(TypeError, range, 0, 42, "spam")
#NEAL self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint)
#NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxint)
#NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize)
#NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize)
self.assertRaises(OverflowError, len, range(0, sys.maxint**10))
self.assertRaises(OverflowError, len, range(0, sys.maxsize**10))
def test_input(self):
self.write_testfile()

22
Lib/test/test_bytes.py
View file

@ -36,14 +36,14 @@ def test_empty_sequence(self):
self.assertEqual(len(b), 0)
self.assertRaises(IndexError, lambda: b[0])
self.assertRaises(IndexError, lambda: b[1])
self.assertRaises(IndexError, lambda: b[sys.maxint])
self.assertRaises(IndexError, lambda: b[sys.maxint+1])
self.assertRaises(IndexError, lambda: b[sys.maxsize])
self.assertRaises(IndexError, lambda: b[sys.maxsize+1])
self.assertRaises(IndexError, lambda: b[10**100])
self.assertRaises(IndexError, lambda: b[-1])
self.assertRaises(IndexError, lambda: b[-2])
self.assertRaises(IndexError, lambda: b[-sys.maxint])
self.assertRaises(IndexError, lambda: b[-sys.maxint-1])
self.assertRaises(IndexError, lambda: b[-sys.maxint-2])
self.assertRaises(IndexError, lambda: b[-sys.maxsize])
self.assertRaises(IndexError, lambda: b[-sys.maxsize-1])
self.assertRaises(IndexError, lambda: b[-sys.maxsize-2])
self.assertRaises(IndexError, lambda: b[-10**100])
def test_from_list(self):
@ -83,14 +83,14 @@ class C:
def test_constructor_value_errors(self):
self.assertRaises(ValueError, bytearray, [-1])
self.assertRaises(ValueError, bytearray, [-sys.maxint])
self.assertRaises(ValueError, bytearray, [-sys.maxint-1])
self.assertRaises(ValueError, bytearray, [-sys.maxint-2])
self.assertRaises(ValueError, bytearray, [-sys.maxsize])
self.assertRaises(ValueError, bytearray, [-sys.maxsize-1])
self.assertRaises(ValueError, bytearray, [-sys.maxsize-2])
self.assertRaises(ValueError, bytearray, [-10**100])
self.assertRaises(ValueError, bytearray, [256])
self.assertRaises(ValueError, bytearray, [257])
self.assertRaises(ValueError, bytearray, [sys.maxint])
self.assertRaises(ValueError, bytearray, [sys.maxint+1])
self.assertRaises(ValueError, bytearray, [sys.maxsize])
self.assertRaises(ValueError, bytearray, [sys.maxsize+1])
self.assertRaises(ValueError, bytearray, [10**100])
def test_repr_str(self):
@ -412,7 +412,7 @@ def test_repeat(self):
self.assertRaises(TypeError, lambda: 3.14 * b)
# XXX Shouldn't bytes and bytearray agree on what to raise?
self.assertRaises((OverflowError, MemoryError),
lambda: b * sys.maxint)
lambda: b * sys.maxsize)
def test_repeat_1char(self):
self.assertEqual(b'x'*100, bytearray([ord('x')]*100))

12
Lib/test/test_compile.py
View file

@ -194,24 +194,24 @@ def test_literals_with_leading_zeroes(self):
def test_unary_minus(self):
# Verify treatment of unary minus on negative numbers SF bug #660455
if sys.maxint == 2147483647:
if sys.maxsize == 2147483647:
# 32-bit machine
all_one_bits = '0xffffffff'
self.assertEqual(eval(all_one_bits), 4294967295)
self.assertEqual(eval("-" + all_one_bits), -4294967295)
elif sys.maxint == 9223372036854775807:
elif sys.maxsize == 9223372036854775807:
# 64-bit machine
all_one_bits = '0xffffffffffffffff'
self.assertEqual(eval(all_one_bits), 18446744073709551615)
self.assertEqual(eval("-" + all_one_bits), -18446744073709551615)
else:
self.fail("How many bits *does* this machine have???")
# Verify treatment of contant folding on -(sys.maxint+1)
# Verify treatment of contant folding on -(sys.maxsize+1)
# i.e. -2147483648 on 32 bit platforms. Should return int, not long.
self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 1)), int))
self.assertTrue(isinstance(eval("%s" % (-sys.maxint - 2)), int))
self.assertTrue(isinstance(eval("%s" % (-sys.maxsize - 1)), int))
self.assertTrue(isinstance(eval("%s" % (-sys.maxsize - 2)), int))
if sys.maxint == 9223372036854775807:
if sys.maxsize == 9223372036854775807:
def test_32_63_bit_values(self):
a = +4294967296 # 1 << 32
b = -4294967296 # 1 << 32

4
Lib/test/test_descr.py
View file

@ -4118,8 +4118,8 @@ def check(expr, x, y):
else:
raise TestFailed("no TypeError from %r" % (expr,))
N1 = sys.maxint + 1 # might trigger OverflowErrors instead of TypeErrors
N2 = sys.maxint # if sizeof(int) < sizeof(long), might trigger
N1 = sys.maxsize + 1 # might trigger OverflowErrors instead of TypeErrors
N2 = sys.maxsize # if sizeof(int) < sizeof(long), might trigger
# ValueErrors instead of TypeErrors
if 1:
metaclass = type

2
Lib/test/test_format.py
View file

@ -40,7 +40,7 @@ def testformat(formatstr, args, output=None):
print('yes')
testformat("%.1d", (1,), "1")
testformat("%.*d", (sys.maxint,1)) # expect overflow
testformat("%.*d", (sys.maxsize,1)) # expect overflow
testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')

8
Lib/test/test_grammar.py
View file

@ -32,8 +32,8 @@ def testPlainIntegers(self):
self.assertEquals(0o377, 255)
self.assertEquals(2147483647, 0o17777777777)
self.assertEquals(0b1001, 9)
from sys import maxint
if maxint == 2147483647:
from sys import maxsize
if maxsize == 2147483647:
self.assertEquals(-2147483647-1, -0o20000000000)
# XXX -2147483648
self.assert_(0o37777777777 > 0)
@ -45,7 +45,7 @@ def testPlainIntegers(self):
x = eval(s)
except OverflowError:
self.fail("OverflowError on huge integer literal %r" % s)
elif maxint == 9223372036854775807:
elif maxsize == 9223372036854775807:
self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
self.assert_(0o1777777777777777777777 > 0)
self.assert_(0xffffffffffffffff > 0)
@ -58,7 +58,7 @@ def testPlainIntegers(self):
except OverflowError:
self.fail("OverflowError on huge integer literal %r" % s)
else:
self.fail('Weird maxint value %r' % maxint)
self.fail('Weird maxsize value %r' % maxsize)
def testLongIntegers(self):
x = 0

2
Lib/test/test_hexoct.py
View file

@ -4,7 +4,7 @@
"""
import sys
platform_long_is_32_bits = sys.maxint == 2147483647
platform_long_is_32_bits = sys.maxsize == 2147483647
import unittest
from test import test_support

3
Lib/test/test_index.py
View file

@ -2,7 +2,6 @@
from test import test_support
import operator
import sys
from sys import maxint
maxsize = test_support.MAX_Py_ssize_t
minsize = -maxsize-1
@ -180,7 +179,7 @@ def test_large_longs(self):
def test_getitem(self):
class GetItem(object):
def __len__(self):
return maxint #cannot return long here
return sys.maxsize
def __getitem__(self, key):
return key
x = GetItem()

2
Lib/test/test_itertools.py
View file

@ -71,7 +71,7 @@ def test_count(self):
self.assertEqual(repr(c), 'count(-9)')
next(c)
self.assertEqual(next(c), -8)
for i in (-sys.maxint-5, -sys.maxint+5 ,-10, -1, 0, 10, sys.maxint-5, sys.maxint+5):
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', '')

2
Lib/test/test_list.py
View file

@ -21,7 +21,7 @@ def test_len(self):
def test_overflow(self):
lst = [4, 5, 6, 7]
n = int((sys.maxint*2+2) // len(lst))
n = int((sys.maxsize*2+2) // len(lst))
def mul(a, b): return a * b
def imul(a, b): a *= b
self.assertRaises((MemoryError, OverflowError), mul, lst, n)

32
Lib/test/test_long.py
View file

@ -233,48 +233,48 @@ def test_misc(self):
import sys
# check the extremes in int<->long conversion
hugepos = sys.maxint
hugepos = sys.maxsize
hugeneg = -hugepos - 1
hugepos_aslong = int(hugepos)
hugeneg_aslong = int(hugeneg)
self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxint) != sys.maxint")
self.assertEqual(hugepos, hugepos_aslong, "long(sys.maxsize) != sys.maxsize")
self.assertEqual(hugeneg, hugeneg_aslong,
"long(-sys.maxint-1) != -sys.maxint-1")
"long(-sys.maxsize-1) != -sys.maxsize-1")
# long -> int should not fail for hugepos_aslong or hugeneg_aslong
x = int(hugepos_aslong)
try:
self.assertEqual(x, hugepos,
"converting sys.maxint to long and back to int fails")
"converting sys.maxsize to long and back to int fails")
except OverflowError:
self.fail("int(long(sys.maxint)) overflowed!")
self.fail("int(long(sys.maxsize)) overflowed!")
if not isinstance(x, int):
raise TestFailed("int(long(sys.maxint)) should have returned int")
raise TestFailed("int(long(sys.maxsize)) should have returned int")
x = int(hugeneg_aslong)
try:
self.assertEqual(x, hugeneg,
"converting -sys.maxint-1 to long and back to int fails")
"converting -sys.maxsize-1 to long and back to int fails")
except OverflowError:
self.fail("int(long(-sys.maxint-1)) overflowed!")
self.fail("int(long(-sys.maxsize-1)) overflowed!")
if not isinstance(x, int):
raise TestFailed("int(long(-sys.maxint-1)) should have "
raise TestFailed("int(long(-sys.maxsize-1)) should have "
"returned int")
# but long -> int should overflow for hugepos+1 and hugeneg-1
x = hugepos_aslong + 1
try:
y = int(x)
except OverflowError:
self.fail("int(long(sys.maxint) + 1) mustn't overflow")
self.fail("int(long(sys.maxsize) + 1) mustn't overflow")
self.assert_(isinstance(y, int),
"int(long(sys.maxint) + 1) should have returned long")
"int(long(sys.maxsize) + 1) should have returned long")
x = hugeneg_aslong - 1
try:
y = int(x)
except OverflowError:
self.fail("int(long(-sys.maxint-1) - 1) mustn't overflow")
self.fail("int(long(-sys.maxsize-1) - 1) mustn't overflow")
self.assert_(isinstance(y, int),
"int(long(-sys.maxint-1) - 1) should have returned long")
"int(long(-sys.maxsize-1) - 1) should have returned long")
class long2(int):
pass
@ -288,8 +288,8 @@ class long2(int):
def test_auto_overflow(self):
import math, sys
special = [0, 1, 2, 3, sys.maxint-1, sys.maxint, sys.maxint+1]
sqrt = int(math.sqrt(sys.maxint))
special = [0, 1, 2, 3, sys.maxsize-1, sys.maxsize, sys.maxsize+1]
sqrt = int(math.sqrt(sys.maxsize))
special.extend([sqrt-1, sqrt, sqrt+1])
special.extend([-i for i in special])
@ -462,7 +462,7 @@ def __cmp__(self, other):
for t in 2.0**48, 2.0**50, 2.0**53:
cases.extend([t - 1.0, t - 0.3, t, t + 0.3, t + 1.0,
int(t-1), int(t), int(t+1)])
cases.extend([0, 1, 2, sys.maxint, float(sys.maxint)])
cases.extend([0, 1, 2, sys.maxsize, float(sys.maxsize)])
# 1L<<20000 should exceed all double formats. long(1e200) is to
# check that we get equality with 1e200 above.
t = int(1e200)

6
Lib/test/test_marshal.py
View file

@ -28,7 +28,7 @@ def helper(self, sample, *extra):
class IntTestCase(unittest.TestCase, HelperMixin):
def test_ints(self):
# Test the full range of Python ints.
n = sys.maxint
n = sys.maxsize
while n:
for expected in (-n, n):
self.helper(expected)
@ -66,7 +66,7 @@ class FloatTestCase(unittest.TestCase, HelperMixin):
def test_floats(self):
# Test a few floats
small = 1e-25
n = sys.maxint * 3.7e250
n = sys.maxsize * 3.7e250
while n > small:
for expected in (-n, n):
self.helper(float(expected))
@ -81,7 +81,7 @@ def test_floats(self):
got = marshal.loads(s)
self.assertEqual(f, got)
n = sys.maxint * 3.7e-250
n = sys.maxsize * 3.7e-250
while n < small:
for expected in (-n, n):
f = float(expected)

2
Lib/test/test_multibytecodec.py
View file

@ -40,7 +40,7 @@ def test_str_decode(self):
def test_errorcallback_longindex(self):
dec = codecs.getdecoder('euc-kr')
myreplace = lambda exc: ('', sys.maxint+1)
myreplace = lambda exc: ('', sys.maxsize+1)
codecs.register_error('test.cjktest', myreplace)
self.assertRaises(IndexError, dec,
'apple\x92ham\x93spam', 'test.cjktest')

2
Lib/test/test_multibytecodec_support.py
View file

@ -114,7 +114,7 @@ def myreplace(exc):
'test.cjktest'), (b'abcdxefgh', 9))
def myreplace(exc):
return ('x', sys.maxint + 1)
return ('x', sys.maxsize + 1)
codecs.register_error("test.cjktest", myreplace)
self.assertRaises(IndexError, self.encode, self.unmappedunicode,
'test.cjktest')

6
Lib/test/test_range.py
View file

@ -51,10 +51,10 @@ def test_range(self):
self.assertRaises(TypeError, range, 0, "spam")
self.assertRaises(TypeError, range, 0, 42, "spam")
self.assertEqual(len(range(0, sys.maxint, sys.maxint-1)), 2)
self.assertEqual(len(range(0, sys.maxsize, sys.maxsize-1)), 2)
r = range(-sys.maxint, sys.maxint, 2)
self.assertEqual(len(r), sys.maxint)
r = range(-sys.maxsize, sys.maxsize, 2)
self.assertEqual(len(r), sys.maxsize)
def test_repr(self):
self.assertEqual(repr(range(1)), 'range(0, 1)')

2
Lib/test/test_slice.py
View file

@ -92,7 +92,7 @@ def test_indices(self):
)
self.assertEqual(slice(-100, 100, 2).indices(10), (0, 10, 2))
self.assertEqual(list(range(10))[::sys.maxint - 1], [0])
self.assertEqual(list(range(10))[::sys.maxsize - 1], [0])
self.assertRaises(OverflowError, slice(None).indices, 1<<100)

4
Lib/test/test_struct.py
View file

@ -506,8 +506,8 @@ def test_1229380():
deprecated_err(struct.pack, endian + 'B', 300)
deprecated_err(struct.pack, endian + 'H', 70000)
deprecated_err(struct.pack, endian + 'I', sys.maxint * 4)
deprecated_err(struct.pack, endian + 'L', sys.maxint * 4)
deprecated_err(struct.pack, endian + 'I', sys.maxsize * 4)
deprecated_err(struct.pack, endian + 'L', sys.maxsize * 4)
if PY_STRUCT_RANGE_CHECKING:
test_1229380()

2
Lib/test/test_sys.py
View file

@ -282,7 +282,7 @@ def test_attributes(self):
self.assert_(isinstance(sys.float_info, dict))
self.assertEqual(len(sys.float_info), 11)
self.assert_(isinstance(sys.hexversion, int))
self.assert_(isinstance(sys.maxint, int))
self.assert_(isinstance(sys.maxsize, int))
self.assert_(isinstance(sys.maxunicode, int))
self.assert_(isinstance(sys.platform, str))
self.assert_(isinstance(sys.prefix, str))

2
Lib/test/test_threading.py
View file

@ -258,7 +258,7 @@ def test_notify_on_unacquired_condition(self):
def test_semaphore_with_negative_value(self):
self.assertRaises(ValueError, threading.Semaphore, value = -1)
self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxint)
self.assertRaises(ValueError, threading.Semaphore, value = -sys.maxsize)
def test_joining_current_thread(self):
currentThread = threading.currentThread()

6
Lib/test/test_types.py
View file

@ -105,7 +105,7 @@ def test_normal_integers(self):
if not (xsize*ysize*zsize == zsize*xsize*ysize == 338912):
self.fail('int mul commutativity')
# And another.
m = -sys.maxint - 1
m = -sys.maxsize - 1
for divisor in 1, 2, 4, 8, 16, 32:
j = m // divisor
prod = divisor * j
@ -122,7 +122,7 @@ def test_normal_integers(self):
self.fail("expected type(%r) to be long, not %r" %
(prod, type(prod)))
# Check for expected * overflow to long.
m = sys.maxint
m = sys.maxsize
for divisor in 1, 2, 4, 8, 16, 32:
j = m // divisor + 1
prod = divisor * j
@ -137,7 +137,7 @@ def test_long_integers(self):
if (-12) + (-24) != -36: self.fail('long op')
if not 12 < 24: self.fail('long op')
if not -24 < -12: self.fail('long op')
x = sys.maxint
x = sys.maxsize
if int(int(x)) != x: self.fail('long op')
try: y = int(int(x)+1)
except OverflowError: self.fail('long op')

4
Lib/test/test_unicode.py
View file

@ -1055,9 +1055,9 @@ def test_expandtabs_overflows_gracefully(self):
# This test only affects 32-bit platforms because expandtabs can only take
# an int as the max value, not a 64-bit C long. If expandtabs is changed
# to take a 64-bit long, this test should apply to all platforms.
if sys.maxint > (1 << 32) or struct.calcsize('P') != 4:
if sys.maxsize > (1 << 32) or struct.calcsize('P') != 4:
return
self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxint)
self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxsize)
def test_main():

2
Lib/test/test_xmlrpc.py
View file

@ -117,7 +117,7 @@ def test_dump_recursive_dict(self):
self.assertRaises(TypeError, xmlrpclib.dumps, (d,))
def test_dump_big_int(self):
if sys.maxint > 2**31-1:
if sys.maxsize > 2**31-1:
self.assertRaises(OverflowError, xmlrpclib.dumps,
(int(2**34),))

2
Lib/zipfile.py
View file

@ -428,7 +428,7 @@ def readline(self, size = -1):
read a whole line.
"""
if size < 0:
size = sys.maxint
size = sys.maxsize
elif size == 0:
return b''

2
Misc/NEWS
View file

@ -54,6 +54,8 @@ Core and Builtins
to longobject.h. It still exists to define several aliases from PyInt_
to PyLong_ functions.
- Removed sys.maxint, use sys.maxsize instead.
Extension Modules
-----------------

6
Objects/longobject.c
View file

@ -9,12 +9,6 @@
#include <ctype.h>
long
PyInt_GetMax(void)
{
return LONG_MAX; /* To initialize sys.maxint */
}
#ifndef NSMALLPOSINTS
#define NSMALLPOSINTS 257
#endif

2
Python/sysmodule.c
View file

@ -1078,8 +1078,6 @@ _PySys_Init(void)
PyUnicode_DecodeFSDefault(Py_GetPrefix()));
SET_SYS_FROM_STRING("exec_prefix",
PyUnicode_DecodeFSDefault(Py_GetExecPrefix()));
SET_SYS_FROM_STRING("maxint",
PyLong_FromLong(PyInt_GetMax()));
SET_SYS_FROM_STRING("maxsize",
PyLong_FromSsize_t(PY_SSIZE_T_MAX));
SET_SYS_FROM_STRING("float_info",

4
Tools/scripts/h2py.py
View file

@ -96,13 +96,13 @@ def pytify(body):
body = p_char.sub('ord(\\0)', body)
# Compute negative hexadecimal constants
start = 0
UMAX = 2*(sys.maxint+1)
UMAX = 2*(sys.maxsize+1)
while 1:
m = p_hex.search(body, start)
if not m: break
s,e = m.span()
val = long(body[slice(*m.span(1))], 16)
if val > sys.maxint:
if val > sys.maxsize:
val -= UMAX
body = body[:s] + "(" + str(val) + ")" + body[e:]
start = s + 1

2
Tools/unicode/makeunicodedata.py
View file

@ -948,7 +948,7 @@ def dump(t1, t2, shift, bytes):
n >>= 1
maxshift += 1
del n
bytes = sys.maxint # smallest total size so far
bytes = sys.maxsize # smallest total size so far
t = tuple(t) # so slices can be dict keys
for shift in range(maxshift + 1):
t1 = []

2
setup.py
View file

@ -1074,7 +1074,7 @@ class db_found(Exception): pass
['cjkcodecs/_codecs_%s.c' % loc]))
# Dynamic loading module
if sys.maxint == 0x7fffffff:
if sys.maxsize == 0x7fffffff:
# This requires sizeof(int) == sizeof(long) == sizeof(char*)
dl_inc = find_file('dlfcn.h', [], inc_dirs)
if (dl_inc is not None) and (platform not in ['atheos']):