cleanup printf-style implementation

Author: skirpichev

Lib/test/test_float.py

@@ -703,6 +703,8 @@ def test_format(self):
         # hexadecimal format
         x = float.fromhex('0x0.0030p+0')
         self.assertEqual(format(x, 'x'), '1.8p-11')
+        x = float.fromhex('0x0.1p-1022')  # subnormal
+        self.assertEqual(format(x, 'x'), '0.1p-1022')
         x = float.fromhex('0x0.0040p+0')
         self.assertEqual(format(x, 'x'), '1p-10')
         self.assertEqual(format(x, '>10x'), '     1p-10')

Lib/test/test_format.py

@@ -293,6 +293,8 @@ def test_common_format(self):
                         "%x format: an integer or float is required, not str")
         test_exc_common('%d', 1j, TypeError,
                         "%d format: a real number is required, not complex")
+        test_exc_common('%x', 1j, TypeError,
+                        "%x format: an integer or float is required, not complex")
 
     def test_str_format(self):
         testformat("%r", "\u0378", "'\\u0378'")  # non printable

Objects/bytesobject.c

@@ -466,30 +466,13 @@ formatlong(PyObject *v, int flags, int prec, int type)
             Py_DECREF(iobj);
             return result;
         }
-        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
-            if (type == 'x' || type == 'X') {
-                PyErr_Clear();
-
-                PyObject *fobj = PyNumber_Float(v);
-                if (!fobj) {
-                    goto wrongtype;
-                }
-                formatfloat(fobj, flags, prec, type, &result, NULL, NULL);
-                if (!result) {
-                    return NULL;
-                }
-                return PyUnicode_FromEncodedObject(result, NULL, NULL);
-            }
-        }
-        else {
+        if (!PyErr_ExceptionMatches(PyExc_TypeError))
             return NULL;
-        }
     }
-  wrongtype:
     PyErr_Format(PyExc_TypeError,
         "%%%c format: %s is required, not %.200s", type,
-        (type == 'x' || type == 'X') ?
-        "an integer or float" : type == 'o' ? "an integer": "a real number",
+        (type == 'o' || type == 'x' || type == 'X') ? "an integer"
+                                                    : "a real number",
         Py_TYPE(v)->tp_name);
     return NULL;
 }
@@ -886,8 +869,24 @@ _PyBytes_FormatEx(const char *format, Py_ssize_t format_len,
                 }
 
                 temp = formatlong(v, flags, prec, c);
-                if (!temp)
+                if (!temp) {
+                    if ((c == 'x' || c == 'X') &&
+                        PyErr_ExceptionMatches(PyExc_TypeError))
+                    {
+                        PyErr_Clear();
+                        if (PyNumber_Check(v)) {
+                            PyObject *fobj = PyNumber_Float(v);
+                            if (fobj) {
+                                v = fobj;
+                                goto dofloats;
+                            }
+                        }
+                        PyErr_Format(PyExc_TypeError,
+                            "%%%c format: an integer or float is required, not %.200s",
+                            c, Py_TYPE(v)->tp_name);
+                    }
                     goto error;
+                }
                 assert(PyUnicode_IS_ASCII(temp));
                 pbuf = (const char *)PyUnicode_1BYTE_DATA(temp);
                 len = PyUnicode_GET_LENGTH(temp);
@@ -896,6 +895,7 @@ _PyBytes_FormatEx(const char *format, Py_ssize_t format_len,
                     fill = '0';
                 break;
 
+          dofloats:
             case 'e':
             case 'E':
             case 'f':

Objects/unicodeobject.c

@@ -13901,18 +13901,8 @@ mainformatlong(PyObject *v,
             iobj = PyNumber_Long(v);
         }
         if (iobj == NULL ) {
-            if (PyErr_ExceptionMatches(PyExc_TypeError)) {
-                if (type == 'x' || type == 'X') {
-                    PyErr_Clear();
-
-                    PyObject *fobj = PyNumber_Float(v);
-                    if (!fobj) {
-                        goto wrongtype;
-                    }
-                    return formatfloat(fobj, arg, p_output, NULL);
-                }
+            if (PyErr_ExceptionMatches(PyExc_TypeError))
                 goto wrongtype;
-            }
             return -1;
         }
         assert(PyLong_Check(iobj));
@@ -13967,15 +13957,10 @@ mainformatlong(PyObject *v,
     switch(type)
     {
         case 'o':
-            PyErr_Format(PyExc_TypeError,
-                    "%%%c format: an integer is required, "
-                    "not %.200s",
-                    type, Py_TYPE(v)->tp_name);
-            break;
         case 'x':
         case 'X':
             PyErr_Format(PyExc_TypeError,
-                    "%%%c format: an integer or float is required, "
+                    "%%%c format: an integer is required, "
                     "not %.200s",
                     type, Py_TYPE(v)->tp_name);
             break;
@@ -14266,12 +14251,30 @@ unicode_format_arg_format(struct unicode_formatter_t *ctx,
     case 'X':
     {
         int ret = mainformatlong(v, arg, p_str, writer);
-        if (ret != 0)
+        if (ret != 0) {
+            if (ret == -1 && (arg->ch == 'x' || arg->ch == 'X') &&
+                PyErr_ExceptionMatches(PyExc_TypeError))
+            {
+                PyErr_Clear();
+                if (PyNumber_Check(v)) {
+                    PyObject *fobj = PyNumber_Float(v);
+                    if (fobj) {
+                        v = fobj;
+                        goto dofloats;
+                    }
+                }
+                PyErr_Format(PyExc_TypeError,
+                        "%%%c format: an integer or float is required, "
+                        "not %.200s",
+                        arg->ch, Py_TYPE(v)->tp_name);
+            }
             return ret;
+        }
         arg->sign = 1;
         break;
     }
 
+  dofloats:
     case 'e':
     case 'E':
     case 'f':