libgo: update to go1.9

    
    Reviewed-on: https://go-review.googlesource.com/63753

From-SVN: r252767

4 files changed, 88 insertions, 6 deletions

diff --git a/libgo/go/fmt/doc.go b/libgo/go/fmt/doc.go
index a2faecb..014ba06 100644
--- a/libgo/go/fmt/doc.go
+++ b/libgo/go/fmt/doc.go
@@ -38,7 +38,7 @@
 		%E	scientific notation, e.g. -1.234456E+78
 		%f	decimal point but no exponent, e.g. 123.456
 		%F	synonym for %f
-		%g	%e for large exponents, %f otherwise
+		%g	%e for large exponents, %f otherwise. Precision is discussed below.
 		%G	%E for large exponents, %F otherwise
 	String and slice of bytes (treated equivalently with these verbs):
 		%s	the uninterpreted bytes of the string or slice
@@ -94,7 +94,7 @@
 	precision sets the number of places after the decimal, if appropriate,
 	except that for %g/%G precision sets the total number of significant
 	digits. For example, given 12.345 the format %6.3f prints 12.345 while
-	%.3g prints 12.3. The default precision for %e and %f is 6; for %g it
+	%.3g prints 12.3. The default precision for %e, %f and %#g is 6; for %g it
 	is the smallest number of digits necessary to identify the value uniquely.
 
 	For complex numbers, the width and precision apply to the two
@@ -109,6 +109,8 @@
 			0X for hex (%#X); suppress 0x for %p (%#p);
 			for %q, print a raw (backquoted) string if strconv.CanBackquote
 			returns true;
+			always print a decimal point for %e, %E, %f, %F, %g and %G;
+			do not remove trailing zeros for %g and %G;
 			write e.g. U+0078 'x' if the character is printable for %U (%#U).
 		' '	(space) leave a space for elided sign in numbers (% d);
 			put spaces between bytes printing strings or slices in hex (% x, % X)
@@ -190,9 +192,9 @@
 	For example,
 		fmt.Sprintf("%[2]d %[1]d\n", 11, 22)
 	will yield "22 11", while
-		fmt.Sprintf("%[3]*.[2]*[1]f", 12.0, 2, 6),
+		fmt.Sprintf("%[3]*.[2]*[1]f", 12.0, 2, 6)
 	equivalent to
-		fmt.Sprintf("%6.2f", 12.0),
+		fmt.Sprintf("%6.2f", 12.0)
 	will yield " 12.00". Because an explicit index affects subsequent verbs,
 	this notation can be used to print the same values multiple times
 	by resetting the index for the first argument to be repeated:
diff --git a/libgo/go/fmt/fmt_test.go b/libgo/go/fmt/fmt_test.go
index ce00456..9e6fcfa 100644
--- a/libgo/go/fmt/fmt_test.go
+++ b/libgo/go/fmt/fmt_test.go
@@ -416,6 +416,32 @@ var fmtTests = []struct {
 	{"% .3g", 1.0, " 1"},
 	{"%b", float32(1.0), "8388608p-23"},
 	{"%b", 1.0, "4503599627370496p-52"},
+	// Test sharp flag used with floats.
+	{"%#g", 1e-323, "1.00000e-323"},
+	{"%#g", -1.0, "-1.00000"},
+	{"%#g", 1.1, "1.10000"},
+	{"%#g", 123456.0, "123456."},
+	{"%#g", 1234567.0, "1.234567e+06"},
+	{"%#g", 1230000.0, "1.23000e+06"},
+	{"%#g", 1000000.0, "1.00000e+06"},
+	{"%#.0f", 1.0, "1."},
+	{"%#.0e", 1.0, "1.e+00"},
+	{"%#.0g", 1.0, "1."},
+	{"%#.0g", 1100000.0, "1.e+06"},
+	{"%#.4f", 1.0, "1.0000"},
+	{"%#.4e", 1.0, "1.0000e+00"},
+	{"%#.4g", 1.0, "1.000"},
+	{"%#.4g", 100000.0, "1.000e+05"},
+	{"%#.0f", 123.0, "123."},
+	{"%#.0e", 123.0, "1.e+02"},
+	{"%#.0g", 123.0, "1.e+02"},
+	{"%#.4f", 123.0, "123.0000"},
+	{"%#.4e", 123.0, "1.2300e+02"},
+	{"%#.4g", 123.0, "123.0"},
+	{"%#.4g", 123000.0, "1.230e+05"},
+	{"%#9.4g", 1.0, "    1.000"},
+	// The sharp flag has no effect for binary float format.
+	{"%#b", 1.0, "4503599627370496p-52"},
 	// Precision has no effect for binary float format.
 	{"%.4b", float32(1.0), "8388608p-23"},
 	{"%.4b", -1.0, "-4503599627370496p-52"},
@@ -466,8 +492,24 @@ var fmtTests = []struct {
 	{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},
 	{"%+.3g", 1 + 2i, "(+1+2i)"},
 	{"%+.3g", complex64(1 + 2i), "(+1+2i)"},
+	{"%#g", 1 + 2i, "(1.00000+2.00000i)"},
+	{"%#g", 123456 + 789012i, "(123456.+789012.i)"},
+	{"%#g", 1e-10i, "(0.00000+1.00000e-10i)"},
+	{"%#g", -1e10 - 1.11e100i, "(-1.00000e+10-1.11000e+100i)"},
+	{"%#.0f", 1.23 + 1.0i, "(1.+1.i)"},
+	{"%#.0e", 1.23 + 1.0i, "(1.e+00+1.e+00i)"},
+	{"%#.0g", 1.23 + 1.0i, "(1.+1.i)"},
+	{"%#.0g", 0 + 100000i, "(0.+1.e+05i)"},
+	{"%#.0g", 1230000 + 0i, "(1.e+06+0.i)"},
+	{"%#.4f", 1 + 1.23i, "(1.0000+1.2300i)"},
+	{"%#.4e", 123 + 1i, "(1.2300e+02+1.0000e+00i)"},
+	{"%#.4g", 123 + 1.23i, "(123.0+1.230i)"},
+	{"%#12.5g", 0 + 100000i, "(      0.0000 +1.0000e+05i)"},
+	{"%#12.5g", 1230000 - 0i, "(  1.2300e+06     +0.0000i)"},
 	{"%b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
 	{"%b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
+	// The sharp flag has no effect for binary complex format.
+	{"%#b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
 	// Precision has no effect for binary complex format.
 	{"%.4b", 1 + 2i, "(4503599627370496p-52+4503599627370496p-51i)"},
 	{"%.4b", complex64(1 + 2i), "(8388608p-23+8388608p-22i)"},
diff --git a/libgo/go/fmt/format.go b/libgo/go/fmt/format.go
index f770483..d4b92f8 100644
--- a/libgo/go/fmt/format.go
+++ b/libgo/go/fmt/format.go
@@ -480,6 +480,46 @@ func (f *fmt) fmt_float(v float64, size int, verb rune, prec int) {
 		f.zero = oldZero
 		return
 	}
+	// The sharp flag forces printing a decimal point for non-binary formats
+	// and retains trailing zeros, which we may need to restore.
+	if f.sharp && verb != 'b' {
+		digits := 0
+		switch verb {
+		case 'v', 'g', 'G':
+			digits = prec
+			// If no precision is set explicitly use a precision of 6.
+			if digits == -1 {
+				digits = 6
+			}
+		}
+
+		// Buffer pre-allocated with enough room for
+		// exponent notations of the form "e+123".
+		var tailBuf [5]byte
+		tail := tailBuf[:0]
+
+		hasDecimalPoint := false
+		// Starting from i = 1 to skip sign at num[0].
+		for i := 1; i < len(num); i++ {
+			switch num[i] {
+			case '.':
+				hasDecimalPoint = true
+			case 'e', 'E':
+				tail = append(tail, num[i:]...)
+				num = num[:i]
+			default:
+				digits--
+			}
+		}
+		if !hasDecimalPoint {
+			num = append(num, '.')
+		}
+		for digits > 0 {
+			num = append(num, '0')
+			digits--
+		}
+		num = append(num, tail...)
+	}
 	// We want a sign if asked for and if the sign is not positive.
 	if f.plus || num[0] != '+' {
 		// If we're zero padding to the left we want the sign before the leading zeros.
diff --git a/libgo/go/fmt/print.go b/libgo/go/fmt/print.go
index a7ef2e5..2bd88f9 100644
--- a/libgo/go/fmt/print.go
+++ b/libgo/go/fmt/print.go
@@ -684,8 +684,6 @@ func (p *pp) printArg(arg interface{}, verb rune) {
 	}
 }
 
-var byteType = reflect.TypeOf(byte(0))
-
 // printValue is similar to printArg but starts with a reflect value, not an interface{} value.
 // It does not handle 'p' and 'T' verbs because these should have been already handled by printArg.
 func (p *pp) printValue(value reflect.Value, verb rune, depth int) {