Commits

ericvsmith committed f283e3b

Issue 3382: Make '%F' and float.__format__('F') convert results to upper case.

  • Participants
  • Parent commits a29c86c
  • Branches legacy-trunk

Comments (0)

Files changed (8)

File Doc/library/stdtypes.rst

 +------------+-----------------------------------------------------+-------+
 | ``'E'``    | Floating point exponential format (uppercase).      | \(3)  |
 +------------+-----------------------------------------------------+-------+
-| ``'f'``    | Floating point decimal format.                      | \(3)  |
+| ``'f'``    | Floating point decimal format (lowercase).          | \(3)  |
 +------------+-----------------------------------------------------+-------+
-| ``'F'``    | Floating point decimal format.                      | \(3)  |
+| ``'F'``    | Floating point decimal format (uppercase).          | \(3)  |
 +------------+-----------------------------------------------------+-------+
 | ``'g'``    | Floating point format. Uses lowercase exponential   | \(4)  |
 |            | format if exponent is less than -4 or not less than |       |

File Doc/library/string.rst

    | ``'e'`` | Exponent notation. Prints the number in scientific       |
    |         | notation using the letter 'e' to indicate the exponent.  |
    +---------+----------------------------------------------------------+
-   | ``'E'`` | Exponent notation. Same as ``'e'`` except it uses an     |
-   |         | upper case 'E' as the separator character.               |
+   | ``'E'`` | Exponent notation. Same as ``'e'`` except it converts    |
+   |         | the number to upper case.                                |
    +---------+----------------------------------------------------------+
    | ``'f'`` | Fixed point. Displays the number as a fixed-point        |
    |         | number.                                                  |
    +---------+----------------------------------------------------------+
-   | ``'F'`` | Fixed point. Same as ``'f'``.                            |
+   | ``'F'`` | Fixed point. Same as ``'f'`` except it converts the      |
+   |         | number to upper case.                                    |
    +---------+----------------------------------------------------------+
    | ``'g'`` | General format. This prints the number as a fixed-point  |
    |         | number, unless the number is too large, in which case    |

File Lib/test/test_format.py

         testboth("%#.*F", (110, -1.e+100/3.))
         overflowrequired = 0
 
+        # check for %f and %F
+        testboth("%f", (1.0,), "1.000000")
+        testboth("%F", (1.0,), "1.000000")
+        testboth("%f", (1e100,), "1e+100")
+        testboth("%F", (1e100,), "1E+100")
+        testboth("%f", (1e100,), "1e+100")
+        testboth("%F", (1e100,), "1E+100")
+        testboth("%f", (float('nan'),), "nan")
+        testboth("%F", (float('nan'),), "NAN")
+        testboth("%f", (float('inf'),), "inf")
+        testboth("%F", (float('inf'),), "INF")
+
         # Formatting of long integers. Overflow is not ok
         overflowok = 0
         testboth("%x", 10L, "a")

File Lib/test/test_types.py

         test( 1.0, '+f', '+1.000000')
         test(-1.0, '+f', '-1.000000')
         test(1.1234e90, 'f', '1.1234e+90')
-        test(1.1234e90, 'F', '1.1234e+90')
+        test(1.1234e90, 'F', '1.1234E+90')
         test(1.1234e200, 'f', '1.1234e+200')
-        test(1.1234e200, 'F', '1.1234e+200')
+        test(1.1234e200, 'F', '1.1234E+200')
+        test(1e100, 'x<20f', '1e+100xxxxxxxxxxxxxx')
+        test(1e100, 'x<20F', '1E+100xxxxxxxxxxxxxx')
+        test(float('nan'), 'f', 'nan')
+        test(float('nan'), 'F', 'NAN')
+        test(float('inf'), 'f', 'inf')
+        test(float('inf'), 'F', 'INF')
+        test(float('-inf'), 'f', '-inf')
+        test(float('-inf'), 'F', '-INF')
 
         test( 1.0, 'e', '1.000000e+00')
         test(-1.0, 'e', '-1.000000e+00')
 Core and Builtins
 -----------------
 
+- Issue #3382: Make '%F' and float.__format__('F') convert results
+  to uppercase.
+
 - Issue #3156: Fix inconsistent behavior of the bytearray type: all
   its methods now allow for items objects that can be converted to
   an integer using operator.index().

File Objects/stringlib/formatter.h

     /* first, do the conversion as 8-bit chars, using the platform's
        snprintf.  then, if needed, convert to unicode. */
 
-    /* 'F' is the same as 'f', per the PEP */
-    if (type == 'F')
-        type = 'f';
-
     x = PyFloat_AsDouble(value);
 
     if (x == -1.0 && PyErr_Occurred())
 
     if (precision < 0)
         precision = 6;
-    if (type == 'f' && (fabs(x) / 1e25) >= 1e25)
-        type = 'g';
+    if ((type == 'f' || type == 'F') && (fabs(x) / 1e25) >= 1e25) {
+	if (type == 'f')
+	    type = 'g';
+	else
+	    type = 'G';
+    }
 
     /* cast "type", because if we're in unicode we need to pass a
        8-bit char.  this is safe, because we've restricted what "type"

File Objects/stringobject.c

 	}
 	if (prec < 0)
 		prec = 6;
-	if (type == 'f' && fabs(x)/1e25 >= 1e25)
-		type = 'g';
+	if ((type == 'f' || type == 'F') && (fabs(x) / 1e25) >= 1e25) {
+		if (type == 'f')
+			type = 'g';
+		else
+			type = 'G';
+	}
 	/* Worst case length calc to ensure no buffer overrun:
 
 	   'g' formats:
 	*/
 	if (((type == 'g' || type == 'G') &&
               buflen <= (size_t)10 + (size_t)prec) ||
-	    (type == 'f' && buflen <= (size_t)53 + (size_t)prec)) {
+	    ((type == 'f' || type == 'F') &&
+	      buflen <= (size_t)53 + (size_t)prec)) {
 		PyErr_SetString(PyExc_OverflowError,
 			"formatted float is too long (precision too large?)");
 		return -1;
 			case 'F':
 			case 'g':
 			case 'G':
-				if (c == 'F')
-					c = 'f';
 				pbuf = formatbuf;
 				len = formatfloat(pbuf, sizeof(formatbuf),
 						  flags, prec, c, v);

File Objects/unicodeobject.c

 	return -1;
     if (prec < 0)
 	prec = 6;
-    if (type == 'f' && (fabs(x) / 1e25) >= 1e25)
-	type = 'g';
+    if ((type == 'f' || type == 'F') && (fabs(x) / 1e25) >= 1e25) {
+        if (type == 'f')
+            type = 'g';
+        else
+            type = 'G';
+    }
     /* Worst case length calc to ensure no buffer overrun:
 
        'g' formats:
     */
     if (((type == 'g' || type == 'G') && 
           buflen <= (size_t)10 + (size_t)prec) ||
-	(type == 'f' && buflen <= (size_t)53 + (size_t)prec)) {
+	((type == 'f' || type == 'F')  &&
+          buflen <= (size_t)53 + (size_t)prec)) {
 	PyErr_SetString(PyExc_OverflowError,
 			"formatted float is too long (precision too large?)");
 	return -1;
 	    case 'F':
 	    case 'g':
 	    case 'G':
-		if (c == 'F')
-			c = 'f';
 		pbuf = formatbuf;
 		len = formatfloat(pbuf, sizeof(formatbuf)/sizeof(Py_UNICODE),
 			flags, prec, c, v);