address review: don't raise ValueError (precision specifies the *minimal* range)

Author: skirpichev

Doc/library/string.rst

@@ -464,11 +464,10 @@ used from the field content.
 
 For integer presentation types (excluding ``'c'``), the precision gives the
 minimal number of digits to appear, expanded with an appropriate number of
-leading zeros.  Note that for non-decimal presentation types --- two's
-complements are used to represent signed integers, accepting values in range
-``[-m,m)``, where ``m=2**(k*precision-1)`` and ``k=1,3,4`` for ``'b'``, ``'o'``
-and ``'x'``/``'X'`` types, respectively.  A precision of ``0`` is treated as
-equivalent to a precision of ``1`` here.
+leading zeros.  Note that for non-decimal presentation types --- integer value
+interpreted as ``max(k*precision, number.bit_length())``-bit two's complement,
+where ``k=1,3,4`` for ``'b'``, ``'o'`` and ``'x'``/``'X'`` types, respectively.
+A precision of ``0`` is treated as equivalent to a precision of ``1`` here.
 
 .. versionchanged:: next
    Precision specification allowed for integer presentation types.

Lib/test/test_long.py

@@ -708,8 +708,8 @@ def test__format__(self):
         self.assertEqual(format(1234567890, '_x'), '4996_02d2')
         self.assertEqual(format(1234567890, '_X'), '4996_02D2')
         self.assertEqual(format(8086, '#.8x'), '0x00001f96')
-        self.assertRaises(ValueError, format, 2048, '.3x')
-        self.assertRaises(ValueError, format, -2049, '.3x')
+        self.assertEqual(format(2048, '.3x'), '0800')
+        self.assertEqual(format(-2049, '.3x'), '17ff')
 
         # octal
         self.assertEqual(format(3, "o"), "3")
@@ -725,8 +725,8 @@ def test__format__(self):
         self.assertRaises(ValueError, format, 1234567890, ',o')
         self.assertEqual(format(1234567890, '_o'), '111_4540_1322')
         self.assertEqual(format(18, '#.3o'), '0o022')
-        self.assertRaises(ValueError, format, 256, '.3o')
-        self.assertRaises(ValueError, format, -257, '.3o')
+        self.assertEqual(format(256, '.3o'), '0400')
+        self.assertEqual(format(-257, '.3o'), '1377')
 
         # binary
         self.assertEqual(format(3, "b"), "11")
@@ -744,10 +744,10 @@ def test__format__(self):
         self.assertEqual(format(-12, '.8b'), '11110100')
         self.assertEqual(format(73, '.8b'), '01001001')
         self.assertEqual(format(73, '#.8b'), '0b01001001')
-        self.assertRaises(ValueError, format, 300, '.8b')
-        self.assertRaises(ValueError, format, -200, '.8b')
-        self.assertRaises(ValueError, format, 128, '.8b')
-        self.assertRaises(ValueError, format, -129, '.8b')
+        self.assertEqual(format(300, '.8b'), '100101100')
+        self.assertEqual(format(-200, '.8b'), '100111000')
+        self.assertEqual(format(128, '.8b'), '010000000')
+        self.assertEqual(format(-129, '.8b'), '101111111')
 
         # make sure these are errors
         self.assertRaises(ValueError, format, 3, "1.3c")  # precision disallowed with 'c',

Python/formatter_unicode.c

@@ -1081,20 +1081,26 @@ format_long_internal(PyObject *value, const InternalFormatSpec *format,
 
         /* Do the hard part, converting to a string in a given base */
         if (format->precision != -1) {
+            int64_t precision = Py_MAX(1, format->precision);
+
             /* Use two's complement for 'b', 'o' and 'x' formatting types */
             if (format->type == 'b' || format->type == 'x'
                 || format->type == 'o' || format->type == 'X')
             {
-                int64_t shift = Py_MAX(1, format->precision);
+                int64_t shift = precision;
+                int incr = 1;
 
                 if (format->type == 'x' || format->type == 'X') {
                     shift *= 4;
                 }
                 else if (format->type == 'o') {
                     shift *= 3;
                 }
-                shift--;  /* expected value in range(-2**shift, 2**shift) */
+                shift = Py_MAX(shift, _PyLong_NumBits(value));
+                shift--;
 
+                /* expected value in range(-2**n, 2**n), where n=shift
+                   or n=shift+1 */
                 PyObject *mod = _PyLong_Lshift(PyLong_FromLong(1), shift);
 
                 if (mod == NULL) {
@@ -1106,9 +1112,9 @@ format_long_internal(PyObject *value, const InternalFormatSpec *format,
                         goto done;
                     }
                     if (PyObject_RichCompareBool(value, mod, Py_LT)) {
-                        goto range;
+                        incr++;
                     }
-                    Py_SETREF(mod, _PyLong_Lshift(mod, 1));
+                    Py_SETREF(mod, _PyLong_Lshift(mod, incr));
                     tmp = PyNumber_Subtract(value, mod);
                     Py_DECREF(mod);
                     if (tmp == NULL) {
@@ -1118,16 +1124,12 @@ format_long_internal(PyObject *value, const InternalFormatSpec *format,
                 }
                 else {
                     if (PyObject_RichCompareBool(value, mod, Py_GE)) {
-range:
-                        Py_DECREF(mod);
-                        PyErr_Format(PyExc_ValueError,
-                                     "Expected integer in range(-2**%ld, 2**%ld)",
-                                     shift, shift);
-                        goto done;
+                        incr++;
                     }
                     Py_DECREF(mod);
                     tmp = _PyLong_Format(value, base);
                 }
+                precision += (incr - 1);
             }
             else {
                 tmp = _PyLong_Format(value, base);
@@ -1139,7 +1141,7 @@ format_long_internal(PyObject *value, const InternalFormatSpec *format,
             /* Prepend enough leading zeros (after the sign) */
 
             int sign = PyUnicode_READ_CHAR(tmp, leading_chars_to_skip) == '-';
-            Py_ssize_t tmp2_len = format->precision + leading_chars_to_skip + sign;
+            Py_ssize_t tmp2_len = precision + leading_chars_to_skip + sign;
             Py_ssize_t tmp_len = PyUnicode_GET_LENGTH(tmp);
             Py_ssize_t gap = tmp2_len - tmp_len;