Use Py_DTSF_ALT to control the prefix

Author: skirpichev

Doc/library/stdtypes.rst

@@ -2478,14 +2478,12 @@ Notes:
    inserted before the first digit.
 
    For floats, represent the number by a hexadecimal string in the style
-   ``[±]0xh.[hhh]p±d``, where there is one hexadecimal digit before the
+   ``[±][0x]h[.hhh]p±d``, where there is one hexadecimal digit before the
    decimal-point character and the number of hexadecimal digits after it is
    equal to the precision; if the precision is missing, then the precision is
-   sufficient for an exact representation of the value.  If the precision is
-   zero and the alternate form is not specified, no decimal-point character
-   appears.  The exponent ``d`` is written in decimal, it always contains at
-   least one digit, and it gives the power of 2 by which to multiply the
-   coefficient.
+   sufficient for an exact representation of the value.  The exponent ``d`` is
+   written in decimal, it always contains at least one digit, and it gives the
+   power of 2 by which to multiply the coefficient.
 
 (3)
    The alternate form causes the result to always contain a decimal point, even if

Doc/library/string.rst

@@ -594,19 +594,19 @@ Additionally, for :class:`float` available following representation types:
    | Type    | Meaning                                                  |
    +=========+==========================================================+
    | ``'x'`` | Represent the number by a hexadecimal string in the      |
-   |         | style ``[±]0xh.hhhhp±d``, where there is one hexadecimal |
-   |         | digit before the decimal-point character and the number  |
-   |         | of hexadecimal digits after it is equal to the           |
-   |         | precision; if the precision is missing, then the         |
+   |         | style ``[±][0x]h[.hhhh]p±d``, where there is one         |
+   |         | hexadecimal digit before the decimal-point character and |
+   |         | the number of hexadecimal digits after it is equal to    |
+   |         | the precision; if the precision is missing, then the     |
    |         | precision is sufficient for an exact representation of   |
-   |         | the value.  If the precision is zero and the ``'#'``     |
-   |         | option is not specified, no decimal-point character      |
-   |         | appears.  The exponent ``d`` is written in decimal, it   |
+   |         | the value.  The exponent ``d`` is written in decimal, it |
    |         | always contains at least one digit, and it gives the     |
-   |         | power of 2 by which to multiply the coefficient.         |
+   |         | power of 2 by which to multiply the coefficient.  If the |
+   |         | ``'#'`` option is specified, a leading ``'0x'`` will be  |
+   |         | inserted before an integer part.                         |
    +---------+----------------------------------------------------------+
-   | ``'X'`` | Same as ``'x'``, but uses ``0X`` prefix and ``'P'`` as   |
-   |         | the exponent separator.                                  |
+   | ``'X'`` | Same as ``'x'``, but uses uppercase digits, ``0X``       |
+   |         | prefix and ``'P'`` as the exponent separator.            |
    +---------+----------------------------------------------------------+
 
 .. versionchanged:: 3.13

Lib/test/test_float.py

@@ -702,17 +702,21 @@ def test_format(self):
 
         # hexadecimal format
         x = float.fromhex('0x0.0030p+0')
-        self.assertEqual(format(x, 'x'), '0x1.8p-11')
+        self.assertEqual(format(x, 'x'), '1.8p-11')
         x = float.fromhex('0x0.0040p+0')
-        self.assertEqual(format(x, 'x'), '0x1p-10')
-        self.assertEqual(format(x, '>10x'), '   0x1p-10')
-        self.assertEqual(format(x, '>#10x'), '  0x1.p-10')
-        self.assertEqual(format(x, '<10x'), '0x1p-10   ')
-        self.assertEqual(format(x, '<#10x'), '0x1.p-10  ')
+        self.assertEqual(format(x, 'x'), '1p-10')
+        self.assertEqual(format(x, '>10x'), '     1p-10')
+        self.assertEqual(format(x, '>#10x'), '   0x1p-10')
+        self.assertEqual(format(x, '>010x'), '000001p-10')
+        self.assertEqual(format(x, '>#010x'), '0000x1p-10')
+        self.assertEqual(format(x, '#010x'), '0x0001p-10')
+        self.assertEqual(format(x, '<10x'), '1p-10     ')
+        self.assertEqual(format(x, '<#10x'), '0x1p-10   ')
         x = float.fromhex('0x1.fe12p0')
-        self.assertEqual(format(x, 'x'), '0x1.fe12p+0')
-        self.assertEqual(format(x, '.3x'), '0x1.fe1p+0')
-        self.assertEqual(format(x, '.1x'), '0x1p+1')
+        self.assertEqual(format(x, 'x'), '1.fe12p+0')
+        self.assertEqual(format(x, '.3x'), '1.fe1p+0')
+        self.assertEqual(format(x, '.1x'), '1p+1')
+        self.assertEqual(format(x, '#.1x'), '0x1p+1')
 
         # conversion to string should fail
         self.assertRaises(ValueError, format, 3.0, "s")

Lib/test/test_format.py

@@ -270,11 +270,15 @@ def test_common_format(self):
         testcommon('%#g', 1.1, '1.10000')
 
         # hexadecimal floats
-        testcommon("%x", 3.14, '0x1.91eb851eb851fp+1')
-        testcommon("%X", 3.14, '0X1.91EB851EB851FP+1')
-        testcommon("%+.3x", 3.14, '+0x1.91fp+1')
-        testcommon("%x", -0.5, '-0x1p-1')
-        testcommon("%#x", -0.5, '-0x1.p-1')
+        testcommon("%x", 3.14, '1.91eb851eb851fp+1')
+        testcommon("%#x", 3.14, '0x1.91eb851eb851fp+1')
+        testcommon("%X", 3.14, '1.91EB851EB851FP+1')
+        testcommon("%+.3x", 3.14, '+1.91fp+1')
+        testcommon("%x", -0.5, '-1p-1')
+        testcommon("%#x", -0.5, '-0x1p-1')
+        x = float.fromhex('0x0.003p+0')
+        testcommon("%040x", x, '0000000000000000000000000000000001.8p-11')
+        testcommon("%#040x", x, '0x00000000000000000000000000000001.8p-11')
 
         if verbose:
             print('Testing exceptions')

Lib/test/test_peepholer.py

@@ -567,7 +567,7 @@ def format(fmt, *values):
         self.assertEqual(format('x = %s%% %%%%', 1234), 'x = 1234% %%')
         self.assertEqual(format('x = %s!', '%% %s'), 'x = %% %s!')
         self.assertEqual(format('x = %s, y = %d', 12, 34), 'x = 12, y = 34')
-        self.assertEqual(format('x = %x', 1234.56), 'x = 0x1.34a3d70a3d70ap+10')
+        self.assertEqual(format('x = %x', 1234.56), 'x = 1.34a3d70a3d70ap+10')
 
     def test_format_errors(self):
         with self.assertRaisesRegex(TypeError,

Lib/test/test_str.py

@@ -1564,8 +1564,8 @@ def __int__(self):
         self.assertEqual('%X' % letter_m, '6D')
         self.assertEqual('%o' % letter_m, '155')
         self.assertEqual('%c' % letter_m, 'm')
-        self.assertEqual('%x' % 3.14, '0x1.91eb851eb851fp+1')
-        self.assertEqual('%X' % 2.11, '0X1.0E147AE147AE1P+1')
+        self.assertEqual('%x' % 3.14, '1.91eb851eb851fp+1')
+        self.assertEqual('%X' % 2.11, '1.0E147AE147AE1P+1')
         self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
         self.assertRaisesRegex(TypeError, '%x format: an integer or float is required, not PseudoFloat', operator.mod, '%x', pi)
         self.assertRaisesRegex(TypeError, '%x format: an integer or float is required, not complex', operator.mod, '%x', 3j)

Objects/floatobject.c

@@ -1219,7 +1219,7 @@ float_hex_impl(PyObject *self)
 {
     PyObject *result = NULL;
     double x = PyFloat_AS_DOUBLE(self);
-    char *buf = PyOS_double_to_string(x, 'x', -1, 0, NULL);
+    char *buf = PyOS_double_to_string(x, 'x', -1, Py_DTSF_ALT, NULL);
 
     if (buf) {
         result = PyUnicode_FromString(buf);

Python/formatter_unicode.c

@@ -1047,6 +1047,7 @@ format_float_internal(PyObject *value,
     Py_ssize_t n_digits;
     Py_ssize_t n_remainder;
     Py_ssize_t n_total;
+    Py_ssize_t n_prefix = 0;
     int has_decimal;
     double val;
     int precision, default_precision = 6;
@@ -1059,7 +1060,7 @@ format_float_internal(PyObject *value,
     Py_UCS4 maxchar = 127;
     Py_UCS4 sign_char = '\0';
     int float_type; /* Used to see if we have a nan, inf, or regular float. */
-    PyObject *unicode_tmp = NULL;
+    PyObject *unicode_tmp = NULL, *prefix = NULL;
 
     /* Locale settings, either from the actual locale or
        from a hard-code pseudo-locale */
@@ -1148,6 +1149,14 @@ format_float_internal(PyObject *value,
         ++index;
         --n_digits;
     }
+    if (PyUnicode_READ_CHAR(unicode_tmp, index) == '0'
+        && (PyUnicode_READ_CHAR(unicode_tmp, index + 1) == 'x'
+            || PyUnicode_READ_CHAR(unicode_tmp, index + 1) == 'X')) {
+        n_prefix = 2;
+        index += 2;
+        n_digits -= 2;
+        prefix = unicode_tmp;
+    }
 
     /* Determine if we have any "remainder" (after the digits, might include
        decimal or exponent or both (or neither)) */
@@ -1160,7 +1169,7 @@ format_float_internal(PyObject *value,
         goto done;
 
     /* Calculate how much memory we'll need. */
-    n_total = calc_number_widths(&spec, 0, sign_char, index,
+    n_total = calc_number_widths(&spec, n_prefix, sign_char, index,
                                  index + n_digits, n_remainder, has_decimal,
                                  &locale, format, &maxchar);
     if (n_total == -1) {
@@ -1174,7 +1183,7 @@ format_float_internal(PyObject *value,
     /* Populate the memory. */
     result = fill_number(writer, &spec,
                          unicode_tmp, index,
-                         NULL, 0, format->fill_char,
+                         prefix, n_prefix ? index - 2 : 0, format->fill_char,
                          &locale, 0);
 
 done:

Python/pystrtod.c

@@ -980,10 +980,12 @@ _Py_dg_dtoa_hex(double x, int precision, int always_add_sign,
         s[si] = '+';
         si++;
     }
-    s[si] = '0';
-    si++;
-    s[si] = upper ? 'X' : 'x';
-    si++;
+    if (use_alt_formatting) {
+        s[si] = '0';
+        si++;
+        s[si] = upper ? 'X' : 'x';
+        si++;
+    }
 
     /* mantissa */
     const char *hexmap = upper ? Py_hexdigits_upper : Py_hexdigits;
@@ -1004,7 +1006,7 @@ _Py_dg_dtoa_hex(double x, int precision, int always_add_sign,
     while (s[si] == '0') {
         si--;
     }
-    if (s[si] != '.' || use_alt_formatting) {
+    if (s[si] != '.') {
         si++;
     }