use \character{L}, since the letter \character{l} looks too much like the
digit \character{1}.
-Plain integer decimal literals that are above the largest representable
-plain integer (e.g., 2147483647 when using 32-bit arithmetic) are accepted
-as if they were long integers instead. Octal and hexadecimal literals
-behave similarly, but when in the range just above the largest representable
-plain integer but below the largest unsigned 32-bit number (on a machine
-using 32-bit arithmetic), 4294967296, they are taken as the negative plain
-integer obtained by subtracting 4294967296 from their unsigned value. There
-is no limit for long integer literals apart from what can be stored in
-available memory. For example, 0xdeadbeef is taken, on a 32-bit machine,
-as the value -559038737, while 0xdeadbeeffeed is taken as the value
-244837814107885L.
+Plain integer literals that are above the largest representable plain
+integer (e.g., 2147483647 when using 32-bit arithmetic) are accepted
+as if they were long integers instead.\footnote{In versions of Python
+prior to 2.4, octal and hexadecimal literals in the range just above
+the largest representable plain integer but below the largest unsigned
+32-bit number (on a machine using 32-bit arithmetic), 4294967296, were
+taken as the negative plain integer obtained by subtracting 4294967296
+from their unsigned value.} There is no limit for long integer
+literals apart from what can be stored in available memory.
Some examples of plain integer literals (first row) and long integer
literals (second and third rows):
\begin{verbatim}
-7 2147483647 0177 0x80000000
+7 2147483647 0177
3L 79228162514264337593543950336L 0377L 0x100000000L
- 79228162514264337593543950336 0xdeadbeeffeed
+ 79228162514264337593543950336 0xdeadbeef
\end{verbatim}
def test_hex(self):
self.assertEqual(hex(16), '0x10')
self.assertEqual(hex(16L), '0x10L')
- self.assertEqual(len(hex(-1)), len(hex(sys.maxint)))
- self.assert_(hex(-16) in ('0xfffffff0', '0xfffffffffffffff0'))
+ self.assertEqual(hex(-16), '-0x10')
self.assertEqual(hex(-16L), '-0x10L')
self.assertRaises(TypeError, hex, {})
def test_oct(self):
self.assertEqual(oct(100), '0144')
self.assertEqual(oct(100L), '0144L')
- self.assert_(oct(-100) in ('037777777634', '01777777777777777777634'))
+ self.assertEqual(oct(-100), '-0144')
self.assertEqual(oct(-100L), '-0144L')
self.assertRaises(TypeError, oct, ())
def test_unary_minus(self):
# Verify treatment of unary minus on negative numbers SF bug #660455
- warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning)
- warnings.filterwarnings("ignore", "hex.* of negative int", FutureWarning)
- # XXX Of course the following test will have to be changed in Python 2.4
- # This test is in a <string> so the filterwarnings() can affect it
- all_one_bits = '0xffffffff'
- if sys.maxint != 2147483647:
+ if sys.maxint == 2147483647:
+ # 32-bit machine
+ all_one_bits = '0xffffffff'
+ self.assertEqual(eval(all_one_bits), 4294967295L)
+ self.assertEqual(eval("-" + all_one_bits), -4294967295L)
+ elif sys.maxint == 9223372036854775807:
+ # 64-bit machine
all_one_bits = '0xffffffffffffffff'
- self.assertEqual(eval(all_one_bits), -1)
- self.assertEqual(eval("-" + all_one_bits), 1)
+ self.assertEqual(eval(all_one_bits), 18446744073709551615L)
+ self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
+ else:
+ self.fail("How many bits *does* this machine have???")
def test_sequence_unpacking_error(self):
# Verify sequence packing/unpacking with "or". SF bug #757818
testboth("%#X", 0L, "0X0")
testboth("%x", 0x42, "42")
-# testboth("%x", -0x42, "ffffffbe") # specific to 32-bit boxes; see below
+testboth("%x", -0x42, "-42")
testboth("%x", 0x42L, "42")
testboth("%x", -0x42L, "-42")
testboth("%o", 042, "42")
-# testboth("%o", -042, "37777777736") # specific to 32-bit boxes; see below
+testboth("%o", -042, "-42")
testboth("%o", 042L, "42")
testboth("%o", -042L, "-42")
pass
else:
raise TestFailed, '"%*d"%(sys.maxint, -127) should fail'
- # (different things go wrong on a 64 bit box...)
- testboth("%x", -0x42, "ffffffbe")
- testboth("%o", -042, "37777777736")
if maxint == 2147483647:
# The following test will start to fail in Python 2.4;
# change the 020000000000 to -020000000000
- if -2147483647-1 != 020000000000: raise TestFailed, 'max negative int'
+ if -2147483647-1 != -020000000000: raise TestFailed, 'max negative int'
# XXX -2147483648
- if 037777777777 != -1: raise TestFailed, 'oct -1'
- if 0xffffffff != -1: raise TestFailed, 'hex -1'
+ if 037777777777 < 0: raise TestFailed, 'large oct'
+ if 0xffffffff < 0: raise TestFailed, 'large hex'
for s in '2147483648', '040000000000', '0x100000000':
try:
x = eval(s)
except OverflowError:
print "OverflowError on huge integer literal " + `s`
elif eval('maxint == 9223372036854775807'):
- if eval('-9223372036854775807-1 != 01000000000000000000000'):
+ if eval('-9223372036854775807-1 != -01000000000000000000000'):
raise TestFailed, 'max negative int'
- if eval('01777777777777777777777') != -1: raise TestFailed, 'oct -1'
- if eval('0xffffffffffffffff') != -1: raise TestFailed, 'hex -1'
+ if eval('01777777777777777777777') < 0: raise TestFailed, 'large oct'
+ if eval('0xffffffffffffffff') < 0: raise TestFailed, 'large hex'
for s in '9223372036854775808', '02000000000000000000000', \
'0x10000000000000000':
try:
"""Test correct treatment of hex/oct constants.
This is complex because of changes due to PEP 237.
-
-Some of these tests will have to change in Python 2.4!
"""
import sys
self.assertEqual(-0x7fffffffffffffff, -9223372036854775807)
def test_hex_unsigned(self):
- # This test is in a <string> so we can ignore the warnings
- exec """if 1:
if platform_long_is_32_bits:
- # Positive-looking constants with negavive values
- self.assertEqual(0x80000000, -2147483648L)
- self.assertEqual(0xffffffff, -1)
+ # Positive constants
+ self.assertEqual(0x80000000, 2147483648L)
+ self.assertEqual(0xffffffff, 4294967295L)
# Ditto with a minus sign and parentheses
- self.assertEqual(-(0x80000000), 2147483648L)
- self.assertEqual(-(0xffffffff), 1)
+ self.assertEqual(-(0x80000000), -2147483648L)
+ self.assertEqual(-(0xffffffff), -4294967295L)
# Ditto with a minus sign and NO parentheses
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
- self.assertEqual(-0x80000000, 2147483648L)
- self.assertEqual(-0xffffffff, 1)
+ self.assertEqual(-0x80000000, -2147483648L)
+ self.assertEqual(-0xffffffff, -4294967295L)
else:
- # Positive-looking constants with negavive values
- self.assertEqual(0x8000000000000000, -9223372036854775808L)
- self.assertEqual(0xffffffffffffffff, -1)
+ # Positive constants
+ self.assertEqual(0x8000000000000000, 9223372036854775808L)
+ self.assertEqual(0xffffffffffffffff, 18446744073709551615L)
# Ditto with a minus sign and parentheses
- self.assertEqual(-(0x8000000000000000), 9223372036854775808L)
- self.assertEqual(-(0xffffffffffffffff), 1)
+ self.assertEqual(-(0x8000000000000000), -9223372036854775808L)
+ self.assertEqual(-(0xffffffffffffffff), -18446744073709551615L)
# Ditto with a minus sign and NO parentheses
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
- self.assertEqual(-0x8000000000000000, 9223372036854775808L)
- self.assertEqual(-0xffffffffffffffff, 1)
- \n"""
+ self.assertEqual(-0x8000000000000000, -9223372036854775808L)
+ self.assertEqual(-0xffffffffffffffff, -18446744073709551615L)
def test_oct_baseline(self):
# Baseline tests
self.assertEqual(-0777777777777777777777, -9223372036854775807)
def test_oct_unsigned(self):
- # This test is in a <string> so we can ignore the warnings
- exec """if 1:
if platform_long_is_32_bits:
- # Positive-looking constants with negavive values
- self.assertEqual(020000000000, -2147483648L)
- self.assertEqual(037777777777, -1)
+ # Positive constants
+ self.assertEqual(020000000000, 2147483648L)
+ self.assertEqual(037777777777, 4294967295L)
# Ditto with a minus sign and parentheses
- self.assertEqual(-(020000000000), 2147483648L)
- self.assertEqual(-(037777777777), 1)
+ self.assertEqual(-(020000000000), -2147483648L)
+ self.assertEqual(-(037777777777), -4294967295L)
# Ditto with a minus sign and NO parentheses
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
- self.assertEqual(-020000000000, 2147483648L)
- self.assertEqual(-037777777777, 1)
+ self.assertEqual(-020000000000, -2147483648L)
+ self.assertEqual(-037777777777, -4294967295L)
else:
- # Positive-looking constants with negavive values
- self.assertEqual(01000000000000000000000, -9223372036854775808L)
- self.assertEqual(01777777777777777777777, -1)
+ # Positive constants
+ self.assertEqual(01000000000000000000000, 9223372036854775808L)
+ self.assertEqual(01777777777777777777777, 18446744073709551615L)
# Ditto with a minus sign and parentheses
- self.assertEqual(-(01000000000000000000000), 9223372036854775808L)
- self.assertEqual(-(01777777777777777777777), 1)
+ self.assertEqual(-(01000000000000000000000), -9223372036854775808L)
+ self.assertEqual(-(01777777777777777777777), -18446744073709551615L)
# Ditto with a minus sign and NO parentheses
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
- self.assertEqual(-01000000000000000000000, 9223372036854775808L)
- self.assertEqual(-01777777777777777777777, 1)
- \n"""
+ self.assertEqual(-01000000000000000000000, -9223372036854775808L)
+ self.assertEqual(-01777777777777777777777, -18446744073709551615L)
def test_main():
test_support.run_unittest(TextHexOct)
Core and builtins
-----------------
+- Removed FutureWarnings related to hex/oct literals and conversions
+ and left shifts. (Thanks to Kalle Svensson for SF patch 849227.)
+ This addresses most of the remaining semantic changes promised by
+ PEP 237, except for repr() of a long, which still shows the trailing
+ 'L'. The PEP appears to promise warnings for operations that
+ changed semantics compared to Python 2.3, but this is not
+ implemented; we've suffered through enough warnings related to
+ hex/oct literals and I think it's best to be silent now.
+
- For str and unicode objects, the ljust(), center(), and rjust()
methods now accept an optional argument specifying a fill
character other than a space.
char *end;
long x;
char buffer[256]; /* For errors */
- int warn = 0;
if ((base != 0 && base < 2) || base > 36) {
PyErr_SetString(PyExc_ValueError,
if (base == 0 && s[0] == '0') {
x = (long) PyOS_strtoul(s, &end, base);
if (x < 0)
- warn = 1;
+ return PyLong_FromString(s, pend, base);
}
else
x = PyOS_strtol(s, &end, base);
return NULL;
return PyLong_FromString(s, pend, base);
}
- if (warn) {
- if (PyErr_Warn(PyExc_FutureWarning,
- "int('0...', 0): sign will change in Python 2.4") < 0)
- return NULL;
- }
if (pend)
*pend = end;
return PyInt_FromLong(x);
if (a == 0 || b == 0)
return int_pos(v);
if (b >= LONG_BIT) {
- if (PyErr_Warn(PyExc_FutureWarning,
- "x<<y losing bits or changing sign "
- "will return a long in Python 2.4 and up") < 0)
- return NULL;
- return PyInt_FromLong(0L);
+ return PyNumber_Lshift(PyLong_FromLong(PyInt_AS_LONG(v)),
+ PyLong_FromLong(PyInt_AS_LONG(w)));
}
c = a << b;
if (a != Py_ARITHMETIC_RIGHT_SHIFT(long, c, b)) {
- if (PyErr_Warn(PyExc_FutureWarning,
- "x<<y losing bits or changing sign "
- "will return a long in Python 2.4 and up") < 0)
- return NULL;
+ return PyNumber_Lshift(PyLong_FromLong(PyInt_AS_LONG(v)),
+ PyLong_FromLong(PyInt_AS_LONG(w)));
}
return PyInt_FromLong(c);
}
{
char buf[100];
long x = v -> ob_ival;
- if (x < 0) {
- if (PyErr_Warn(PyExc_FutureWarning,
- "hex()/oct() of negative int will return "
- "a signed string in Python 2.4 and up") < 0)
- return NULL;
- }
- if (x == 0)
+ if (x < 0)
+ PyOS_snprintf(buf, sizeof(buf), "-0%lo", -x);
+ else if (x == 0)
strcpy(buf, "0");
else
PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
{
char buf[100];
long x = v -> ob_ival;
- if (x < 0) {
- if (PyErr_Warn(PyExc_FutureWarning,
- "hex()/oct() of negative int will return "
- "a signed string in Python 2.4 and up") < 0)
- return NULL;
- }
- PyOS_snprintf(buf, sizeof(buf), "0x%lx", x);
+ if (x < 0)
+ PyOS_snprintf(buf, sizeof(buf), "-0x%lx", -x);
+ else
+ PyOS_snprintf(buf, sizeof(buf), "0x%lx", x);
return PyString_FromString(buf);
}
worst case length = 3 + 19 (worst len of INT_MAX on 64-bit machine)
+ 1 + 1 = 24 */
char fmt[64]; /* plenty big enough! */
+ char *sign;
long x;
x = PyInt_AsLong(v);
PyErr_SetString(PyExc_TypeError, "int argument required");
return -1;
}
- if (x < 0 && type != 'd' && type != 'i') {
- if (PyErr_Warn(PyExc_FutureWarning,
- "%u/%o/%x/%X of negative int will return "
- "a signed string in Python 2.4 and up") < 0)
- return -1;
+ if (x < 0 && type == 'u') {
+ type = 'd';
}
+ if (x < 0 && (type == 'x' || type == 'X' || type == 'o'))
+ sign = "-";
+ else
+ sign = "";
if (prec < 0)
prec = 1;
* Note that this is the same approach as used in
* formatint() in unicodeobject.c
*/
- PyOS_snprintf(fmt, sizeof(fmt), "0%c%%.%dl%c",
- type, prec, type);
+ PyOS_snprintf(fmt, sizeof(fmt), "%s0%c%%.%dl%c",
+ sign, type, prec, type);
}
else {
- PyOS_snprintf(fmt, sizeof(fmt), "%%%s.%dl%c",
- (flags&F_ALT) ? "#" : "",
+ PyOS_snprintf(fmt, sizeof(fmt), "%s%%%s.%dl%c",
+ sign, (flags&F_ALT) ? "#" : "",
prec, type);
}
- /* buf = '+'/'-'/'0'/'0x' + '[0-9]'*max(prec, len(x in octal))
- * worst case buf = '0x' + [0-9]*prec, where prec >= 11
+ /* buf = '+'/'-'/'' + '0'/'0x'/'' + '[0-9]'*max(prec, len(x in octal))
+ * worst case buf = '-0x' + [0-9]*prec, where prec >= 11
*/
- if (buflen <= 13 || buflen <= (size_t)2 + (size_t)prec) {
+ if (buflen <= 14 || buflen <= (size_t)3 + (size_t)prec) {
PyErr_SetString(PyExc_OverflowError,
"formatted integer is too long (precision too large?)");
return -1;
}
- PyOS_snprintf(buf, buflen, fmt, x);
+ if (sign[0])
+ PyOS_snprintf(buf, buflen, fmt, -x);
+ else
+ PyOS_snprintf(buf, buflen, fmt, x);
return strlen(buf);
}
prec, c, &pbuf, &len);
if (!temp)
goto error;
- /* unbounded ints can always produce
- a sign character! */
sign = 1;
}
else {
flags, prec, c, v);
if (len < 0)
goto error;
- /* only d conversion is signed */
- sign = c == 'd';
+ sign = 1;
}
if (flags & F_ZERO)
fill = '0';
* = 24
*/
char fmt[64]; /* plenty big enough! */
+ char *sign;
long x;
x = PyInt_AsLong(v);
if (x == -1 && PyErr_Occurred())
return -1;
- if (x < 0 && type != 'd' && type != 'i') {
- if (PyErr_Warn(PyExc_FutureWarning,
- "%u/%o/%x/%X of negative int will return "
- "a signed string in Python 2.4 and up") < 0)
- return -1;
+ if (x < 0 && type == 'u') {
+ type = 'd';
}
+ if (x < 0 && (type == 'x' || type == 'X' || type == 'o'))
+ sign = "-";
+ else
+ sign = "";
if (prec < 0)
prec = 1;
- /* buf = '+'/'-'/'0'/'0x' + '[0-9]'*max(prec,len(x in octal))
- * worst case buf = '0x' + [0-9]*prec, where prec >= 11
+ /* buf = '+'/'-'/'' + '0'/'0x'/'' + '[0-9]'*max(prec, len(x in octal))
+ * worst case buf = '-0x' + [0-9]*prec, where prec >= 11
*/
- if (buflen <= 13 || buflen <= (size_t)2 + (size_t)prec) {
+ if (buflen <= 14 || buflen <= (size_t)3 + (size_t)prec) {
PyErr_SetString(PyExc_OverflowError,
"formatted integer is too long (precision too large?)");
return -1;
* Note that this is the same approach as used in
* formatint() in stringobject.c
*/
- PyOS_snprintf(fmt, sizeof(fmt), "0%c%%.%dl%c",
- type, prec, type);
+ PyOS_snprintf(fmt, sizeof(fmt), "%s0%c%%.%dl%c",
+ sign, type, prec, type);
}
else {
- PyOS_snprintf(fmt, sizeof(fmt), "%%%s.%dl%c",
- (flags&F_ALT) ? "#" : "",
+ PyOS_snprintf(fmt, sizeof(fmt), "%s%%%s.%dl%c",
+ sign, (flags&F_ALT) ? "#" : "",
prec, type);
}
- return usprintf(buf, fmt, x);
+ if (sign[0])
+ return usprintf(buf, fmt, -x);
+ else
+ return usprintf(buf, fmt, x);
}
static int
goto onError;
pbuf = PyUnicode_AS_UNICODE(temp);
len = PyUnicode_GET_SIZE(temp);
- /* unbounded ints can always produce
- a sign character! */
sign = 1;
}
else {
flags, prec, c, v);
if (len < 0)
goto onError;
- /* only d conversion is signed */
- sign = c == 'd';
+ sign = 1;
}
if (flags & F_ZERO)
fill = '0';
if (s[0] == '0') {
x = (long) PyOS_strtoul(s, &end, 0);
if (x < 0 && errno == 0) {
- if (PyErr_WarnExplicit(
- PyExc_FutureWarning,
- "hex/oct constants > sys.maxint "
- "will return positive values "
- "in Python 2.4 and up",
- /* XXX: Give WarnExplicit
- a const char* argument. */
- (char*)c->c_filename,
- c->c_lineno,
- NULL,
- NULL) < 0)
- return NULL;
- errno = 0; /* Might be changed by PyErr_Warn() */
+ return PyLong_FromString(s, (char **)0, 0);
}
}
else
projects / thirdparty / Python / cpython.git / commitdiff
