strconv: format hex floats

This CL updates FormatFloat to format
standard hexadecimal floating-point constants,
using the 'x' and 'X' verbs.

See golang.org/design/19308-number-literals for background.

For #29008.

Change-Id: I540b8f71d492cfdb7c58af533d357a564591f28b
Reviewed-on: https://go-review.googlesource.com/c/160242
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

src/math/big/floatconv_test.go

@@ -268,7 +268,7 @@ func TestFloat64Text(t *testing.T) {
 		{32, 'g', -1, "32"},
 		{32, 'g', 0, "3e+01"},
 
-		{100, 'x', -1, "%x"},
+		// {100, 'x', -1, "%x"},
 
 		// {math.NaN(), 'g', -1, "NaN"},  // Float doesn't support NaNs
 		// {-math.NaN(), 'g', -1, "NaN"}, // Float doesn't support NaNs
@@ -440,8 +440,8 @@ func TestFloatText(t *testing.T) {
 		{"-1024.0", 64, 'p', 0, "-0x.8p+11"},
 
 		// unsupported format
-		{"3.14", 64, 'x', 0, "%x"},
-		{"-3.14", 64, 'x', 0, "%x"},
+		//{"3.14", 64, 'x', 0, "%x"},
+		//{"-3.14", 64, 'x', 0, "%x"},
 	} {
 		f, _, err := ParseFloat(test.x, 0, test.prec, ToNearestEven)
 		if err != nil {

src/strconv/ftoa.go

@@ -32,12 +32,14 @@ var float64info = floatInfo{52, 11, -1023}
 // 'e' (-d.dddde±dd, a decimal exponent),
 // 'E' (-d.ddddE±dd, a decimal exponent),
 // 'f' (-ddd.dddd, no exponent),
-// 'g' ('e' for large exponents, 'f' otherwise), or
-// 'G' ('E' for large exponents, 'f' otherwise).
+// 'g' ('e' for large exponents, 'f' otherwise),
+// 'G' ('E' for large exponents, 'f' otherwise),
+// 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or
+// 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent).
 //
 // The precision prec controls the number of digits (excluding the exponent)
-// printed by the 'e', 'E', 'f', 'g', and 'G' formats.
-// For 'e', 'E', and 'f' it is the number of digits after the decimal point.
+// printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats.
+// For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point.
 // For 'g' and 'G' it is the maximum number of significant digits (trailing
 // zeros are removed).
 // The special precision -1 uses the smallest number of digits
@@ -94,10 +96,13 @@ func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
 	}
 	exp += flt.bias
 
-	// Pick off easy binary format.
+	// Pick off easy binary, hex formats.
 	if fmt == 'b' {
 		return fmtB(dst, neg, mant, exp, flt)
 	}
+	if fmt == 'x' || fmt == 'X' {
+		return fmtX(dst, prec, fmt, neg, mant, exp, flt)
+	}
 
 	if !optimize {
 		return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
@@ -439,6 +444,89 @@ func fmtB(dst []byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
 	return dst
 }
 
+// %x: -0x1.yyyyyyyyp±ddd or -0x0p+0. (y is hex digit, d is decimal digit)
+func fmtX(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
+	if mant == 0 {
+		exp = 0
+	}
+
+	// Shift digits so leading 1 (if any) is at bit 1<<60.
+	mant <<= 60 - flt.mantbits
+	for mant != 0 && mant&(1<<60) == 0 {
+		mant <<= 1
+		exp--
+	}
+
+	// Round if requested.
+	if prec >= 0 && prec < 15 {
+		shift := uint(prec * 4)
+		extra := (mant << shift) & (1<<60 - 1)
+		mant >>= 60 - shift
+		if extra|(mant&1) > 1<<59 {
+			mant++
+		}
+		mant <<= 60 - shift
+		if mant&(1<<61) != 0 {
+			// Wrapped around.
+			mant >>= 1
+			exp++
+		}
+	}
+
+	hex := lowerhex
+	if fmt == 'X' {
+		hex = upperhex
+	}
+
+	// sign, 0x, leading digit
+	if neg {
+		dst = append(dst, '-')
+	}
+	dst = append(dst, '0', fmt, '0'+byte((mant>>60)&1))
+
+	// .fraction
+	mant <<= 4 // remove leading 0 or 1
+	if prec < 0 && mant != 0 {
+		dst = append(dst, '.')
+		for mant != 0 {
+			dst = append(dst, hex[(mant>>60)&15])
+			mant <<= 4
+		}
+	} else if prec > 0 {
+		dst = append(dst, '.')
+		for i := 0; i < prec; i++ {
+			dst = append(dst, hex[(mant>>60)&15])
+			mant <<= 4
+		}
+	}
+
+	// p±
+	ch := byte('P')
+	if fmt == lower(fmt) {
+		ch = 'p'
+	}
+	dst = append(dst, ch)
+	if exp < 0 {
+		ch = '-'
+		exp = -exp
+	} else {
+		ch = '+'
+	}
+	dst = append(dst, ch)
+
+	// dd or ddd or dddd
+	switch {
+	case exp < 100:
+		dst = append(dst, byte(exp/10)+'0', byte(exp%10)+'0')
+	case exp < 1000:
+		dst = append(dst, byte(exp/100)+'0', byte((exp/10)%10)+'0', byte(exp%10)+'0')
+	default:
+		dst = append(dst, byte(exp/1000)+'0', byte(exp/100)%10+'0', byte((exp/10)%10)+'0', byte(exp%10)+'0')
+	}
+
+	return dst
+}
+
 func min(a, b int) int {
 	if a < b {
 		return a

src/strconv/ftoa_test.go

@@ -30,9 +30,15 @@ var ftoatests = []ftoaTest{
 	{1, 'f', 5, "1.00000"},
 	{1, 'g', 5, "1"},
 	{1, 'g', -1, "1"},
+	{1, 'x', -1, "0x1p+00"},
+	{1, 'x', 5, "0x1.00000p+00"},
 	{20, 'g', -1, "20"},
+	{20, 'x', -1, "0x1.4p+04"},
 	{1234567.8, 'g', -1, "1.2345678e+06"},
+	{1234567.8, 'x', -1, "0x1.2d687cccccccdp+20"},
 	{200000, 'g', -1, "200000"},
+	{200000, 'x', -1, "0x1.86ap+17"},
+	{200000, 'X', -1, "0X1.86AP+17"},
 	{2000000, 'g', -1, "2e+06"},
 
 	// g conversion and zero suppression
@@ -50,6 +56,7 @@ var ftoatests = []ftoaTest{
 	{0, 'f', 5, "0.00000"},
 	{0, 'g', 5, "0"},
 	{0, 'g', -1, "0"},
+	{0, 'x', 5, "0x0.00000p+00"},
 
 	{-1, 'e', 5, "-1.00000e+00"},
 	{-1, 'f', 5, "-1.00000"},
@@ -100,7 +107,8 @@ var ftoatests = []ftoaTest{
 	{32, 'g', -1, "32"},
 	{32, 'g', 0, "3e+01"},
 
-	{100, 'x', -1, "%x"},
+	{100, 'x', -1, "0x1.9p+06"},
+	{100, 'y', -1, "%y"},
 
 	{math.NaN(), 'g', -1, "NaN"},
 	{-math.NaN(), 'g', -1, "NaN"},
@@ -128,6 +136,23 @@ var ftoatests = []ftoaTest{
 	// Issue 2625.
 	{383260575764816448, 'f', 0, "383260575764816448"},
 	{383260575764816448, 'g', -1, "3.8326057576481645e+17"},
+
+	// rounding
+	{2.275555555555555, 'x', -1, "0x1.23456789abcdep+01"},
+	{2.275555555555555, 'x', 0, "0x1p+01"},
+	{2.275555555555555, 'x', 2, "0x1.23p+01"},
+	{2.275555555555555, 'x', 16, "0x1.23456789abcde000p+01"},
+	{2.275555555555555, 'x', 21, "0x1.23456789abcde00000000p+01"},
+	{2.2755555510520935, 'x', -1, "0x1.2345678p+01"},
+	{2.2755555510520935, 'x', 6, "0x1.234568p+01"},
+	{2.275555431842804, 'x', -1, "0x1.2345668p+01"},
+	{2.275555431842804, 'x', 6, "0x1.234566p+01"},
+	{3.999969482421875, 'x', -1, "0x1.ffffp+01"},
+	{3.999969482421875, 'x', 4, "0x1.ffffp+01"},
+	{3.999969482421875, 'x', 3, "0x1.000p+02"},
+	{3.999969482421875, 'x', 2, "0x1.00p+02"},
+	{3.999969482421875, 'x', 1, "0x1.0p+02"},
+	{3.999969482421875, 'x', 0, "0x1p+02"},
 }
 
 func TestFtoa(t *testing.T) {

src/strconv/quote.go

@@ -11,7 +11,10 @@ import (
 	"unicode/utf8"
 )
 
-const lowerhex = "0123456789abcdef"
+const (
+	lowerhex = "0123456789abcdef"
+	upperhex = "0123456789ABCDEF"
+)
 
 func quoteWith(s string, quote byte, ASCIIonly, graphicOnly bool) string {
 	return string(appendQuotedWith(make([]byte, 0, 3*len(s)/2), s, quote, ASCIIonly, graphicOnly))